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