BreakDark: September 2014

Friday, September 26, 2014

Solución al problema 282A - Bit [http://www.codeforces.com] con C++

Para ver el link del problema Click aqui

Thursday, September 18, 2014

Solución al Problema: 96A - Football [http://codeforces.com] Con Java

Para ver el link del problema Click aqui

Solución al Problema: 1C - Ancient Berland Circus [http://codeforces.com] Con Java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 1C - Ancient Berland Circus [http://codeforces.com]
 * Agradecimientos al tutorial publicado por <code>removed1's</code>
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 16/09/2014
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de prueba
        double x1, x2, x3, y1, y2, y3;

        // aqui inicia el programa
        Lee = new Scanner(System.in);
        while (Lee.hasNext()) {
            x1 = Double.parseDouble(Lee.next());
            y1 = Double.parseDouble(Lee.next());
            x2 = Double.parseDouble(Lee.next());
            y2 = Double.parseDouble(Lee.next());
            x3 = Double.parseDouble(Lee.next());
            y3 = Double.parseDouble(Lee.next());
            procesar(x1, y1, x2, y2, x3, y3);
        }
    }

    /**
     * @param x1
     *            coordenada x del primer punto
     * @param y1
     *            coordenada y del primer punto
     * @param x2
     *            coordenada x del segundo punto
     * @param y2
     *            coordenada y del segundo punto
     * @param x3
     *            coordenada x del tercer punto
     * @param y3
     *            coordenada y del tercer punto
     */
    private static void procesar(double x1, double y1, double x2, double y2,
            double x3, double y3) {
        double R; // radio de la circunferencia incrita en un traingulo
        double a, b, c; // distancias
        double A, B, C; // angulos
        double n; // numero de lados
        double area;// area
        // int b; // base

        a = distancia(x1, y1, x2, y2);
        b = distancia(x1, y1, x3, y3);
        c = distancia(x2, y2, x3, y3);
        R = radioDelTriangulo(a, b, c);
        A = anguloDelTriangulo(a, b, c);
        B = anguloDelTriangulo(b, c, a);
        C = anguloDelTriangulo(c, a, b);
        n = Math.round(Math.PI / gcd(gcd(A, B), C));
        area = n / 2 * R * R * Math.sin(2 * Math.PI / n);
        System.out.println(String.format("%6f", area).replace(',', '.'));
    }

    /**
     * El maximo comun divisor de valores double, proporcionado en el foro de
     * codeforces
     * 
     * @param x
     *            Valor x a procesar
     * @param y
     *            Valor y a procesar
     * @return El maximo comun divisor entre <code>x</code> y <code>y</code>
     */
    private static double gcd(double x, double y) {
        double eps = 1 * Math.pow(Math.E, -4);

        while (Math.abs(x) > eps && Math.abs(y) > eps) {
            if (x > y)
                x -= Math.floor(x / y) * y;
            else
                y -= Math.floor(y / x) * x;
        }
        return x + y;
    }

    /**
     * @param a
     *            lado a
     * @param b
     *            lado b
     * @param c
     *            lado c
     * @return El angulo opuesto del lado a
     */
    private static double anguloDelTriangulo(double a, double b, double c) {
        return Math.acos((b * b + c * c - a * a) / (2 * b * c));
    }

    /**
     * @param a
     *            lado a
     * @param b
     *            lado b
     * @param c
     *            lado c
     * @return El radio de la circunferencia que toca los tres vertices del
     *         traingulo
     */
    private static double radioDelTriangulo(double a, double b, double c) {
        double A = areaDelTriangulo(a, b, c);
        return a * b * c / (4 * A);
    }

    /**
     * @param a
     *            lado a
     * @param b
     *            lado b
     * @param c
     *            lado c
     * @return El area del traingulo
     */
    private static double areaDelTriangulo(double a, double b, double c) {
        double s = (a + b + c) / 2;
        return Math.sqrt(s * (s - a) * (s - b) * (s - c));
    }

    /**
     * distancia entre dos puntos
     * 
     * @param x1
     *            coordenada x del primer punto
     * @param y1
     *            coordenada y del primer punto
     * @param x2
     *            coordenada x del segundo punto
     * @param y2
     *            coordenada y del segundo punto
     * @return un double representando la diatancia entre dos puntos
     * @author BreakDark (Jhonny Monrroy)
     * @version 1.0 beta 16/09/2014
     */
    private static double distancia(double x1, double y1, double x2, double y2) {
        double dis = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
        return Math.sqrt(dis);
    }
}

Solución al Problema: 1B - Spreadsheets [http://codeforces.com] Con Java

Para ver el link del problema Click aqui

import java.util.Scanner;
import java.util.StringTokenizer;

/**
 * Solucion al Problema: 1B - Spreadsheets [http://codeforces.com]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 4.0.1 beta 15/09/2014
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de entrada
        int n; // para los n casos
        String coordenadas; // para procesar la cadena
        char[] val = new char[26];

        // INICIA EL PROGRAMA
        val[0] = 'A';
        for (int i = 1; i < 26; i++)
            val[i] = (char) (val[i - 1] + 1);
        Lee = new Scanner(System.in);
        n = Lee.nextInt();
        while (n-- > 0) {
            coordenadas = Lee.next();
            procesar(coordenadas, val);
        }
    }

    /**
     * @param coordenadas
     *            coordenadas a procesar
     * @param val
     *            vector de caracteres
     */
    private static void procesar(String coordenadas, char[] val) {
        int fil, col = 0, i, exp;
        String f;
        StringTokenizer LeeCadena;
        String aux = "";
        char letra;

        if (formatoUno(coordenadas)) {
            coordenadas = coordenadas.replace('R', ' ').replace('C', ' ');
            LeeCadena = new StringTokenizer(coordenadas);
            f = LeeCadena.nextToken();
            col = Integer.parseInt(LeeCadena.nextToken());
            while (col > 0) {
                col--;
                aux = val[col % 26] + aux;
                col /= 26;
            }
            System.out.println(aux + f);
        } else {
            for (i = 0; i < coordenadas.length(); i++) {
                letra = coordenadas.charAt(i);
                if (letra >= 'A' && letra <= 'Z')
                    aux += letra;
                else
                    break;
            }
            fil = Integer.parseInt(coordenadas.substring(i));
            col = 0;
            exp = 0;
            for (i = aux.length() - 1; i >= 0; i--) {
                letra = coordenadas.charAt(i);
                letra++;
                col += ((letra - 'A') * Math.pow(26, exp++));
            }
            System.out.println("R" + fil + "C" + col);
        }
    }

    /**
     * @param coordenadas
     *            cadena a investigar
     * @return true su es del formato 1, false si es del formato 2
     */
    private static boolean formatoUno(String coordenadas) {
        for (char c = 'A'; c <= 'Z'; c++)
            coordenadas = coordenadas.replace(c, ' ');
        return (new StringTokenizer(coordenadas)).countTokens() == 2;
    }
}

Solucion al Problema: 122A - Lucky Division [http://codeforces.com] Con Java

Para ver el link del problema Click aqui

import java.util.BitSet;
import java.util.Scanner;

/**
 * Solucion al Problema: 122A - Lucky Division [http://codeforces.com]
 * 
 * @author BreakDark (Jhonny Monrroy)
 * @version 1.0 beta 18/09/2014
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para ller los datos de entrada
        short n; // numero a evaluar
        BitSet noAfortunados; // numeros no afortunados

        // aqui inicia el programa
        Lee = new Scanner(System.in);
        noAfortunados = generarNoAfortunados();
        while (Lee.hasNext()) {
            n = Lee.nextShort();
            procesar(n, noAfortunados);
        }
    }

    /**
     * Resuelve el problema
     * 
     * @author BreakDark (Jhonny Monrroy)
     * @version 1.0 beta 18/09/2014
     * @param n
     *            numero a evaluar
     * @param noAfortunados
     *            Bitset con los numeros no afortunados
     */
    private static void procesar(short n, BitSet noAfortunados) {
        int i;
        boolean sw = true;

        if (!noAfortunados.get(n))
            System.out.println("YES");
        else {
            for (i = 2; i < n; i++)
                if (!noAfortunados.get(i))
                    if (n % i == 0) {
                        System.out.println("YES");
                        sw = false;
                        break;
                    }
            if (sw)
                System.out.println("NO");
        }
    }

    /**
     * Genera un bitset set marcando los numeros no afortunados
     * 
     * @author BreakDark (Jhonny Monrroy)
     * @version 1.0 beta 18/09/2014
     * @return Un Bitset con los numeros no afortunados marcados
     */
    private static BitSet generarNoAfortunados() {
        BitSet res = new BitSet(1001);
        String aux;
        int i, j;

        for (i = 0; i < 1000; i++) {
            aux = Integer.toString(i);
            for (j = 0; j < aux.length(); j++)
                if (aux.charAt(j) != '4' && aux.charAt(j) != '7')
                    res.set(i);
        }
        return res;
    }
}

Solucion al Problema: 110A - Nearly Lucky Number [http://codeforces.com] en Java

Para ver el link del problema Click aqui

import java.util.Scanner;

/**
 * Solucion al Problema: 110A - Nearly Lucky Number [http://codeforces.com]
 * 
 * @author BreakDark
 * @version 1.0 beta 30/01/2013
 */
// ACEPTADO!!! xD
public class Main {
    public static void main(String[] args) {
        Scanner Lee; // para leer los datos de entrada
        char[] n; // El numero a leer
        byte numDig; // numero de digitos afortunados
        byte i; // para los bucles

        // AQUI INICIA EL PROGRAMA!!!
        Lee = new Scanner(System.in);
        while (Lee.hasNext()) {
            n = Lee.next().toCharArray();
            numDig = 0;
            for (i = 0; i < n.length; i++)
                if (n[i] == '4' || n[i] == '7')
                    numDig++;
            if (numDig == 4 || numDig == 7)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }
}

BreakDark

Friday, September 26, 2014

Solución al problema 282A - Bit [http://www.codeforces.com] con C++

Thursday, September 18, 2014

Solución al Problema: 96A - Football [http://codeforces.com] Con Java

Solución al Problema: 1C - Ancient Berland Circus [http://codeforces.com] Con Java

Solución al Problema: 1B - Spreadsheets [http://codeforces.com] Con Java

Solucion al Problema: 122A - Lucky Division [http://codeforces.com] Con Java

Solucion al Problema: 110A - Nearly Lucky Number [http://codeforces.com] en Java

Contributors

Links