BreakDark

Solución al problema: 10783 - Odd Sum con Java

2018-01-22T17:37:00.003-08:00

Para ver el link del problema Click aqui

import java.util.BitSet;
import java.util.Scanner;

/**
 * Solución a 10783 - Odd Sum [https://uva.onlinejudge.org/]
 *
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 24 nov. de 2017
 */
// Accepted!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee = new Scanner(System.in);
  int t, a, b, i, j, sum;
  BitSet impares = new BitSet(101);
  for (i = 1; i <= 100; i += 2)
   impares.set(i);

  // AQUI INICIA EL PROGRAMA
  t = Lee.nextInt();
  for (i = 1; i <= t; i++) {
   a = Lee.nextInt();
   b = Lee.nextInt();
   sum = 0;
   for (j = a; j <= b; j++) {
    if (impares.get(j))
     sum += j;
   }
   System.out.println("Case " + i + ": " + sum);
  }
  Lee.close();
 }
}

Solución al problema: 488 - Triangle Wave con Java

2018-01-22T17:31:00.002-08:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 488 - Triangle Wave [http://uva.onlinejudge.org]
 * 
 * @author BreakDark
 * @version 2.0 beta
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de entrada
        int numcasos; // para el numero de casos
        byte amplitud; // para la amplitud
        int frecuencia; // frecuencia
        int i; // para los bucles
        // vector de ondas
        String[] vec = {"", "1", "1\n22\n1", "1\n22\n333\n22\n1", "1\n22\n333\n4444\n333\n22\n1", "1\n22\n333\n4444\n55555\n4444\n333\n22\n1",
                "1\n22\n333\n4444\n55555\n666666\n55555\n4444\n333\n22\n1",
                "1\n22\n333\n4444\n55555\n666666\n7777777\n666666\n55555\n4444\n333\n22\n1",
                "1\n22\n333\n4444\n55555\n666666\n7777777\n88888888\n7777777\n666666\n55555\n4444\n333\n22\n1",
                "1\n22\n333\n4444\n55555\n666666\n7777777\n88888888\n999999999\n88888888\n7777777\n666666\n55555\n4444\n333\n22\n1"};

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        numcasos = Lee.nextInt();
        while(numcasos-- > 0){
            amplitud = Lee.nextByte();
            frecuencia = Lee.nextInt();
            for(i = 0; i < frecuencia; i++){
                System.out.println(vec[amplitud]);
                if(i < frecuencia - 1 || numcasos > 0)
                    System.out.println();
            }
        }
    }
}

Solución al problema: 106 - Fermat vs Pythagoras con Java

2018-01-22T17:20:00.001-08:00

Para ver el link del problema Click aqui

import java.util.BitSet;
import java.util.Scanner;

/**
 * 106 - Fermat vs. Pythagoras [http://uva.onlinejudge.org]
 * 
 * @author BreakDark
 * @version 3.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // Para leer los datos de entrada
  int N; // para el N a leer

  // AQUI INICIA EL PROGRAMA!!!
  Lee = new Scanner(System.in);
  while(Lee.hasNext()){
   N = Lee.nextInt();
   calcula(N);
  }
 }
 /**
  * Procedimiento que realiza todo el trabajo
  * 
  * @param N
  *            el numero a procesar
  */
 private static void calcula(int N) {
  int cont = 0;
  int numUsados = 0;
  int r, s, i, x, y, z;
  BitSet numeros = new BitSet(N + 1);

  for(r = 2; r * r <= N; r++)
   for(s = 1; s < r && r * r + s * s <= N; s++){
    x = r * r - s * s;
    y = 2 * r * s;
    z = r * r + s * s;
    if(mcd(x, y) == 1){
     cont++;
     for(i = 1; z * i <= N; i++){
      if(!numeros.get(x * i)){
       numUsados++;
       numeros.set(x * i);
      }
      // para y
      if(!numeros.get(y * i)){
       numUsados++;
       numeros.set(y * i);
      }
      // para z
      if(!numeros.get(z * i)){
       numUsados++;
       numeros.set(z * i);
      }
     }
    }
   }
  System.out.println(cont + " " + (N - numUsados));
 }
 /**
  * Funcion que encuentra el MCD de dos enteros basado en el slgoritmo de
  * euclides
  * 
  * @param a
  *            entero a evaluar el MCD
  * @param b
  *            entero a evaluar el MCD
  * @return el MCD de a y b
  */
 private static int mcd(int a, int b) {
  int r;
  if(b > a){
   r = a;
   a = b;
   b = r;
  }
  r = b;
  while(b > 0){
   r = a % b;
   a = b;
   b = r;
  }
  return a;
 }
}

Solución al problema: 10004 - Islas [http://acm.cs.buap.mx] con Java

2017-02-25T05:13:00.001-08:00

Para ver el link del problema Click aqui

import java.util.Scanner;
import java.util.Stack;

/**
 * Solución al problema: 10004 - Islas [http://acm.cs.buap.mx]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0b 18 feb. 2017
 */
// ACETTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int n; // dimension del mapa
  char[][] mapa;
  int i; // para los bucles

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  do {
   n = Lee.nextInt();
   if (n > 0) {
    mapa = new char[n][n];
    for (i = 0; i < n; i++) {
     mapa[i] = Lee.next().toCharArray();
    }
    System.out.println(obtenerSolucion(n, mapa));
   }
  } while (Lee.hasNext() && n != 0);
  Lee.close();
 }

 /**
  * Metodo que obtiene la solucion del problema
  * 
  * @param n
  *            Dimension del mapa
  * @param mapa
  *            Matriz que representa el mapa
  * @return Un String que representa la solucion
  */
 public static String obtenerSolucion(int n, char[][] mapa) {
  int[][] mp = new int[n][n]; // mapa de numeros
  // int[] dimIslas = new int[n * n]; // dimension de las islas
  int numIsla = 0;
  int i, j; // para los bucles

  // recorremos la matriz del mapa
  for (i = 0; i < n; i++) {
   for (j = 0; j < n; j++) {
    if (mapa[i][j] != 'm') {
     // pintamos la isla
     if (mp[i][j] == 0) {
      // si no esta pintado ya
      Stack pila = new Stack();
      pila.push(i); // introcucimos la primera coordenada
      pila.push(j);
      while (!pila.isEmpty()) {
       int ind_j = pila.pop();
       int ind_i = pila.pop();
       // System.out.println(ind_j + "," + ind_i);
       // buscamos los alrededores
       // coordenada NorOeste
       if (ind_i > 0 && ind_j > 0 && mapa[ind_i - 1][ind_j - 1] == 't'
         && mp[ind_i - 1][ind_j - 1] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j - 1);
       }
       // coordenada Norte
       if (ind_i > 0 && mapa[ind_i - 1][ind_j] == 't' && mp[ind_i - 1][ind_j] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j);
       }
       // coordenada NorEste
       if (ind_i > 0 && ind_j + 1 < n && mapa[ind_i - 1][ind_j + 1] == 't'
         && mp[ind_i - 1][ind_j + 1] == 0) {
        pila.push(ind_i - 1);
        pila.push(ind_j + 1);
       }
       // Oeste
       if (ind_j > 0 && mapa[ind_i][ind_j - 1] == 't' && mp[ind_i][ind_j - 1] == 0) {
        pila.push(ind_i);
        pila.push(ind_j - 1);
       }
       // coordenada Este
       if (ind_j + 1 < n && mapa[ind_i][ind_j + 1] == 't' && mp[ind_i][ind_j + 1] == 0) {
        pila.push(ind_i);
        pila.push(ind_j + 1);
       }
       // coordenada SurOeste
       if (ind_i + 1 < n && ind_j > 0 && mapa[ind_i + 1][ind_j - 1] == 't'
         && mp[ind_i + 1][ind_j - 1] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j - 1);
       }
       // coordenada Sur
       if (ind_i + 1 < n && mapa[ind_i + 1][ind_j] == 't' && mp[ind_i + 1][ind_j] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j);
       }
       // coordenada SurEste
       if (ind_i + 1 < n && ind_j + 1 < n && mapa[ind_i + 1][ind_j + 1] == 't'
         && mp[ind_i + 1][ind_j + 1] == 0) {
        pila.push(ind_i + 1);
        pila.push(ind_j + 1);
       }
       mp[ind_i][ind_j] = numIsla + 1;
      }
      numIsla++;
     }
    }
   }
  }

  // si no hay islas o solo hay una
  if (numIsla == 0)
   return "No hay islas";
  if (numIsla == 1)
   return "Solo hay una isla";

  // buscamos el menor y la mayor dimension
  int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
  for (int isla = 1; isla <= numIsla; isla++) {
   int cont = 0;
   for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
     if (mp[i][j] > 0 && mp[i][j] == isla)
      cont++;
   if (cont > 0 && cont < min)
    min = cont;
   if (cont > max)
    max = cont;
  }
  return min + " " + max;
 }
}

Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx] con Java

2017-02-25T05:07:00.000-08:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx]
 */

/**
 * @author BreakDark (Jhonny Monrroy)
 * @version 2.0 b 18 feb. 2017
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para los datos de entrada
  int r, n; /// radio y numero de intentos

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  do {
   r = Lee.nextInt();
   n = Lee.nextInt();
   if (r != 0 && n != 0)
    System.out.println(obtenerSolucion(r, n));
  } while (Lee.hasNext() && r != 0 && n != 0);
  Lee.close();
 }

 /**
  * Metodo que obtiene la solucion del problema
  * 
  * @param r
  *            Radio del corral
  * @param n
  *            Numero de intentos
  * @return Un String que representa la distancia del burrito al poste
  */
 public static String obtenerSolucion(int r, int n) {
  double x = 0, y = 0; // coordenadas del burrito
  byte dir = 0; // 0=norte, 1=este, 2=sur, 3=oeste

  while (n-- > 0) {
   switch (dir) {
   case 0: // norte
    y = (y + Math.sqrt(r * r - x * x)) / 2;
    break;
   case 1: // este
    x = (x + Math.sqrt(r * r - y * y)) / 2;
    break;
   case 2: // sur
    y = (y - Math.sqrt(r * r - x * x)) / 2;
    break;
   default: // oeste
    x = (x - Math.sqrt(r * r - y * y)) / 2;
    dir = -1; // para volver a empezar desde el principio
    break;
   }
   dir++;
  }
  // mostramos el resultado
  return String.format("%.2f", Math.sqrt(x * x + y * y)).replace(',', '.');
 }
}

Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx] con Java

2017-02-25T05:02:00.000-08:00

Para ver el link del problema Click aqui

import java.util.BitSet;
import java.util.PriorityQueue;
import java.util.Scanner;

/**
 * Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx]
 * 
 * @author BreakDark
 * @version 1.0b 17 feb. 2017
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int n; // numero de casos de prueba
  String p; // nombre de la poblacion
  String s; // informacion de los cultivos

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  n = Integer.parseInt(Lee.nextLine());
  while (n-- > 0) {
   p = Lee.nextLine();
   s = Lee.nextLine();
   System.out.print(procesar(p, s));
  }
  Lee.close();
 }

 /**
  * Metodo que resueleve el problema
  * 
  * @param p
  *            Nombre de la poblacion
  * @param s
  *            Informacion de los cultivos
  */
 static String procesar(String p, String s) {
  String resp = "";
  // contamos los cultivos
  int dim = 'z' - 'a' + 1, i;
  BitSet tipoCultivos = new BitSet(dim - 1);
  char letra;
  int d = 0; // desconocidos
  int[] cultivos = new int[dim];
  for (i = 0; i < s.length(); i++) {
   letra = s.charAt(i);
   if (letra != '*') {
    tipoCultivos.set(letra - 'a');
    cultivos[letra - 'a']++;
   } else
    d++;
  }
  resp += "POBLACION: " + p + "\n";
  resp += "TIPOS DE CULTIVOS: " + tipoCultivos.cardinality() + "\n";
  resp += "DESCONOCIDOS: " + d + "\n";
  resp += "CANTIDADES:" + "\n";
  // mostramos los conteos de los cultivos
  PriorityQueue cola = new PriorityQueue();
  for (i = 0; i < dim; i++) {
   // adicionamos los valores a una cola de prioridad
   if (cultivos[i] > 0)
    cola.add(new CultivoValor((char) ('a' + i), cultivos[i]));
   // resp += (char) ('a' + i) + " - " + cultivos[i] + "\n";
  }
  // mostramos la cola
  while (!cola.isEmpty()) {
   CultivoValor cv = cola.poll();
   resp += cv.cult + " - " + cv.val + "\n";
  }
  return resp;
 }
}

class CultivoValor implements Comparable {
 char cult;
 int val;

 public CultivoValor(char c, int v) {
  this.cult = c;
  this.val = v;
 }

 @Override
 public int compareTo(CultivoValor X) {
  if (X.val - this.val == 0)
   return this.cult - X.cult;
  return X.val - this.val;
 }
}

Solucion al Problema: 1354 – IP Checking [http://lightoj.com/] con Java

2016-09-15T20:54:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 1354 – IP Checking [http://lightoj.com/]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 14 ago. 2016
 */
// Accepted!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int T; // numero de casos de prueba
  String ipDecimal, ipBinario;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextInt();
  for (int i = 1; i <= T; i++) {
   ipDecimal = Lee.next();
   ipBinario = Lee.next();
   String aux = Short.parseShort(ipBinario.substring(0, 8), 2) + ".";
   aux += Short.parseShort(ipBinario.substring(9, 17), 2) + ".";
   aux += Short.parseShort(ipBinario.substring(18, 26), 2) + ".";
   aux += Short.parseShort(ipBinario.substring(27), 2);
   System.out.println("Case " + i + ": " + (ipDecimal.equals(aux) ? "Yes" : "No"));
  }
  Lee.close();
 }
}

Solucion al Problema: 1293 - Document Analyzer [http://lightoj.com/] con C++

2016-09-15T20:45:00.004-07:00

Para ver el link del problema Click aqui

//============================================================================
// Name        : 1293.cpp
// Author      : BreakDark (Jhonny Monrroy) basado en la solucion publicada en [http://www.cnblogs.com/njczy2010/p/4337078.html]
// Version     : 3.0 16/09/2016
// Copyright   : (Solucion obtenida de [http://www.cnblogs.com/njczy2010/p/4337078.html])
// Description : Solucion al Problema: 1293 - Document Analyzer [http://lightoj.com/]
//============================================================================

// Accepted!!! xD

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <sstream>
#include <map>

using namespace std;

int T; // para el numero de casos de prueba
int t; // indice

/**
 * Metodo procesarPalabra: reemplaza los caracteres que no son letras por
 * espacios
 *
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 20 ago. 2016
 * @param palabra
 *            Cadena a procesar
 * @return Retorna la cadena ya proceesda
 */
string procesarPalabra(string palabra) {
 string nuevaLinea = "";
 char letra;
 for (int i = 0; i < palabra.length(); i++) {
  letra = palabra[i];
  if (letra >= 'a' && letra <= 'z') {
   nuevaLinea += letra;
  } else {
   nuevaLinea += ' ';
  }
 }
 return nuevaLinea;
}

/**
 * Metodo obtenerRangoMenor: Metodo que busca el rango menor para este
 * problema
 *
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 20 ago. 2016
 * @param vecPal
 *            Vector de palabras
 * @param numPal
 *            Numero de palabras del vector
 * @param hashPal
 *            HashMap de palabras no iguales
 */
void obtenerRangoMenor(string vecPal[], int numPal, map<string, int> hashPal) {
 int p = -1;
 int q = numPal + 1;
 int posible_p, posible_q;
 int cont = 0; // contador de palabras encontradas
 posible_p = 0;
 posible_q = 0;
 while (posible_p < numPal) {
  for (; posible_q < numPal; posible_q++) {
   hashPal[vecPal[posible_q]]++;
   if (hashPal[vecPal[posible_q]] == 1)
    cont++;
   if (cont == hashPal.size()) {
    for (; posible_p <= posible_q; posible_p++) {
     if (hashPal[vecPal[posible_p]] == 1) {
      if (posible_q - posible_p < q - p) {
       p = posible_p;
       q = posible_q;
      } else if (posible_q - posible_p == q - p) {
       if (posible_p < p) {
        p = posible_p;
        q = posible_q;
       }
      }
      hashPal[vecPal[posible_p]]--;
      cont--;
      posible_p++;
      posible_q++;
      break;
     }
     hashPal[vecPal[posible_p]]--;
    }
    break;
   }
  }
  if (posible_q == numPal)
   break;
 }
 printf("Case %d: %d %d\n", t, (p + 1), (q + 1));
}

int main() {
 //int T; // para el numero de casos de prueba
 string palabra; // para cada palabra
 char linea[102]; // para la linea que se lea
 string linea_s;

 string palabras[50000]; // vector de palabras
 int numPal; // para el numero de palabras a almacenar
 map<string, int> hashPalabras; // conjunto de palabras no repetidas

 // AQUI INICIA EL PROGRAMA
 scanf("%d", &T);
 for (t = 1; t <= T; t++) {
  numPal = 0; // vaciamos el vector
  hashPalabras.clear();
  while (scanf("%s", linea) != EOF && strcmp(linea, "END") != 0) {
   char nuevaLinea[102] = "";
   char letra;
   for (int i = 0; i < strlen(linea); i++) {
    letra = linea[i];
    if (letra >= 'a' && letra <= 'z') {
     nuevaLinea[strlen(nuevaLinea)] = letra;
    } else {
     strcat(nuevaLinea, " ");
    }
   }
   strcpy(linea, nuevaLinea);
   //cout<<linea<<endl;
   char *vecPalabras;
   vecPalabras = strtok(linea, " ");
   while (vecPalabras != NULL) {
    //printf("%s\n", vecPalabras);
    palabras[numPal] = vecPalabras;
    stringstream ss;
    ss << palabras[numPal];
    ss >> linea_s;

    hashPalabras[linea_s] = 0; // seleccionamos palabras distintas
    numPal++;
    vecPalabras = strtok(NULL, " ");
   }
  }
  obtenerRangoMenor(palabras, numPal, hashPalabras);
 }
 return 0;
}

Solucion al Problema: 1109 - False Ordering [http://lightoj.com/] con Java

2016-09-15T20:39:00.005-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 1109 - False Ordering [http://lightoj.com/]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 13 ago. 2016
 */
// Accepted!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int t; // numero de casos
  int n; // numero a evaluar
  int vecDiv[]; // vector para almacenar cantidad de veces que es divisor
                // cada indice
  int vecNum[]; // numero de los valores que seran ordenados
  int limite = 1001; // para el limite de las operaciones

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  // generamos el vector de num de divisores
  vecDiv = new int[limite + 1];
  vecNum = new int[limite + 1];
  for (int i = 1; i <= limite; i++) {
   for (int j = i; j <= limite; j += i) {
    vecDiv[j]++;
   }
   vecNum[i] = i;
  }

  // ordenamos los valores por el metodo burbuja adecauado al problema
  for (int i = 1; i < limite - 1; i++) {
   for (int j = i + 1; j < limite; j++) {
    int x = vecNum[j];
    int y = vecNum[i];
    if (vecDiv[x] < vecDiv[y] || (vecDiv[x] == vecDiv[y] && x > y)) {
     int aux = vecNum[i];
     vecNum[i] = vecNum[j];
     vecNum[j] = aux;
    }
   }
  }

  // leemos los datos
  t = Lee.nextInt();
  for (int i = 1; i <= t; i++) {
   n = Lee.nextInt();
   System.out.println("Case " + i + ": " + vecNum[n]);
  }
  Lee.close();
 }
}

Solucion al Problema: 1072 – Calm Down [http://lightoj.com/] con Java

2016-09-15T20:37:00.004-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 1072 – Calm Down [http://lightoj.com/]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 14 ago. 2016
 */
// Accepted!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  int T; // numero de casos de prueba
  double R; // para el radio
  int n; // numero re balas esperado
  double r; // radio buscado

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextInt();
  for (int i = 1; i <= T; i++) {
   R = Double.parseDouble(Lee.next());
   n = Lee.nextInt();
   double angulo = 2 * Math.PI / n;
   double senoAngulo = Math.sin(angulo / 2);
   r = R * senoAngulo / (1 + senoAngulo);
   if (r == (int) r) {
    System.out.println(String.format("Case %d: %d", i, (int) r));
   } else {
    System.out.println(String.format("Case %d: %.10f", i, r).replace(',', '.'));
   }
  }
  Lee.close();
 }
}

Solucion al Problema: 1043 - Triangle Partitioning [http://lightoj.com/] con java

2016-09-15T20:35:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 1043 - Triangle Partitioning [http://lightoj.com/]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 08/10/2013
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  byte T, caso; // para los casos de entrada
  double AB, AC, BC; // para los lados del triangulo
  double r; // para el radio de las areas
  double Area, Area1, Area2; // para las areas
  double SenoDeAlpha; // Seno de Alfa
  double h, h1, h2; // la altura del triangulo inicial
  double AD; // longitud superior del trapecio, y la longitud buscada

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextByte();
  for (caso = 1; caso <= T; caso++) {
   // leemos la informacion
   AB = Lee.nextDouble();
   AC = Lee.nextDouble();
   BC = Lee.nextDouble();
   r = Lee.nextDouble();
   // obtenemos el area del traingulo
   Area = areaDelTriangulo(AB, AC, BC);
   h = 2 * Area / BC;
   Area2 = Area / (r + 1);
   Area1 = Area - Area2;
   // obtenemos el seno del angulo
   SenoDeAlpha = Area * 2 / (AB * BC);
   h2 = formulaDeSegundoGrado(BC, -(2 * Area2 + h * BC + 2 * Area1), 2
     * Area2 * h);
   h1 = h - h2;
   AD = h1 / SenoDeAlpha;
   // mostramos el resultado
   System.out.println("Case " + caso + ": " + AD);
  }
 }

 /**
  * Obtiene uno de los resultados de la ecuacion de 2do grado ax2+bx+c
  * 
  * @author BreakDark (Jhonny Monrroy)
  * @version 1.0 beta 25/08/2013
  * @param a
  *            El coeficiente A de la ecuacion de 2do grado
  * @param b
  *            El coeficiente B de la ecuacion de 2do grado
  * @param c
  *            El coeficiente C de la ecuacion de 2do grado
  * @return uno de los valores de x a partir de la ecuacion ax2+bx+c
  */
 private static double formulaDeSegundoGrado(double a, double b, double c) {
  double dis = b * b - 4 * a * c; // discriminante
  if (dis >= 0)
   return ((-b - Math.sqrt(dis)) / (2 * a));
  else
   System.out.println("El resultado es un numero imaginario :(");
  return 0;
 }

 /**
  * obtiene el area de un triangulo a partir de sus lados
  * 
  * @author BreakDark (Jhonny Monrroy)
  * @version 1.0 beta 12/08/2013
  * @param a
  *            Longitud del lado a del triangulo
  * @param b
  *            Longitud del lado b del triangulo
  * @param c
  *            Longitud del lado c del triangulo
  * @return El area del triangulo de lados a, b, c
  */
 private static double areaDelTriangulo(double a, double b, double c) {
  double s = (a + b + c) / 2; // semiperimetro
  return Math.sqrt(s * (s - a) * (s - b) * (s - c));
 }
}

Solución al problema 1001 - Opposite Task [http://www.lightoj.com] con java

2016-09-15T20:32:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1001 - Opposite Task [http://www.lightoj.com]
 * 
 * @author BreakDark
 * @version 1.1 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer los datos de entrada
  byte T; // para el numero de casos de prueba
  byte n; // para el numero de problemas
  byte a; // para la computadora 1

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextByte();
  while (T-- > 0) {
   n = Lee.nextByte();
   if (n >= 10) {
    a = (byte) (n - 10);
    System.out.println(a + " " + (n - a));
   } else
    System.out.println("0 " + n);
  }
 }
}

Solucion al problema: 1000 - Greetings from LightOJ [www.lightoj.com] con Java

2016-09-15T20:25:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1000 - Greetings from LightOJ [www.lightoj.com]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee; // para leer l0os datos de entrada
  byte T; // numero de casos
  byte caso; // para contar los casos
  byte a, b; // problemas en cada computadora

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextByte();
  for (caso = 1; caso <= T; caso++) {
   a = Lee.nextByte();
   b = Lee.nextByte();
   System.out.println("Case " + caso + ": " + (a + b));
  }
 }
}

Solucion al problema: 3056 - Automatic Checking Machine [http://coj.uci.cu] con Java

2016-06-12T19:32:00.001-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 3056 - Automatic Checking Machine [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 20/11/2014
 */
// Acepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee;
        boolean[] c1, c2;
        int i;
        boolean nocompatibles = false;

        // aca inicia el programa
        Lee = new Scanner(System.in);
        c1 = new boolean[5];
        c2 = new boolean[5];
        while (Lee.hasNext()) {
            nocompatibles = false;
            for (i = 0; i < 5; i++)
                c1[i] = (Lee.nextInt() == 1);
            for (i = 0; i < 5; i++)
                c2[i] = (Lee.nextInt() == 1);
            // buscamos si son compatibles
            for (i = 0; i < 5; i++)
                if (c1[i] == c2[i]) {
                    nocompatibles = true;
                    break;
                }
            if (nocompatibles) {
                for (i = 0; i < 5; i++)
                    if (c1[i] == c2[5 - 1 - i]) {
                        nocompatibles = true;
                        break;
                    }
            }
            System.out.println((nocompatibles) ? "N" : "Y");
        }
    }
}

Solucion al problema: 1805 - A+B Complejo [http://coj.uci.cu] con Java

2016-06-12T19:30:00.001-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 1805 - A+B Complejo [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 11 de jun. de 2016
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos
        long a, b;
        long suma;

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        a = Lee.nextInt();
        b = Lee.nextInt();
        suma = 2 * a + 2 * b; // 2a+2b = (a+b) + (a-b) + (b+a) + (b-a)
        System.out.println(suma);
        Lee.close();
    }
}

Solución al problema: 1666 - WERTYU [http://coj.uci.cu/] con Java

2016-06-12T19:28:00.001-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1666 - WERTYU [http://coj.uci.cu/]
 * 
 * @author BreakDark
 * @version 1.1 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee;
  String cadena, salida;
  int i;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  while (Lee.hasNextLine()) {
   cadena = Lee.nextLine();
   salida = "";
   for (i = 0; i < cadena.length(); i++) {
    switch (cadena.charAt(i)) {
    case 'W':
     salida += 'Q';
     break;
    case 'S':
     salida += 'A';
     break;
    case 'X':
     salida += 'Z';
     break;
    case 'E':
     salida += 'W';
     break;
    case 'D':
     salida += 'S';
     break;
    case 'C':
     salida += 'X';
     break;
    case 'R':
     salida += 'E';
     break;
    case 'F':
     salida += 'D';
     break;
    case 'V':
     salida += 'C';
     break;
    case 'T':
     salida += 'R';
     break;
    case 'G':
     salida += 'F';
     break;
    case 'B':
     salida += 'V';
     break;
    case 'Y':
     salida += 'T';
     break;
    case 'H':
     salida += 'G';
     break;
    case 'N':
     salida += 'B';
     break;
    case 'U':
     salida += 'Y';
     break;
    case 'J':
     salida += 'H';
     break;
    case 'M':
     salida += 'N';
     break;
    case 'I':
     salida += 'U';
     break;
    case 'K':
     salida += 'J';
     break;
    case ',':
     salida += 'M';
     break;
    case 'O':
     salida += 'I';
     break;
    case 'L':
     salida += 'K';
     break;
    case '.':
     salida += ',';
     break;
    case 'P':
     salida += 'O';
     break;
    case ';':
     salida += 'L';
     break;
    case '/':
     salida += '.';
     break;
    case '2':
     salida += '1';
     break;
    case '3':
     salida += '2';
     break;
    case '4':
     salida += '3';
     break;
    case '5':
     salida += '4';
     break;
    case '6':
     salida += '5';
     break;
    case '7':
     salida += '8';
     break;
    case '8':
     salida += '7';
     break;
    case '9':
     salida += '8';
     break;
    case '0':
     salida += '9';
     break;
    case '-':
     salida += '0';
     break;
    case '=':
     salida += '-';
     break;
    case '[':
     salida += 'P';
     break;
    case ']':
     salida += '[';
     break;
    case '\\':
     salida += ']';
     break;
    case '\'':
     salida += ';';
     break;
    case ' ':
     salida += ' ';
     break;
    }
   }
   System.out.println(salida);
  }
 }
}

Solución al problema: 1663 - Error Correction [http://coj.uci.cu/] con Java

2016-06-12T19:25:00.005-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1663 - Error Correction [http://coj.uci.cu/]
 * 
 * @author BreakDark
 * @version 1.1 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee;
  byte N;
  boolean[][] mat;
  byte i, j;
  byte sum;
  byte fil, col;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  N = Lee.nextByte();
  while (N > 0) {
   mat = new boolean[N][N];
   fil = col = -1;
   for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
     mat[i][j] = (Lee.nextByte() == 1) ? true : false;
   if (cumpleParidad(mat))
    System.out.println("OK");
   else {
    // buscamos errores en filas
    for (i = 0; i < N; i++) {
     sum = 0;
     for (j = 0; j < N; j++)
      if (mat[i][j])
       sum++;
     if ((sum & 1) == 1) {
      fil = i;
      break;
     }
    }
    if (fil > 0) {
     // buscamos errores en columnas
     for (j = 0; j < N; j++) {
      sum = 0;
      for (i = 0; i < N; i++)
       if (mat[i][j])
        sum++;
      if ((sum & 1) == 1) {
       col = j;
       break;
      }
     }
    }
    // reparamos
    if (fil >= 0 && col >= 0)
     mat[fil][col] = !mat[fil][col];
    if (cumpleParidad(mat))
     System.out.println("Change bit (" + (fil + 1) + ","
       + (col + 1) + ")");
    else
     System.out.println("Corrupt");
   }
   N = Lee.nextByte();
  }
 }

 /** Para comprobar si la matriz cumple con la paridad */
 private static boolean cumpleParidad(boolean[][] mat) {
  byte i, j;
  byte sum;
  // buscamos filas
  for (i = 0; i < mat.length; i++) {
   sum = 0;
   for (j = 0; j < mat.length; j++)
    if (mat[i][j])
     sum++;
   if ((sum & 1) == 1)
    return false;
  }
  // buscamos columnas
  for (j = 0; j < mat.length; j++) {
   sum = 0;
   for (i = 0; i < mat.length; i++)
    if (mat[i][j])
     sum++;
   if ((sum & 1) == 1)
    return false;
  }
  return true;
 }
}

Solución al problema: 1662 - Run-Length Encoding-Decoding [http://coj.uci.cu/] con Java

2016-06-12T19:23:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1662 - Run-Length Encoding-Decoding [http://coj.uci.cu/]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee;
  byte T;
  byte caso;
  String cadena, salida;
  char letra;
  int i, j;
  String aux;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  T = Lee.nextByte();
  for (caso = 1; caso <= T; caso++) {
   System.out.print("Case " + caso + ": ");
   cadena = Lee.next();
   salida = "";
   letra = cadena.charAt(0);
   aux = "";
   for (i = 1; i < cadena.length(); i++) {
    if (cadena.charAt(i) >= '0' && cadena.charAt(i) <= '9')
     aux += cadena.charAt(i);
    else {
     for (j = 0; j < Integer.parseInt(aux); j++)
      salida += letra;
     letra = cadena.charAt(i);
     aux = "";
    }
   }
   for (j = 0; j < Integer.parseInt(aux); j++)
    salida += letra;
   System.out.println(salida);
  }
 }
}

Solución al problema: 1655 - Xtreme Encription [http://coj.uci.cu/] con Java

2016-06-12T19:20:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1655 - Xtreme Encription [http://coj.uci.cu/]
 * 
 * @author BreakDark
 * @version 1.0 beta
 */
// ACEPTADO!!! xD
public class Main {
 public static void main(String[] args) {
  Scanner Lee;
  String texto, texto2;
  int i, j;

  // AQUI INICIA EL PROGRAMA
  Lee = new Scanner(System.in);
  while (Lee.hasNext()) {
   texto = Lee.next();
   texto2 = Lee.next();
   i = j = 0;
   while (i < texto.length() && j < texto2.length()) {
    if (texto.charAt(i) == texto2.charAt(j))
     i++;
    j++;
   }
   if (i == texto.length())
    System.out.println("Yes");
   else
    System.out.println("No");
  }
 }
}

Solucion al problema: 1495 - Increasing Order List [http://coj.uci.cu] con Java

2016-06-12T19:17:00.002-07:00

Para ver el link del problema Click aqui

import java.util.Arrays;
import java.util.Scanner;

/**
 * Solucion al problema: 1495 - Increasing Order List [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 12 de jun. de 2016
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer datos
        int[] ni; // lista de enteros
        int n; // numero de enteros

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        n = Lee.nextInt();
        ni = new int[n];
        for (int i = 0; i < n; i++) {
            ni[i] = Lee.nextInt();
        }
        Arrays.sort(ni);
        for (int i = 0; i < n; i++) {
            System.out.println(ni[i]);
        }
        Lee.close();
    }
}

Solucion al problema: 1494 - Hey don't Read!!! [http://coj.uci.cu] con Java

2016-06-12T19:14:00.003-07:00

Para ver el link del problema Click aqui

/**
 * Solucion al problema: 1494 - Hey don't Read!!! [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 19/11/2014
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        System.out.println("I got my first solution!!!");
    }
}

Solucion al problema: 1312 - R2 [http://coj.uci.cu] con Java

2016-06-12T19:12:00.006-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 1312 - R2 [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 19/11/2014
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de entrada
        int r1, r2, s;

        // aqui inicia el programa
        Lee = new Scanner(System.in);
        r1 = Lee.nextInt();
        s = Lee.nextInt();
        r2 = (s << 1) - r1;
        System.out.println(r2);
    }
}

Solucion al problema: 1156 - La Vida, El Universo y El Todo [http://coj.uci.cu] con Java

2016-06-12T19:10:00.001-07:00

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 1156 - La Vida, El Universo y El Todo
 * [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 1 de jun. de 2016
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // Pasra leer los datos de entrada
        int i; // para los datos de entrada

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        while (Lee.hasNext()) {
            i = Lee.nextInt();
            if (i == 42) {
                break;
            }
            System.out.println(i);
        }
    }
}

Solucion al problema: 1102 - You Can Say 11 [http://coj.uci.cu] con java

2016-06-12T19:08:00.002-07:00

Para ver el link del problema Click aqui

import java.math.BigInteger;
import java.util.Scanner;

/**
 * Solucion al problema: 1102 - You Can Say 11 [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 11 de jun. de 2016
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para ler datos
        BigInteger n; // el numero a evaluar

        BigInteger once = new BigInteger("11");

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        n = new BigInteger(Lee.next());
        while (!n.equals(BigInteger.ZERO)) {
            if (n.mod(once).equals(BigInteger.ZERO)) {
                System.out.println(n + " is a multiple of 11.");
            } else {
                System.out.println(n + " is not a multiple of 11.");
            }
            n = new BigInteger(Lee.next());
        }
        Lee.close();
    }
}

Solución al problema: 1099 - Pythagorean Numbers [http://coj.uci.cu] con Java

2016-06-12T19:06:00.000-07:00

Para ver el link del problema Click aqui

import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

/**
 * 1099 - Pythagorean Numbers [http://coj.uci.cu]
 * 
 * @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
        String linea; // para leer una linea
        StringTokenizer LeerLinea;
        short[] num = new short[3]; // para la trica phitagorica

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        // leemos los datos
        linea = Lee.nextLine();
        while (!linea.equals("0")) {
            LeerLinea = new StringTokenizer(linea);
            num[0] = Short.parseShort(LeerLinea.nextToken());
            num[1] = Short.parseShort(LeerLinea.nextToken());
            num[2] = Short.parseShort(LeerLinea.nextToken());
            Arrays.sort(num); // ordenamos
            // mostramos el resultado
            if (num[0] * num[0] + num[1] * num[1] == num[2] * num[2])
                System.out.println("right");
            else
                System.out.println("wrong");
            linea = Lee.nextLine();
        }
    }
}