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:

Friday, October 21, 2011

Solución a 1785 - Lost in Localization [http://acm.timus.ru]

Solución a 1785 - Lost in Localization [http://acm.timus.ru]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 1785 - Lost in Localization [http://acm.timus.ru]
 * 
 * @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
  short n; // para el numero a evaluar

  // AQUI INICIA EL PROGRAMA!!!
  Lee = new Scanner(System.in);
  while (Lee.hasNext()) {
   n = Lee.nextShort();
   // evaluamos
   if (n > 4)
    if (n > 9)
     if (n > 19)
      if (n > 49)
       if (n > 99)
        if (n > 249)
         if (n > 499)
          if (n > 999)
           System.out.println("legion");
          else
           System.out.println("zounds");
         else
          System.out.println("swarm");
        else
         System.out.println("throng");
       else
        System.out.println("horde");
      else
       System.out.println("lots");
     else
      System.out.println("pack");
    else
     System.out.println("several");
   else
    System.out.println("few");
  }
 }
}
Publicado por en No comments:

Solución a 2052 - Number Steps [ACM - ICPC]

Solución a 2052 - Number Steps [ACM - ICPC]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 2052 - Number Steps [ACM - ICPC]
 * 
 * @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
  int N; // el numero de casos de prueba
  short x, y; // pra las coordenadas
  short[][] mat; // matriz para generar los numeros

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  mat = generarMatriz();
  N = Lee.nextInt();
  while(N > 0){
   x = Lee.nextShort();
   y = Lee.nextShort();
   if(x == 0 && y == 0)
    System.out.println("0");
   else{
    if(mat[y][x] > 0)
     System.out.println(mat[y][x]);
    else
     System.out.println("No Number");
   }
   N--;
  }
 }
 /** Funcion que genera la matriz para que luego sea evaluada por el programa */
 private static short[][] generarMatriz() {
  short[][] r = new short[5002][5002];
  short c = 1; // valor acumulable
  boolean sw = true;
  for(short i = 1; i < 5001; i++){
   if(sw){
    r[i][i] = c++;
    r[i - 1][i + 1] = c++;
   }
   else{
    r[i - 1][i + 1] = c++;
    r[i][i] = c++;
   }
   sw = !sw;
  }
  return r;
 }
}
Publicado por en No comments:

Thursday, October 20, 2011

Solución a 2070 - Simple Encryption [ACM-ICPC]

Solución a 2070 - Simple Encryption [ACM-ICPC]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 2070 - Simple Encryption [ACM-ICPC]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datosd e entrada
  byte numCol; // numero de columnas
  int numFil; // numero de filas
  String cadena; // cadena a desencriptar
  char[][] mat; // matriz de caracteres
  int i, j; // para los bucles

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  numCol = Lee.nextByte();
  while(numCol != 0){
   cadena = Lee.next();
   numFil = cadena.length() / numCol;
   mat = new char[numFil][numCol];
   // llenamos la matriz
   j = 0;
   for(i = 0; i < numFil; i++){
    mat[i] = cadena.substring(j, j + numCol).toCharArray();
    j += numCol;
   }
   // mostramos la matriz
   mostrarMatriz(mat);
   numCol = Lee.nextByte();
  }
 }
 /** Procedimiento que evalua la matriz y muestra el resultado */
 private static void mostrarMatriz(char[][] mat) {
  int numFil = mat.length;
  int numCol = mat[0].length;
  int i, j, k;
  i = 0;
  j = 0;
  k = 1;
  while(k <= numFil + numCol - 1){
   System.out.print(mat[i][j]);
   i++;
   j--;
   if(j < 0 || i >= numFil){
    if(k < numCol){
     j = k;
     i = 0;
    }
    else{
     j = numCol - 1;
     i = k - numCol + 1;
    }
    k++;
   }
  }
  System.out.println();
 }
}
Publicado por en No comments:

Saturday, October 15, 2011

Solución a G. Prediction Contest [http://acm.timus.ru]

Solución a G. Prediction Contest [http://acm.timus.ru]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * G. Prediction Contest [http://acm.timus.ru]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee, LeerLinea;
  byte n;
  int nk;
  String[] ganadores = new String[12];
  int i, j;
  int sum; // monto total a pagar
  String universidad;
  byte premio;
  int[] sumParcial;
  int sumMayor;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  while (Lee.hasNextLine()) {
   sumMayor = 0;
   for (i = 0; i < 12; i++)
    ganadores[i] = Lee.nextLine();
   n = (new Scanner(Lee.nextLine()).nextByte());
   sumParcial = new int[n];
   for (j = 0; j < n; j++) {
    nk = (new Scanner(Lee.nextLine()).nextInt());
    while (nk > 0) {
     LeerLinea = new Scanner(Lee.nextLine());
     universidad = LeerLinea.next();
     LeerLinea.next();
     switch (LeerLinea.next().charAt(0)) {
     case 'g':
      premio = 4;
      break;
     case 's':
      premio = 8;
      break;
     default:
      premio = 12;
      break;
     }
     // aqui se hace el proceso
     for (i = premio - 4; i < premio; i++) {
      if (ganadores[i].contentEquals(universidad)
        || universidad.contentEquals(ganadores[i]))
       sumParcial[j]++;
     }
     nk--;
    }
    if (sumParcial[j] > sumMayor)
     sumMayor = sumParcial[j];
   }
   // sumamos 5 por cada uno que logro el maximo
   sum = 0;
   for (i = 0; i < n; i++) {
    if (sumParcial[i] == sumMayor)
     sum += 5;
   }
   System.out.println(sum);
  }
 }
}
Publicado por en No comments:

Solución a 1293 - Eniya [http://acm.timus.ru]

Solución a 1293 - Eniya [http://acm.timus.ru]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 1293 - Eniya [http://acm.timus.ru]
 * 
 * @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
  byte N, A, B;

  // EL PROGRAMA INICIA AQUI
  Lee = new Scanner(System.in);
  while (Lee.hasNext()) {
   N = Lee.nextByte();
   A = Lee.nextByte();
   B = Lee.nextByte();
   System.out.println(A * B * 2 * N);
  }
 }
}
Publicado por en No comments:

Solución a 1068. Sum [http://acm.timus.ru]

Solución a 1068. Sum [http://acm.timus.ru]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * 1068 - Sum [http://acm.timus.ru]
 * 
 * @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
  int sum;
  short N;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  while (Lee.hasNext()) {
   sum = 0;
   N = Lee.nextShort();
   if (N >= 1)
    while (N >= 1) {
     sum += N;
     N--;
    }
   else
    while (N <= 1) {
     sum += N;
     N++;
    }
   System.out.println(sum);
  }
 }
}
Publicado por en No comments:

Saturday, October 08, 2011

Solución al problema Factorial - Problem code: FCTRL [http://www.codechef.com]

Solución al problema Factorial - Problem code: FCTRL [http://www.codechef.com]
El enunciado del problema esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * Factorial - Problem code: FCTRL [http://www.codechef.com]
 * 
 * @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
		int T; // para leer cuantos TEST se debe realizar

		// AQUI INICIA EL PROGRAMA
		Lee = new Scanner(System.in);
		// leemos T
		T = Lee.nextInt();
		while (T > 0) {
			System.out.println(funcionZ(Lee.nextInt()));
			T--;
		}
	}

	/** Función Z de N */
	private static int funcionZ(int n) {
		int r = 0;
		while (n >= 5) {
			n /= 5;
			r += n;
		}
		return r;
	}
}
Publicado por en No comments:

Solución al problema ATM Problem code: HS08TEST [http://www.codechef.com]

Solución al problema  HS08TEST - ATM  [http://www.codechef.com]
el enunciado esta en el siguiente link enunciado

import java.util.Scanner;

/**
 * ATM Problem code: HS08TEST [http://www.codechef.com]
 * 
 * @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
  int montoRetirar; // monto a retirar
  int saldo; // saldo multiplicado por dos

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  while (Lee.hasNext()) {
   montoRetirar = Lee.nextInt() * 100;
   saldo = (int) (Double.parseDouble(Lee.next()) * 100);
   // preguntar si hay saldo suficiente
   if (montoRetirar <= saldo - 50) {
    // preguntar si el monto es multiplo de 5
    if (montoRetirar % 500 == 0) {
     saldo -= montoRetirar;
     saldo -= 50;
    }
   }
   // mostramos el saldo sobrante
   System.out.println(String.format("%.2f", ((double) (saldo) / 100))
     .replace(',', '.'));
  }
 }
}
Publicado por en No comments:

Solución al problema Life, the Universe, and Everything Problem code: TEST [http://www.codechef.com]

Solución al problema Life, the Universe, and Everything Problem code: TEST [http://www.codechef.com]
El enunciado esta en este link enunciado

import java.util.Scanner;

/**
 * Life, the Universe, and Everything Problem code: TEST
 * [http://www.codechef.com]
 * 
 * @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
		byte num; // para leer el numero y mostrarlo

		// Aqui inicia el programa
		Lee = new Scanner(System.in);
		num = Lee.nextByte();
		while (num != 42) {
			System.out.println(num);
			num = Lee.nextByte();
		}
	}
}
Publicado por en No comments:

Wednesday, October 05, 2011

LAB-131

 Ejercicios para Paralelo D DEF3 LAB-131-2011
puedes descargarlo de aqui
http://www.4shared.com/document/KqSWvDCj/Ejercicios_para_Paralelo_D_DEF.html

Solo para los alumnos de LAB-131 Paralelo D Informatica UMSA.
Los informes deben tener los siguientes puntos.
- Enunciado
- Analisis del problema
- Diagrama de clases
- Codigo manuscritos solo de las funciones y métodos que se implementen para la solucion detallando a que clase pertenecen, no es necesario escribir todo el código (Solo escribir sus metodos implementados por ustedes).
- Captura de pantalla de la ejecucion.

Notas preliminares de Informe de Laboratorio de LAB-131 Paralelo D
Lic. Tarquino

Nº
Nombre
CI
Informes de Laboratorio 3 pts. cada uno
Total

1º P-CC
2º MP-MC
3º
4º
5º

1
Alfaro Jemio Miguel Alejandro
4782715
2,0
2,0






4,0

2
Aruquipa Machaca Marco Antonio
6890329
1,0








1,0

3
Atahuachi Mamani Rubén Ricardo
6084913
1,0
0,8






1,8

4
Bravo Lecoña Gladys
6791524
3,0
3,0






6,0

5
Callizaya Coquendo Efraín
6956383
1,8
2,0






3,8

6
Chávez Reyes Alex Rodrigo
8326973
0,7
2,0






2,7

7
Choque Mendoza Ever Edson
7015803
2,5








2,5

8
Chura Mamani Sergio Raúl
6068525
2,5








2,5

9
Copa Pariapaza Yerson Marvin


3,0
2,0






5,0

10
Espinal Alvarez Iván Sergio
8264274
3,0
3,0






6,0

11
Espinoza Tito Priscila Wendy
8341027
3,0
3,0






6,0

12
Gutiérrez Titirico D'Jalmar
6867562
1,1
3,0






4,1

13
Huallpara Meicias Israel José




1,0






1,0

14
Ibañes Yujra David Isrrael


1,4
3,0






4,4

15
Limachi Mamani Nandy Rocio
6073715
0,7








0,7

16
Pederma Parada Daniel Mauricio
4771462
3,0
3,0






6,0

17
Rojas Febrero María Luisa


0,7








0,7

18
Villar Pabón Siacir
4904503
1,0
0,8






1,8



Cualquier consulta o reclamo, comenten aqui, o escriban abreakdark666@yahoo.es
jrmonnroy@umsa.bo

SALUDOS
Publicado por en No comments:
Etiquetas:
Subscribe to: Posts (Atom)