Solución al problema: 185C - Cd and pwd commands [http://codeforces.com] con Java

Solución al problema: 185C - Cd and pwd commands [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; import java.util.Stack; import java.util.StringTokenizer; /** * 185C - Cd and pwd commands [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada String linea, salida; // para procesar una linea y la salida StringTokenizer LeerLinea; // para leer una linea byte n; // numero de instrucciones Stack pila = new Stack(); // para los directorios Stack pilaAux = new Stack(); // AQUI INICIA EL PROGRAMA!!! Lee = new Scanner(System.in); while (Lee.hasNextLine()) { n = Byte.parseByte(Lee.nextLine()); pila.clear(); // vaciamos todo while (n-- > 0) { linea = Lee.nextLine(); if (linea.equals("pwd")) { // mostramos el directorio actual salida = ""; while (!pila.empty()) { linea = pila.pop(); salida = ("/" + linea) + salida; pilaAux.push(linea); } // reponemos la pila while (!pilaAux.empty()) pila.push(pilaAux.pop()); salida += "/"; System.out.println(salida); } else { // si es cd linea = linea.substring(3); if (linea.charAt(0) == '/') { // si es el directorio raiz pila.clear(); LeerLinea = new StringTokenizer(linea.replace('/', ' ')); while (LeerLinea.hasMoreTokens()) { linea = LeerLinea.nextToken(); if (linea.charAt(0) == '.') { // si es que hay que retroceder una carpeta pila.pop(); } else pila.push(linea); } } else { LeerLinea = new StringTokenizer(linea.replace('/', ' ')); while (LeerLinea.hasMoreTokens()) { linea = LeerLinea.nextToken(); if (linea.charAt(0) == '.') { // si es que hay que retroceder una carpeta pila.pop(); } else pila.push(linea); } } } } } } }

Solucion al Problema: 148A - Insomnia cure [http://codeforces.com] con Java

Solucion al Problema: 148A - Insomnia cure [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.BitSet; import java.util.Scanner; /** * Solucion al Problema: 148A - Insomnia cure [http://codeforces.com] * * @author BreakDark * @version 1.0.1 beta 11/11/2012 */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos byte k, l, m, n; // los -th a los que lastimo int d; // el total de dragones // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos k = Lee.nextByte(); l = Lee.nextByte(); m = Lee.nextByte(); n = Lee.nextByte(); d = Lee.nextInt(); // resolvemos el problema procesar(k, l, m, n, d); } } /** * Metodo que resuelva este problema * * @author BreakDark * @version 1.0.1 beta 11/11/2012 * @param k * golpeados con la sarten en la cara * @param l * con las colas apretadas con la puerta * @param m * con las patas pisadas por los tacones de la princesa * @param n * a los acusados con su mama :) * @param d * total de dragones */ private static void procesar(byte k, byte l, byte m, byte n, int d) { BitSet dragones = new BitSet(d); // total de dragones int i; // para los bucles // marcamos a los k for (i = k - 1; i < d; i += k) dragones.set(i); // marcamos a los l for (i = l - 1; i < d; i += l) dragones.set(i); // marcamos a los m for (i = m - 1; i < d; i += m) dragones.set(i); // marcamos a los n for (i = n - 1; i < d; i += n) dragones.set(i); // mostramos el numero de dragones lastimados System.out.println(dragones.cardinality()); } }

Solucion al Problema: 133A - HQ9+ [http://codeforces.com] con Java

Solucion al Problema: 133A - HQ9+ [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * Solucion al Problema: 133A - HQ9+ [http://codeforces.com] * * @author BreakDark * @version 1.3 beta 21/11/2012 */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada String comando; // la linea a evaluar // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos comando = Lee.next(); if (comando.contains("H") || comando.contains("Q") || comando.contains("9")) System.out.println("YES"); else System.out.println("NO"); } } }

Solución al problema: 131A - cAPS lOCK - [http://www.codeforces.com] con Java

Solución al problema: 131A - cAPS lOCK - [http://www.codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 131A - cAPS lOCK - [http://www.codeforces.com] * * @author BreakDark * @version 2.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; String cadena; byte i; // para bucles // INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { cadena = Lee.next(); if (cadena.length() > 1) { if ((cadena.equals(cadena.toUpperCase())) || (cadena.substring(1).equals(cadena.substring(1) .toUpperCase()))) { for (i = 0; i < cadena.length(); i++) if (cadena.charAt(i) > 96 && cadena.charAt(i) < 123) System.out.print((char) (cadena.charAt(i) - 32)); else System.out.print((char) (cadena.charAt(i) + 32)); System.out.println(); } else System.out.println(cadena); } else { if (cadena.charAt(0) >= 'a' && cadena.charAt(0) <= 'z') System.out.println((char) (cadena.charAt(0) - 32)); else { if (cadena.charAt(0) >= 'A' && cadena.charAt(0) <= 'Z') System.out.println((char) (cadena.charAt(0) + 32)); else System.out.println(cadena); } } } } }

Solución al problema: 119A - Epic Game [http://codeforces.com] con Java

Solución al problema: 119A - Epic Game [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 119A - Epic Game [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte a, b, n; // Simon, Antisimon y total n boolean simon; // quien juega // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos a = Lee.nextByte(); b = Lee.nextByte(); n = Lee.nextByte(); simon = true; // jugamos while (mcd(a, n) <= n && mcd(b, n) <= n) { if (simon) n -= mcd(a, n); else n -= mcd(b, n); simon = !simon; } // mostramos el resultado if (simon) System.out.println("1"); else System.out.println("0"); } } /** * Maximo Comun Divisor por el algoritmo de Euclides * * @param a * entero A * @param b * entero B * @return MCD de a y b */ private static int mcd(int a, int b) { int r; if (a < b) { r = a; a = b; b = r; } while (b > 0) { r = a % b; a = b; b = r; } return a; } }

Solucion al Problema: 116A - Tram [http://codeforces.com] con Java

Solucion al Problema: 116A - Tram [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 116A - Tram [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada short n; // num paradas 2<=n<=1000 short a, b; // personas que bajan y suben int minNumPas; // minimo numero de personas en el tranvia int perTran; // personas dentro el tranvia // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos n = Lee.nextShort(); perTran = 0; minNumPas = 0; while (n-- > 0) { perTran -= Lee.nextShort(); perTran += Lee.nextShort(); if (perTran > minNumPas) minNumPas = perTran; } // mostramos el resultado System.out.println(minNumPas); } } }

Solucion al Problema: 112A - Petya and Strings [http://codeforces.com] con Java

Solucion al Problema: 112A - Petya and Strings [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * Solucion al Problema: 112A - Petya and Strings [http://codeforces.com] * * @author BreakDark * @version 1.0 beta 11/11/2012 */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada String cadena1, cadena2; // para las cadenas // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos cadena1 = Lee.next().toLowerCase(); cadena2 = Lee.next().toLowerCase(); // mostramos el resultado System.out.println((int) (Math.signum(cadena1.compareTo(cadena2)))); } } }

Solucion al Problema: 82A - Double Cola [http://codeforces.com] con Java

Solucion al Problema: 82A - Double Cola [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 82A - Double Cola [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada // lista de los nombres String[] nombres = { "Sheldon", "Leonard", "Penny", "Rajesh", "Howard" }; int n; // para la posición a buscar <=1000000000 int[] poten = new int[29]; // potencias byte i; // para los bucles e indices int aux; // variable temporal // AQUI INICIA EL PROGRAMA // generamos las potencias 5*n*2^n-1 aux = 1; poten[0] = 0; for (i = 1; i < 29; i++) { poten[i] = poten[i - 1] + 5 * aux; aux <<= 1; } Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextInt(); i = 0; aux = 0; while (poten[i] < n) { aux = n - poten[i++]; } // calculamos quien esta en la fila n = 1 << (i - 1); i = 0; while (aux > n) { aux -= n; i++; } System.out.println(nombres[i]); } } }

Solucion al Problema: 50A - Domino piling [http://codeforces.com]

Solucion al Problema: 50A - Domino piling [http://codeforces.com] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * Solucion al Problema: 50A - Domino piling [http://codeforces.com] * * @author BreakDark * @version 1.0 beta 11/11/2012 */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte M, N; // las bases de la tabla short area; // area de la tabla // AQUI INICIA EL PROGRAMA!!! Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos M = Lee.nextByte(); N = Lee.nextByte(); area = (short) (M * N); // mostramos el resultado System.out.println(area >> 1); } } }

Solución al Problema 5514 - Circle Through Three Points [http://livearchive.onlinejudge.org] con Java

Solución al Problema 5514 - Circle Through Three Points [http://livearchive.onlinejudge.org] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 5514 - Circle Through Three Points [http://livearchive.onlinejudge.org] * 190 - Circle Through Three Points [http://uva.onlinejudge.org] * * @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 double Ax, Ay, Bx, By, Cx, Cy; // para las coordenadas de los puntos double h = 0, k = 0, r = 0, c = 0, d = 0, e = 0; // para los datos que // se mostraran double[][] C = new double[3][3]; // para sacar el determinante double[][] D = new double[3][3]; double[][] E = new double[3][3]; double[][] dis = new double[3][3]; double aux; // un auxiliar para ahorrar operaciones String linea; // para la linea que se mostrara al final // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while(Lee.hasNext()){ Ax = Double.parseDouble(Lee.next()); Ay = Double.parseDouble(Lee.next()); Bx = Double.parseDouble(Lee.next()); By = Double.parseDouble(Lee.next()); Cx = Double.parseDouble(Lee.next()); Cy = Double.parseDouble(Lee.next()); // creamos las matriz discriminante dis[0][0] = Ax; dis[0][1] = Ay; dis[0][2] = 1; dis[1][0] = Bx; dis[1][1] = By; dis[1][2] = 1; dis[2][0] = Cx; dis[2][1] = Cy; dis[2][2] = 1; // copiamos antes de modificar las matrices C = copia(dis); D = copia(dis); E = copia(dis); // creamos la matriz D C[0][0] = -(Ax * Ax + Ay * Ay); C[1][0] = -(Bx * Bx + By * By); C[2][0] = -(Cx * Cx + Cy * Cy); // creamos la matriz E D[0][1] = -(Ax * Ax + Ay * Ay); D[1][1] = -(Bx * Bx + By * By); D[2][1] = -(Cx * Cx + Cy * Cy); // creamos la matriz F E[0][2] = -(Ax * Ax + Ay * Ay); E[1][2] = -(Bx * Bx + By * By); E[2][2] = -(Cx * Cx + Cy * Cy); // hallamos las soluciones aux = det(dis); c = det(C) / aux; d = det(D) / aux; e = det(E) / aux; h = c / 2;// -c/2; k = d / 2;// -d/2; r = Math.sqrt(h * h + k * k - e); // aqui mostramos el resultado // formato 1 // para h linea = "(x "; if(h >= 0) linea += String.format("+ %.3f", h); else linea += String.format("- %.3f", Math.abs(h)); linea += ")^2 + (y "; // para k if(k >= 0) linea += String.format("+ %.3f", k); else linea += String.format("- %.3f", Math.abs(k)); linea += ")^2 = "; // para r linea += String.format("%.3f^2\n", r); System.out.print(linea.replace(',', '.')); // formato 2 linea = "x^2 + y^2 "; // para c if(c >= 0) linea += String.format("+ %.3fx ", c); else linea += String.format("- %.3fx ", Math.abs(c)); // para d if(d >= 0) linea += String.format("+ %.3fy ", d); else linea += String.format("- %.3fy ", Math.abs(d)); // para e if(e >= 0) linea += String.format("+ %.3f = 0\n", e); else linea += String.format("- %.3f = 0\n", Math.abs(e)); System.out.print(linea.replace(',', '.')); // if(Lee.hasNext()) System.out.println(); } } /** * Realiza una copia de la matriz mat de 3 por 3 * * @author BreakDark * @param mat * matriz a copiar * @return matriz con los mismos elementos de mat */ private static double[][] copia(double[][] mat) { double[][] res = new double[3][3]; byte i, j; for(i = 0; i < 3; i++) for(j = 0; j < 3; j++) res[i][j] = mat[i][j]; return res; } /** * Funcion que halla el determinante de una matriz de 3 por 3 * * @author BreakDark * @param mat * Es una matriz de 3 por 3 * @return el determinante de mat */ private static double det(double[][] mat) { return (mat[0][0] * mat[1][1] * mat[2][2] + mat[0][1] * mat[1][2] * mat[2][0] + mat[0][2] * mat[1][0] * mat[2][1] - mat[0][0] * mat[1][2] * mat[2][1] - mat[0][1] * mat[1][0] * mat[2][2] - mat[0][2] * mat[1][1] * mat[2][0]); } }

Solución al Problema 5356 - Exponentiation [http://livearchive.onlinejudge.org] con Java

Solución al Problema 5356 - Exponentiation [http://livearchive.onlinejudge.org] con Java
El link del Problema se encuentra en el siguiente enlace

import java.math.BigDecimal; import java.util.Scanner; /** * 5356 - Exponentiation [http://livearchive.onlinejudge.org] 748 - * 748 - Exponentiation [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada BigDecimal num; // para leer la base // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while(Lee.hasNext()){ num = new BigDecimal(Lee.next()); num = num.pow(Lee.nextByte()); System.out.println(sinCerosInsignificantes(num.toPlainString())); } } /** * Esta funcion elimina los ceros insignificantes * * @author BreakDark * @param numero * El numero que al que se desea eliminar los ceros * insignificantes * @return una cadena que representa el numero sin ceros insignificantes * */ private static String sinCerosInsignificantes(String numero) { int i, j; // buscamos desde el principio for(i = 0; i < numero.length(); i++) if(numero.charAt(i) != '0') break; // buscamos desde el final for(j = numero.length() - 1; j >= 0; j--) if(numero.charAt(j) != '0') break; return numero.substring(i, j + 1); } }

Solución al Problema 5355 - Baudot Data Communication Code [http://livearchive.onlinejudge.org] con Java

Solución al Problema 5355 - Baudot Data Communication Code [http://livearchive.onlinejudge.org] con Java
El link del Problema se encuentra en el siguiente enlace

import java.util.Scanner; /** * 5355 - Baudot Data Communication Code [http://livearchive.onlinejudge.org] * 740 - Baudot Data Communication Code [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada char[][] codigo = new char[2][32]; // para los codigos String mensajeCod, mensajeRecod; // para recodificar el mensaje byte i; // para los bucles byte shift; // para saber si es down_shift o up_shift // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); // leemos down-shift y up-shift codigo[0] = Lee.nextLine().toCharArray(); codigo[1] = Lee.nextLine().toCharArray(); while(Lee.hasNextLine()){ mensajeCod = Lee.nextLine(); mensajeRecod = ""; shift = 0; for(i = 0; i < mensajeCod.length(); i += 5){ if(Byte.parseByte(mensajeCod.substring(i, i + 5), 2) == 27) shift = 0; else if(Byte.parseByte(mensajeCod.substring(i, i + 5), 2) == 31) shift = 1; else mensajeRecod += (codigo[shift][Byte.parseByte(mensajeCod.substring(i, i + 5), 2)]); } // mostramos el texto decodificado System.out.println(mensajeRecod); } } }

Solución al problema T9 Spelling [http://code.google.com/codejam] con Java

Solución al problema T9 Spelling [http://code.google.com/codejam] con Java, el link del problema es el siguiente enlace

import java.util.Scanner; /** * T9 Spelling [http://code.google.com/codejam] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte N; // para el numero total de casos de prueba char[] linea; // para la cadena a procesar byte n; // para los bucles de N String lineaFinal; // para la linea final short i; // para contar los caracteres de la linea String digito = ""; // para mostrar el digito a imprimir // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); N = Byte.parseByte(Lee.nextLine()); for(n = 1; n <= N; n++){ System.out.print("Case #" + n + ": "); linea = Lee.nextLine().toCharArray(); lineaFinal = ""; for(i = 0; i < linea.length; i++){ switch(linea[i]){ case 'a': digito = "2"; break; case 'b': digito = "22"; break; case 'c': digito = "222"; break; case 'd': digito = "3"; break; case 'e': digito = "33"; break; case 'f': digito = "333"; break; case 'g': digito = "4"; break; case 'h': digito = "44"; break; case 'i': digito = "444"; break; case 'j': digito = "5"; break; case 'k': digito = "55"; break; case 'l': digito = "555"; break; case 'm': digito = "6"; break; case 'n': digito = "66"; break; case 'o': digito = "666"; break; case 'p': digito = "7"; break; case 'q': digito = "77"; break; case 'r': digito = "777"; break; case 's': digito = "7777"; break; case 't': digito = "8"; break; case 'u': digito = "88"; break; case 'v': digito = "888"; break; case 'w': digito = "9"; break; case 'x': digito = "99"; break; case 'y': digito = "999"; break; case 'z': digito = "9999"; break; case ' ': digito = "0"; break; } if(lineaFinal.length() > 0){ if(lineaFinal.charAt(lineaFinal.length() - 1) != digito.charAt(0)) lineaFinal += digito; else lineaFinal += (" " + digito); } else lineaFinal += digito; } System.out.println(lineaFinal); } } }

Solución al problema Store Credit [http://code.google.com/codejam] con Java

Solución al problema Store Credit [http://code.google.com/codejam] con Java, el link del problema es el siguiente enlace

import java.util.Scanner; /** * Store Credit [http://code.google.com/codejam] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de byte N; // numero de casos de prueba short C; // total de credito short I; // numero de items en el store short[] P = new short[2000]; // lista de precios de cada articulo byte n; // para el bucle N short i, j; // para los bucles I boolean sw; // para informar si ya se encontro el par // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); N = Lee.nextByte(); for(n = 1; n <= N; n++){ System.out.print("Case #" + n + ": "); // leemos los datos C = Lee.nextShort(); I = Lee.nextShort(); for(i = 0; i < I; i++) P[i] = Lee.nextShort(); // resolvemos el problema sw = false; for(i = 0; i < I - 1 && !sw; i++) for(j = (short) (i + 1); j < I; j++) if(P[i] + P[j] == C){ System.out.println((i + 1) + " " + (j + 1)); sw = true; break; } } } }

Solución al problema Reverse Words [http://code.google.com/codejam] con Java

Solución al problema Reverse Words [http://code.google.com/codejam] con Java el link del problema es el siguiente enlace

import java.util.Scanner; import java.util.StringTokenizer; /** * Reverse Words [http://code.google.com/codejam] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte N; // para el numero de casos de prueba String lineaFinal; // para el texto al reves byte n; // para el bucle N StringTokenizer LeerLinea; // para leer las palabras de la linea // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); N = Byte.parseByte(Lee.nextLine()); for(n = 1; n <= N; n++){ System.out.print("Case #" + n + ": "); LeerLinea = new StringTokenizer(Lee.nextLine()); lineaFinal = ""; while(LeerLinea.hasMoreTokens()){ lineaFinal = LeerLinea.nextToken() + lineaFinal; if(LeerLinea.hasMoreTokens()) lineaFinal = ' ' + lineaFinal; } System.out.println(lineaFinal); } } }

Solución a 69A - Young Physicist [http://www.codeforces.com] con Java

Solución a 69A - Young Physicist [http://www.codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * Problema 69A - Young Physicist [http://www.codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! :) public class Main { public static void main(String[] args) { Scanner Lee; byte n; byte x, y, z; // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextByte(); x = y = z = 0; while (n > 0) { x += Lee.nextByte(); y += Lee.nextByte(); z += Lee.nextByte(); n--; } if ((x == 0) && (y == 0) && (z == 0)) System.out.println("YES"); else System.out.println("NO"); } } }

Solución a 200B - Drinks [http://codeforces.com] con Java

Solución a 200B - Drinks [http://codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 200B - Drinks [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; byte n; int sumPi; byte i; // bucles // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextByte(); sumPi = 0; for (i = 0; i < n; i++) sumPi += Lee.nextInt(); System.out.println(String.format("%.12f", ((double) sumPi / n)) .replace(',', '.')); } } }

Solución a 158B - Taxi [http://codeforces.com] con Java

Solución a 158B - Taxi [http://codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 158B - Taxi [http://codeforces.com] * * @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 n; // numero de grupos int i; // para los bucles int c; // contador de taxis int sum1, sum2, sum3, sum4; // sumamos los grupos de 1 a 4 estudiantes byte aux; // un auxiliar // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos n = Lee.nextInt(); sum1 = sum2 = sum3 = sum4 = 0; for (i = 0; i < n; i++) { aux = Lee.nextByte(); switch (aux) { case 1: sum1++; break; case 2: sum2++; break; case 3: sum3++; break; default: sum4++; break; } } // calculamos los taxis necesarios c = sum4; // los que necesitan de 4 estudiantes if (sum3 > sum1) { // sumamos 3 con 1 c += sum1; c += (sum3 - sum1); // sumamos los grupos de a dos c += Math.ceil((double) sum2 / 2); } else { c += sum3; sum1 -= sum3; // sumamos los grupos de a dos c += sum2 >> 1; // si solo queda un grupo de a dos if ((sum2 & 1) == 1) { c++; sum1 -= 2; } // si aun quedan grupos de a 1 if (sum1 > 0) c += Math.ceil((double) sum1 / 4); } // mostramos el resultado System.out.println(c); } } }

Solución a 158A - Next Round [http://codeforces.com] con Java

Solución a 158A - Next Round [http://codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 158A - Next Round [http://codeforces.com] * * @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 byte n, k; // el numero de concursantes y el puesto byte[] A; // para guardar los puntajes de cada jugador byte c; // un contador byte i; // para los bucles // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos n = Lee.nextByte(); k = Lee.nextByte(); A = new byte[n]; // leemos las puntuaciones for (i = 0; i < n; i++) A[i] = Lee.nextByte(); // contamos a los mejores c = 0; for (i = 0; i < n; i++) if (A[i] > 0 && A[i] - A[k - 1] >= 0) c++; else break; // mostramos el resultado System.out.println(c); } } }

Solución a 136A - Presents [http://www.codeforces.com] con Java

Solución a 136A - Presents [http://www.codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 136A - Presents [http://www.codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los dtos de entrada byte n; int[] amigos; int i; // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextByte(); amigos = new int[n]; for (i = 0; i < n; i++) amigos[Lee.nextInt() - 1] = i + 1; for (i = 0; i < n; i++) { System.out.print(amigos[i]); if (i < n - 1) System.out.print(" "); else System.out.println(); } } } }

Solución a 118A - String Task [http://codeforces.com] con Java

Solución a 118A - String Task [http://codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 118A - String Task [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada String cadena, nuevaCadena; // cadena y cadena modificada int i; // para los bucles char aux; // un caracter auxiliar // AQU INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos cadena = Lee.next(); cadena = cadena.toLowerCase(); // a minusculas // generamos la nueva cadena nuevaCadena = ""; for (i = 0; i < cadena.length(); i++) { aux = cadena.charAt(i); if ((aux != 'a') && (aux != 'e') && (aux != 'i') && (aux != 'o') && (aux != 'u') && (aux != 'y')) nuevaCadena += ("." + aux); } // mostramos la nueva cadena System.out.println(nuevaCadena); } } }

Solución a 71A - Way Too Long Words [http://codeforces.com] con Java

Solución a 71A - Way Too Long Words [http://codeforces.com] el enlace del problema está en el siguiente link

import java.util.Scanner; /** * 71A - Way Too Long Words [http://codeforces.com] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para ller los datos de entrada byte n; // el numero de palabras String palabra; // palabra a procesar // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos n = Lee.nextByte(); // leemos las palabras while (n-- > 0) { palabra = Lee.next(); if (palabra.length() > 10) System.out.println(palabra.charAt(0) + "" + (palabra.length() - 2) + "" + palabra.charAt(palabra.length() - 1)); else System.out.println(palabra); } } } }

Solución a 4A - Watermelon [http://codeforces.com] con Java

Solución a 4A - Watermelon [http://codeforces.com] el enlace del problema está en el siguiente link http://codeforces.com/problemset/problem/4/A

import java.util.Scanner; /** * 4A - Watermelon [http://codeforces.com] * * @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 byte w; // para el peso // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los kilos w = Lee.nextByte(); if (w > 2) { if (((w - 2) & 1) == 0) System.out.println("YES"); else System.out.println("NO"); } else System.out.println("NO"); } } }

Solución a 2017 - Hey, You're Not Marion Jones! [http://livearchive.onlinejudge.org]

Solución a 2017 - Hey, You're Not Marion Jones! [http://livearchive.onlinejudge.org]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 2017 - Hey, You're Not Marion Jones! [http://livearchive.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { static byte funcionG[] = {1, 5, 7, 6, 2, 8, 3, 0, 9, 4}; public static void main(String[] args) { Scanner Lee; // para ller los datos de entrada int n; // para el numero de casos String barcode; // para el codigo a leer String numBase10; // para el numero base 10 String[] cifraSignificativa = {"athlete", "athlete", "reserve", "reserve", "judge", "judge", "staff", "staff", "press", "press"}; // AQUI INICIA EL PROGRAMA!!! Lee = new Scanner(System.in); n = Lee.nextInt(); while(n-- > 0){ barcode = Lee.next(); numBase10 = convertir(barcode); System.out.print(barcode + "/" + numBase10 + " is "); // verificamos si numBase10 es un ID valido if(esValido(numBase10)) System.out.println("valid " + cifraSignificativa[numBase10.charAt(0) - '0'] + " id number"); else System.out.println("invalid id number"); } } /** Verifica si un ID es valido */ private static boolean esValido(String numero) { // sacamos las funciones F int[] F = new int[8]; byte i, j; for(i = 0, j = 7; i < 8; i++, j--) F[i] = funcionF(i, numero.charAt(j) - '0'); // realizamos la funcionIporJ int producto = funcionIporJ(F[0], F[1]); for(i = 2; i < 8; i++) producto = funcionIporJ(producto, F[i]); if(producto == 0) return true; return false; } /** realiza la funcionIporJ */ private static int funcionIporJ(int i, int j) { if(i < 5 && j < 5) return (i + j) % 5; if(i < 5 && j >= 5){ if(i + (j - 5) < 0) return ((i + (j - 5)) + 5) % 5 + 5; return (i + (j - 5)) % 5 + 5; } if(i >= 5 && j < 5){ if(((i - 5) - j) < 0) return (((i - 5) - j) + 5) % 5 + 5; return ((i - 5) - j) % 5 + 5; } if((i - j) < 0) return ((i - j) + 5) % 5; return (i - j) % 5; } /** realiza la funcionF */ private static int funcionF(int i, int j) { if(i == 0) return j; else if(i == 1) return funcionG[j]; else return funcionF(i - 1, funcionG[j]); } /** Convierte el numero base 5 a base 10 */ private static String convertir(String cadena) { long r = 0; String r2; int i, j = 0; for(i = cadena.length() - 1; i >= 0; i--, j++){ switch(cadena.charAt(i)){ case 'V': r += (4 * Math.pow(5, j)); break; case 'W': r += (3 * Math.pow(5, j)); break; case 'X': r += (2 * Math.pow(5, j)); break; case 'Y': r += (1 * Math.pow(5, j)); break; default: r += 0; break; } } r2 = Long.toString(r); // completamos con ceros si es necesario while(r2.length() < 8) r2 = '0' + r2; return r2; } }

Solución a 2015 - Bob's Bingo Bonanza [http://livearchive.onlinejudge.org]

Solución a 2015 - Bob's Bingo Bonanza [http://livearchive.onlinejudge.org]
El enunciado esta en el siguiente link enunciado

import java.util.BitSet; import java.util.Scanner; /** * 2015 - Bob's Bingo Bonanza [http://livearchive.onlinejudge.org] * * @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 BitSet modTarjeta = new BitSet(25); // para el modelo de la tarjeta byte n; // para el numero de tarjetas int game = 1; // para el numero de juego BitSet[] tarjeta = new BitSet[100]; byte i, j; // para los bucles String linea; // para leer una linea // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); for(i = 0; i < 100; i++) tarjeta[i] = new BitSet(76); do{ // leemos el modelo j = 0; linea = ""; modTarjeta.clear(); for(i = 0; i < 5; i++) linea += Lee.next(); for(i = 0; i < linea.length(); i++){ if(linea.charAt(i) == 'X') modTarjeta.set(i); } // leemos n n = Lee.nextByte(); if(n > 0){ if(game > 1) System.out.println(); // linea en blanco // llenamos las tarjetas for(i = 0; i < n; i++){ tarjeta[i].clear(); for(j = 0; j < 25; j++){ if(modTarjeta.get(j)) tarjeta[i].set(Lee.nextByte()); else Lee.nextByte(); } } System.out.println("Game " + game++); // procesamos la informacion procesar(tarjeta, n); } } while(n > 0); } /** procedimiento que hace todo el trabajo */ private static void procesar(BitSet[] tarjeta, byte n) { byte i, j; // buscamos en todos los juegos de tarjetas for(i = 1; i < n; i++){ // recorremos las tarjetas for(j = 0; j < i; j++){ // preguntamos si tienen numeros comunes if(tarjeta[i].equals(tarjeta[j])){ System.out.println("Card " + (i + 1) + " is equivalent to card " + (j + 1)); break; } } } } }

ATENCION SOLO PARA 143

ATENCION SOLO PARA 143
La pagina para descargas de material esta alojada en el siguiente blog
http://breakdark143.blogspot.com/
SALUDOS

ATENCION LOS ARCHIVOS PARA INF-131 SE PUBLICARAN EN EL SIGUIENTE BLOG 

http://breakdark131.blogspot.com

Solucion a 12398 NumPuzz I [http://uva.onlinejudge.org] con Java

Solucion a 12398 NumPuzz I [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * Problem B NumPuzz I [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! public class Main { public static void main(String[] args) { Scanner Lee; String linea; byte[][] mat; int i, j, k, caso; // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); caso = 1; while (Lee.hasNextLine()) { linea = Lee.nextLine(); mat = new byte[3][3]; for (k = linea.length() - 1; k >= 0; k--) { switch (linea.charAt(k)) { case 'a': i = 0; j = 0; break; case 'b': i = 0; j = 1; break; case 'c': i = 0; j = 2; break; case 'd': i = 1; j = 0; break; case 'e': i = 1; j = 1; break; case 'f': i = 1; j = 2; break; case 'g': i = 2; j = 0; break; case 'h': i = 2; j = 1; break; default: i = 2; j = 2; break; } // modificamos la casilla if (mat[i][j] < 9) mat[i][j]++; else mat[i][j] = 0; // modificamos arriba if (i > 0) { if (mat[i - 1][j] < 9) mat[i - 1][j]++; else mat[i - 1][j] = 0; } // modificamos abajo if (i < 2) { if (mat[i + 1][j] < 9) mat[i + 1][j]++; else mat[i + 1][j] = 0; } // modificamos izquierda if (j > 0) { if (mat[i][j - 1] < 9) mat[i][j - 1]++; else mat[i][j - 1] = 0; } // modificamos derecha if (j < 2) { if (mat[i][j + 1] < 9) mat[i][j + 1]++; else mat[i][j + 1] = 0; } } System.out.println("Case #" + (caso++) + ":"); for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { System.out.print(mat[i][j]); if (j < 2) System.out.print(" "); } System.out.println(); } } } }

Solucion a 12397 Roman Numerals [http://uva.onlinejudge.org] con Java

Solucion a 12397 Roman Numerals [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * Problem A Roman Numerals [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! public class Main { public static void main(String[] args) { Scanner Lee; short N; byte i; byte[][] valores = { { 0, 1, 2, 3, 3, 2, 3, 4, 5, 3 }, { 0, 2, 4, 6, 4, 2, 4, 6, 8, 4 }, { 0, 2, 4, 6, 5, 3, 5, 7, 9, 6 }, { 0, 4, 8, 12, 0, 0, 0, 0, 0, 0 } }; byte sum; // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { N = Lee.nextShort(); i = 0; sum = 0; while (N > 0) { sum += valores[i][N % 10]; N /= 10; i++; } System.out.println(sum); } } }

Solucion a 10300 - Ecological Premium [http://uva.onlinejudge.org] con Java

Solucion a 10300 - Ecological Premium [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 10300 - Ecological Premium [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte n; // numero de casos de prueba byte f; // numero de granjas long suma; // para sumar los premios int a; // para el tamanio de la granja en m2 // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextByte(); while (n-- > 0) { f = Lee.nextByte(); suma = 0; while (f-- > 0) { a = Lee.nextInt(); Lee.nextInt(); suma += (a * Lee.nextInt()); } System.out.println(suma); } } } }

Solucion a 10071 - Back to High School Physics [http://uva.onlinejudge.org] con Java

Solucion a 10071 - Back to High School Physics [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 10071 - Back to High School Physics [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.1 beta */ // ACEPTADO!!! public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada byte v; // para la velocidad short t; // para el tiempo // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { v = Lee.nextByte(); t = Lee.nextShort(); System.out.println(v * 2 * t); } } }

Solucion a 10055 - Hashmat the brave warrior [http://uva.onlinejudge.org] con Java

Solucion a 10055 - Hashmat the brave warrior [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 10055 - Hashmat the brave warrior [http://uva.onlinejudge.org] * * @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 long numH, numOP; // soldados de Hashman y del opositor // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { numH = Lee.nextLong(); numOP = Lee.nextLong(); System.out.println(Math.abs(numOP - numH)); } } }

Solucion a 10035 - Primary Arithmetic [http://uva.onlinejudge.org] con Java

Solucion a 10035 - Primary Arithmetic [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 10035 - Primary Arithmetic [http://uva.onlinejudge.org] * * @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 String num1, num2; // para los numeros a asumar byte numAcarreo; // para contar los acarreos byte aux; // para las sumas temporales int i, j; // para los bucles // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); num1 = Lee.next(); num2 = Lee.next(); while (!num1.equals("0") || !num2.equals("0")) { i = num1.length() - 1; j = num2.length() - 1; aux = 0; numAcarreo = 0; while (i >= 0 && j >= 0) { if ((num1.charAt(i) - '0') + (num2.charAt(j) - '0') + aux > 9) { aux = 1; numAcarreo++; } else aux = 0; i--; j--; } // si el primer numero termino de evaluarse if (i >= 0) { while (i >= 0) { if ((num1.charAt(i) - '0') + aux > 9) { aux = 1; numAcarreo++; } else aux = 0; i--; } } else if (j >= 0) { while (j >= 0) { if ((num2.charAt(j) - '0') + aux > 9) { aux = 1; numAcarreo++; } else aux = 0; j--; } } // mostramos el resultado if (numAcarreo > 1) System.out.println(numAcarreo + " carry operations."); else if (numAcarreo == 1) System.out.println("1 carry operation."); else System.out.println("No carry operation."); num1 = Lee.next(); num2 = Lee.next(); } } }

Solucion a 10018 - Reverse and Add [http://uva.onlinejudge.org] con Java

Solucion a 10018 - Reverse and Add [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 10018 - Reverse and Add [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada int N; // el numero de casos de prueba long num1, num2; // para verificar si es palindrome int numIteraciones; // para contar las iteraciones // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); N = Lee.nextInt(); while (N-- > 0) { numIteraciones = 0; num1 = Lee.nextLong(); num2 = invertir(num1); while (num1 != num2) { num1 += num2; num2 = invertir(num1); numIteraciones++; } System.out.println(numIteraciones + " " + num1); } } /** * Funcion que invierte los dogitos de un numero * * @param num * el numero a invertir * @return el numero ya invertido */ private static long invertir(long num) { String anterior = Long.toString(num); String nuevoNum = ""; for (int i = anterior.length() - 1; i >= 0; i--) nuevoNum += anterior.charAt(i); return Long.parseLong(nuevoNum); } }

Solucion a 494 - Kindergarten Counting Game [http://uva.onlinejudge.org] con Java

Solucion a 494 - Kindergarten Counting Game [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; import java.util.StringTokenizer; /** * 494 - Kindergarten Counting Game [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // para leer los datos de entrada String linea, nuevaLinea; // para procesar una linea int i; // para los bucles // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNextLine()) { linea = Lee.nextLine(); // eliminamos caracteres que no nos interezan nuevaLinea = ""; for (i = 0; i < linea.length(); i++) { if ((linea.charAt(i) >= 'A' && linea.charAt(i) <= 'Z') || (linea.charAt(i) >= 'a' && linea.charAt(i) <= 'z')) nuevaLinea += linea.charAt(i); else nuevaLinea += ' '; } // contamos las palabras System.out.println((new StringTokenizer(nuevaLinea)).countTokens()); } } }

Solucion a 113 - Power of Cryptography [http://uva.onlinejudge.org] con Java

Solucion a 113 - Power of Cryptography [http://uva.onlinejudge.org] con Java
El enunciado esta en el siguiente link enunciado

import java.math.BigInteger; import java.util.Scanner; /** * 113 - Power of Cryptography [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 short n; // para el exponente BigInteger p; // para el p grande // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { n = Lee.nextShort(); p = Lee.nextBigInteger(); System.out.println(Math.round(Math.pow(Math.E, (Math.log(p.doubleValue()) / n)))); } } }

Solucion a 102 - Ecological Bin Packing [http://uva.onlinejudge.org]

Solucion a 102 - Ecological Bin Packing [http://uva.onlinejudge.org]
El enunciado esta en el siguiente link enunciado

import java.util.Scanner; /** * 102 - Ecological Bin Packing [http://uva.onlinejudge.org] * * @author BreakDark * @version 1.0 beta */ // ACEPTADO!!! xD public class Main { public static void main(String[] args) { Scanner Lee; // Para leer los datos de entrada int[][] botellas = new int[3][3]; // para las botellas byte[][] combinaciones = { { 0, 1, 2 }, { 0, 2, 1 }, { 1, 0, 2 }, { 1, 2, 0 }, { 2, 0, 1 }, { 2, 1, 0 } }; String[] combiColores = { "BCG", "BGC", "CBG", "CGB", "GBC", "GCB" }; // combinacion // de // colores byte i, j; // para los bucles long may, suma; // para hallar la combinacion que necesita menos cambios byte indCom; // para la mejor combinacion // AQUI INICIA EL PROGRAMA Lee = new Scanner(System.in); while (Lee.hasNext()) { // leemos los datos for (i = 0; i < 3; i++) { botellas[i][0] = Lee.nextInt(); botellas[i][2] = Lee.nextInt(); botellas[i][1] = Lee.nextInt(); } // buscamos la mejor combinacion may = 0; indCom = 0; for (i = 0; i < 6; i++) { suma = botellas[0][combinaciones[i][0]] + botellas[1][combinaciones[i][1]] + botellas[2][combinaciones[i][2]]; if (suma > may) { may = suma; indCom = i; } } // sumamos todos excepto los indices de la mejor combinacion suma = 0; for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) { if (j != combinaciones[indCom][i]) suma += botellas[i][j]; } // mostramos el resultado System.out.println(combiColores[indCom] + " " + suma); } } }