BreakDark: November 2012

Wednesday, November 21, 2012

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

BreakDark