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

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++

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

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

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

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

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

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));
  }
 }
}