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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solucion al problema: 1079 - Sums in a Triangle I [http://coj.uci.cu] con Java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 1079 - Sums in a Triangle I [http://coj.uci.cu]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 10 de jun. de 2016
 */
// Accepted!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de entrada
        int nt; // numero de casos de prueba
        int n; // tamanio de la matriz
        int[][] matriz; // matriz donde guardar los numeros del triangulo

        // AQUI INICIA EL PROGRAMA!!!
        Lee = new Scanner(System.in);
        nt = Lee.nextInt();
        while (nt-- > 0) {
            n = Lee.nextInt();
            matriz = new int[n][n];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j <= i; j++) {
                    matriz[i][j] = Lee.nextInt();
                }
            }
            System.out.println(obtenerSumaMasLarga(matriz, n));
        }
        Lee.close();
    }

    /**
     * Obtiene la suma mas larga que se puede obtener de un triangulo de enteros
     * desde la punta hasta una de sus ramas
     * 
     * @param matriz
     *            Matriz de enteros a procesar
     * @param n
     *            El tamaño de la matriz de N x N, n debe ser mayor que 0
     * @return Un entero con el resultado de la suma mas larga
     */
    private static int obtenerSumaMasLarga(int[][] matriz, int n) {
        int i, j; // indices
        for (i = n - 2; i >= 0; i--) {
            for (j = 0; j <= i; j++) {
                matriz[i][j] = Math.max(matriz[i][j] + matriz[i + 1][j],
                        matriz[i][j] + matriz[i + 1][j + 1]);
            }
        }
        return matriz[0][0];
    }
}

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

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1049 - Sum [http://coj.uci.cu/]
 * 
 * @author BreakDark
 * @version 2.0 beta
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para los datos de entrada
        int N; // el N a leer

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        while (Lee.hasNext()) {
            // leemos los datos
            N = Lee.nextShort();
            // mostramos el resultado
            if (N > 0)
                System.out.println((N * (N + 1)) / 2);
            else {
                N = -N;
                N = ((N * (N + 1)) / 2);
                System.out.println(1 - N);
            }
        }
    }
}

Solucion al problema: 1023 - Financial Management [http://coj.uci.cu] en java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al problema: 1023 - Financial Management [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 lps datos de entrada
        double suma, promedio; // para sumar los valores y promedio
        int i; // para los bucles

        // aqui inicia el programa
        Lee = new Scanner(System.in);
        suma = 0;
        for (i = 1; i <= 12; i++)
            suma += Double.valueOf(Lee.next());
        promedio = suma / 12;
        System.out.println(String.format("$%.2f", promedio).replace(',', '.'));
    }
}

Solucion al problema: 1003 - General Election [http://coj.uci.cu] en Java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * 1003 - General Election [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
        byte T; // casos de prueba
        byte n, m; // candidatos y regiones
        int[] suma; // vector de la suma de los candidatos
        int sumaMax; // suma maxima
        int i, j; // indices

        // AQUI INICIA EL PROGRAMA
        Lee = new Scanner(System.in);
        // leemos los datos
        T = Lee.nextByte();
        while (T-- > 0) {
            n = Lee.nextByte();
            m = Lee.nextByte();
            suma = new int[n];
            // sumamos y calculamos
            sumaMax = Integer.MIN_VALUE;
            for (i = 0; i < m; i++)
                for (j = 0; j < n; j++) {
                    suma[j] += Lee.nextInt();
                    if (suma[j] > sumaMax)
                        sumaMax = suma[j];
                }
            // mostramos al ganador
            for (i = 0; i < n; i++)
                if (suma[i] == sumaMax) {
                    System.out.println(i + 1);
                    break;
                }
        }
    }
}

Solucion al problema: 1078 - Another Candies [http://coj.uci.cu] con C++

Para ver el link del problema Click aqui

#include 

using namespace std;

/**
 * Solucion al problema: 1078 - Another Candies [http://coj.uci.cu]
 *
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta_cpp 8 de jun. de 2016
 */
// Accepted !!! xD
int candies[100];  // dulces de cada ninio

/**
* Funcion que calcula si se pueden repartir los dulces equitativamente
* entre los n ninios
*
* @param n
*            numero de ninios a calcular
* @return true si se puede repartir en partes iguales,
*         false en caso contrario
*/
bool puedeDistribuirLosCaramelos(int n);

int main(){
    int t;  // casos de entrada
    int n;  // numero de ninios

    // AQUI INICIA EL PROGRAMA
    cin>>t;
    for(int it=1;it<=t;it++){
        cin>>n;
        for(int ni=0;ni<n;ni++){
            cin>>candies[ni];
        }
        cout<<(puedeDistribuirLosCaramelos(n)?"YES":"NO")<<endl;
    }
    return 0;
}

bool puedeDistribuirLosCaramelos(int n){
    int sum=0;
    for(int i=0;i<n;i++){
        sum+=candies[i];
    }
    return (sum%n)==0;
}