Entregable 1.

ArteAscii.java

import java.awt.*;
import java.awt.image.BufferedImage;

public class ArteAscii {
    /*
     * Problema: 6. Ascii art
     *
     * Escriba un método que muestre en pantalla un dibujo en arte ASCII de su elección.
     * Cree también el método main que invoca al método anterior.
     */


    /**
     * Metodo que es capaz de dibujar una cadena de texto como un dibujo Ascii,
     * esto lo hace por medio de la creación de un Buffer de almacenamiento de la imagen
     * con una configuración prestablecida, y usando el metodo drawString de la clase de
     * gráficos 2D de java, el cual es capaz de dibujar la cadena de texto basado en la configuración
     * del gráfico que fue creado en el buffer.
     *
     * Por ultimo, lee cada una de las posiciones de la imagen y forma una cadena de texto,
     * usando el StringBuilder, en el cual cada posición de la imagen, demarca un caracter
     * que debe ir a la cadena.
     *
     * Por ultimo, imprime la cadena de texto a la consola.
     *
     * @param texto el texto a transformar en imagen.
     * @param caracterArte el caracter con el cual vamos a llenar el lienzo de arte en las zonar en blanco.
     * @param configuracion la configuración del gráfico.
     */
    public void dibujarTexto(String texto, String caracterArte, Configuracion configuracion) {
        BufferedImage imagen = getImageIntegerMode(configuracion.ancho, configuracion.alto);

        Graphics2D grafico2D = getGraphics2D(imagen.getGraphics(), configuracion);
        grafico2D.drawString(texto, 6, 24);

        for (int y = 0; y < configuracion.alto; y++) {
            StringBuilder cadenaGraficoFinal = new StringBuilder();

            for (int x = 0; x < configuracion.ancho; x++) {
                cadenaGraficoFinal.append(imagen.getRGB(x, y) == -16777216 ? " " : caracterArte);
            }

            if (cadenaGraficoFinal.toString().trim().isEmpty()) {
                continue;
            }

            System.out.println(cadenaGraficoFinal);
        }

    }

    /**
     * Buffer en el cual se almacenará la imagen con el tipo TYPE_INT_RGB
     * que se refiere a una imagen con configuración de colores RGB
     * representado por enteros de 8 bits.
     * @param ancho ancho del gráfico
     * @param alto alto del gráfico.
     * @return Buffer de la imagen.
     */
    private BufferedImage getImageIntegerMode(int ancho, int alto) {
        return new BufferedImage(ancho, alto, BufferedImage.TYPE_INT_RGB);
    }


    /**
     * Método que apartir de una configuración y una instancia de
     * gráficos, crea una configuración de gráfico 2D con una fuente
     * seleccionada.
     * @param graficos instancia del gráfico.
     * @param configuracion configuración para creación del gráfico
     * @return instancia gráfico en 2D con fuente.
     */
    private Graphics2D getGraphics2D(Graphics graficos, Configuracion configuracion) {
        // agregamos la fuente en la cual se va a crear el dibujo
        graficos.setFont(configuracion.fuente);

        // Leemos el gráfico como si fuera un gráfico 2D
        Graphics2D graphics2D = (Graphics2D) graficos;

        // agregamos la configuración para el algoritmo de creación
        // del grafico.
        graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

        return graphics2D;
    }


    /**
     * Clase de utilidad donde almacenaremos
     * las opciones de configuración que utilizaremos
     * para crear el dibujo
     */
    public static class Configuracion {
        public Font fuente;
        public int ancho;
        public int alto;

        public Configuracion(Font fuente, int ancho, int alto) {
            this.fuente = fuente;
            this.ancho = ancho;
            this.alto = alto;
        }
    }

    public static void main(String[] args) {
        ArteAscii arte = new ArteAscii();
        Font fuente = new Font("Dialog", Font.PLAIN, 24);
        Configuracion configuracion = new Configuracion(fuente, 144, 32);
        arte.dibujarTexto("ARTE ASCII", "*", configuracion);
    }
}

ConversionMedidasLongitud.java

import java.util.Scanner;

public class ConversionMedidasLongitud {

    /*
     * Problema: 2. Conversión de medidas de longitud
     *
     * Escriba un programa que pida al usuario una longitud
     * en metros y muestre en pantalla las conversiones de dicha
     * cantidad a centímetros, milímetros, pies, pulgadas, yardas,
     * años luz y angstroms.
     *
     * Use métodos adecuadamente.
     */

    /**
     * Objeto enumerable donde almacenaremos todos los valores constantes
     * de las medidas para reutilizar la funcionalidad de transformar el
     * valor de metros.
     *
     * A diferencia de una clase, un objeto enumerable nos permite declarar
     * los valores directamente en vez de instanciar cuando la aplicación se ejecute.
     */
    enum Medida {
        CM("CENTIMETROS", 100.0),
        FT("PIES",  3.28084),
        MM("MILIMETROS",  1000.0),
        IN("PULGADAS",  39.3701),
        YD("YARDAS",  1.09361),
        LY("AÑOS LUZ",  1.057e-16),
        A("ANGSTROMS",  1e+10);

        private String nombre;
        private Double cantidad;

        Medida(String nombre, Double cantidad) {
            this.nombre = nombre;
            this.cantidad = cantidad;
        }

        /**
         * Función que convierte los metros a la unidad del
         * objeto enum.
         * @param metros cantidad de metros a transformar
         * @return resultado de transformar los metros a la unidad del enum.
         */
        private Double convertirMetrosAMedida(Double metros) {
            return metros * cantidad;
        }

        /**
         * Función que crea una cadena de texto con la transformación.
         * @param metros cantidad de metros a transformar
         * @return mensaje de transformación en la unidad del enum.
         */
        public String mensajeMetrosAMedida(Double metros) {
            Double resultadoTransformacion = convertirMetrosAMedida(metros);
            return metros + " metros en " + nombre  + " es igual a " + resultadoTransformacion;
        }
    }



    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Programa de transformación de metros a centimetros, milimetros, " +
                "pies, pulgadas, yardas, años luz y angstroms.");
        System.out.println("Escriba la longitud en metros");
        double metros = scanner.nextDouble();
        System.out.println("Los valores de medida de " + metros + " en otras medidas es:");
        System.out.println(Medida.CM.mensajeMetrosAMedida(metros));
        System.out.println(Medida.FT.mensajeMetrosAMedida(metros));
        System.out.println(Medida.MM.mensajeMetrosAMedida(metros));
        System.out.println(Medida.IN.mensajeMetrosAMedida(metros));
        System.out.println(Medida.YD.mensajeMetrosAMedida(metros));
        System.out.println(Medida.LY.mensajeMetrosAMedida(metros));
        System.out.println(Medida.A.mensajeMetrosAMedida(metros));

    }
}

ConversionMedidasTemperatura.java

import java.util.Scanner;

public class ConversionMedidasTemperatura {

    /*
     * Problema: 3. Temperatura
     *
     * Escriba un programa que pida al usuario una cantidad
     * correspondiente a una temperatura en grados centígrados
     * y muestre en pantalla las conversiones de dicha cantidad
     * a grados Fahrenheit, Kelvin y Rankine.
     *
     * Use métodos adecuadamente.
     */

    /**
     * Objeto enumerable donde almacenaremos todos los valores constantes
     * de las medidas de temperatura para reutilizar la funcionalidad
     * de transformar el valor de grados centigrados.
     *
     * A diferencia de una clase, un objeto enumerable nos permite declarar
     * los valores directamente en vez de instanciar cuando la aplicación se ejecute.
     */
    enum Medida {
        F("Fahrenheit", 33.8),
        K("Kelvin",  274.15),
        R("Rankine",  493.47);

        private String nombre;
        private Double cantidad;

        Medida(String nombre, Double cantidad) {
            this.nombre = nombre;
            this.cantidad = cantidad;
        }

        /**
         * Función que convierte los grados centigrados
         * a la unidad del objeto enum.
         * @param centigrados cantidad de centigrados a transformar
         * @return resultado de transformar los centigrados a la unidad del enum.
         */
        private Double convertirCentigradosAMedida(Double centigrados) {
            return centigrados * cantidad;
        }

        /**
         * Función que crea una cadena de texto con la transformación.
         * @param centigrados cantidad de centigrados a transformar
         * @return mensaje de transformación en la unidad del enum.
         */
        public String mensajeCentigradosAMedida(Double centigrados) {
            Double resultadoTransformacion = convertirCentigradosAMedida(centigrados);
            return centigrados + " grados centigrados en " + nombre  + " es igual a " + resultadoTransformacion;
        }
    }



    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Programa de transformación de grados centigrados " +
                "en Fahrenheit, Kelvin y Rankine.");
        System.out.println("Escriba la cantidad de grados centigrados");
        double metros = scanner.nextDouble();
        System.out.println("Los valores de medida de " + metros + " centigrados en otras unidades es:");
        System.out.println(Medida.F.mensajeCentigradosAMedida(metros));
        System.out.println(Medida.K.mensajeCentigradosAMedida(metros));
        System.out.println(Medida.R.mensajeCentigradosAMedida(metros));

    }
}

Cuaderno.java

import java.util.Scanner;

public class Cuaderno {
    /*
     * Problema: 5. Cuaderno
     *
     * Escriba un programa que pida al usuario los valores de A y B,
     * y muestre en pantalla la solución del siguiente problema:
     * A María se le acaba de ocurrir una pregunta muy interesante sobre su cuaderno:
     * ¿Cuántos cuadritos hay en cada página?
     * María, que es muy inteligente, sabe que no es necesario contar todos los cuadros;
     * en cambio, usa su regla para realizar las siguientes mediciones:
     *
     * » Cada página del cuaderno mide A centímetros de largo por B de ancho.
     * » El margen de cada página es de 1 centímetro arriba, 1 centímetro abajo,
     *   medio centímetro a la izquierda y medio centímetro a la derecha.
     * » Cada cuadro de la cuadrícula mide medio centímetro por medio centímetro.
     *
     * » ¿Cuántos cuadritos hay en cada página del cuaderno de María?
     */

    static Double MARGEN_ARRIBA = 1.0;
    static Double MARGEN_ABAJO = 1.0;
    static Double MARGEN_IZQUIERDA = 0.5;
    static Double MARGEN_DERECHA = 0.5;


    /**
     * Función que calcula la centidad de cuadritos de una pagina de A de largo por B de ancho.
     * Primero elimina las margenes de cada medida de cada medida, luego transforma cada centimetro
     * en la cantidad de cuadritos que caben en un centimetro
     *
     * Ejemplo:
     *         - En una linea de 1 cm caben 2 lineas de 0.5 centimetros
     *         - En un cuadrito de 1 cm caben 4 cuadritos de 0.5 centimetros
     *
     * @param centimetrosLargo centimetros de largo de la hoja
     * @param centimetroAncho centimetros de ancho de la hoja
     * @return cantidad de cuadritos en la hoja.
     */
    public static double calcularCuadritos(double centimetrosLargo, double centimetroAncho) {
        double centrimetrosLargoSinMargen = centimetrosLargo - MARGEN_ARRIBA - MARGEN_ABAJO;
        double centrimetrosAnchoSinMargen = centimetroAncho - MARGEN_IZQUIERDA - MARGEN_DERECHA;
        double cantidadDeMediosCentimetrosLargo = centrimetrosLargoSinMargen * 2; // 1 cm = 0.5 cm + 0.5 cm
        double cantidadDeMediosCentimetrosAncho = centrimetrosAnchoSinMargen * 2; // 1 cm = 0.5 cm + 0.5 cm
        return cantidadDeMediosCentimetrosLargo * cantidadDeMediosCentimetrosAncho;
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Programa de cuadritos en cada pagina del cuaderno de María.");
        System.out.println("Por favor escriba los siguientes datos, presionando enter después de cada dato.");
        System.out.println("Centimetros de largo (A)");
        double centimetrosLargo = scanner.nextDouble();
        System.out.println("Centimetros de ancho (B)");
        double centimetrosAncho = scanner.nextDouble();
        double cuadritos = calcularCuadritos(centimetrosLargo, centimetrosAncho);
        System.out.println("En una hoja de " + centimetrosLargo + " cm de largo * "
                + centimetrosAncho + " cm ancho");
        System.out.println("Hay " + cuadritos + " cuadritos");
    }
}

HorasASegundos.java

import java.util.Scanner;

public class HorasASegundos {

    /*
     * Problema: 1. Hora a segundos
     *
     * a. Escriba un método que reciba tres enteros correspondientes
     *    a la hora actual (horas, minutos y segundos), y retorne el número
     *    de segundos que han transcurrido desde la medianoche.
     *    Use el formato de 24 horas.
     *
     * b. Escriba un programa que pida al usuario los valores de horas,
     *    minutos y segundos, y muestre en pantalla el valor retornado
     *    por el método del literal a.
     */

    /**
     * Función que calcula los segundos a partir de una hora.
     * @param horas hora en formato 24 horas.
     * @param minutos minutos de la hora.
     * @param segundos segundos de la hora
     * @return la cantidad de segundos desde la media noche.
     */
    public static Integer segundosDesdeMediaNoche(Integer horas, Integer minutos, Integer segundos) {
        Integer horasASegundos = horas * 3600;
        Integer minutosASegudos = minutos * 60;
        return horasASegundos + minutosASegudos + segundos;
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Programa de transformación de hora actual a segundos desde la media noche.");
        System.out.println("Por favor escriba los siguientes datos, presionando enter después de cada dato.");
        System.out.println("Escriba la hora actual (Formato 24 horas)");
        Integer horas = scanner.nextInt();
        System.out.println("Escriba el minuto actual");
        Integer minutos = scanner.nextInt();
        System.out.println("Escriba el segundo actual");
        Integer segundos = scanner.nextInt();
        Integer segundosDesdeMediaNoche = segundosDesdeMediaNoche(horas, minutos, segundos);
        String horaActual = horas + ":" + minutos + ":" + segundos;
        System.out.println("Los segundos desde media noche para la hora: " + horaActual + " son: " + segundosDesdeMediaNoche);
    }
}

Ofertas.java

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Ofertas {
    /*
     * Ejercicio 4: Ofertas
     * Escriba un programa que pida al usuario los valores de A, B, C y D, y muestre en pantalla
     * la solución del siguiente problema:
     * Bélen desea comprar tres camisetas. En una tienda, cada
     * camiseta tiene un costo de A pesos y por comprar tres
     * dan un descuento de D% sobre el valor total de la compra.
     * En otra tienda, cada camiseta tiene un costo de B pesos y tienen
     * una oferta de lleve tres camisetas y pague dos.
     * En otra tienda, cada camiseta tiene un costo de C pesos
     * y no ofrecen ningún tipo de oferta.
     *
     * ¿Cuál es el menor valor que puede pagar Bélen por las tres camisetas?
     */


    /**
     * Clase de utilidad donde almacenaremos el nombre
     * y descuento de cada tienda para calcular el precio
     * a pagar por la compra de 3 camisetas.
     */
    static class Tienda implements Comparable<Tienda>{
        private String nombre;
        private Double costoCamiseta;
        private Double descuento;

        Tienda(String nombre, Double costoCamiseta, Double descuento) {
            this.nombre = nombre;
            this.costoCamiseta = costoCamiseta;
            this.descuento = descuento;
        }


        /**
         * Función que nos permite calcular el valor
         * de comprar 3 camisetas en esta tienda
         * teniendo el cuenta el valor de descuento.
         * @return el valor de compra total menos el descuento.
         */
        public Double valor3camisetas() {
            Double totalCamisetas = costoCamiseta * 3;
            Double totalDescuento = totalCamisetas * descuento / 100;
            return totalCamisetas - totalDescuento;
        }


        public String valorEnTienda() {
            Double valor3CamisetasEnTienda = valor3camisetas();
            String solo2DecimalesValor = String.format("%.2f", valor3CamisetasEnTienda);
            return nombre + " : " + solo2DecimalesValor;
        }

        /**
         * Metodo que nos permite comparar el valor de 3 camisetas
         * en esta tienda contra el valor de las mismas 3 camisetas
         * en otra tienda
         * @param otraTienda la tienda contra la cual vamor a comparar.
         * @return * 0 si el valor de esta tienda es igual al valor en la otra tienda
         *         * Un valor menor a 0 si el valor en esta tienda es menor que en la otra tienda.
         *         * Un valor mayor a 0 si el valor en esta tienda es mayor que en la otra tienda.
         */
        public int compareTo(Tienda otraTienda) {
            Double valorEnEstaTienda = this.valor3camisetas();
            Double valorEnOtraTienda = otraTienda.valor3camisetas();
            return Double.compare(valorEnEstaTienda, valorEnOtraTienda);
        }
    }

    /**
     * Función a donde enviamos todas las tiendas para
     * determinar cual es la tienda en donde cuesta menos
     * comprar 3 camisetas.
     *
     * @return la tienda donde cuesta menos
     */
    public static Tienda calcularTiendaDondeCuestaMenos(List<Tienda> tiendas) {
        /*
         * El metodo Collections.min retorna el minimo valor de una colección,
         * en este caso una tienda de la lista de tiendas, utilizando la función compareTo
         * que está implementada en la clase tienda, la cual compara los valores
         * de comprar 3 camisetas entre 2 tiendas.
         */
        return Collections.min(tiendas);
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Programa de calculo de mejor oferta para Bélen para comprar 3 camisetas.");
        System.out.println("Por favor escriba los siguientes datos, presionando enter después de cada dato.");
        System.out.println("Precio en tienda 1 (A)");
        Double precio1 = scanner.nextDouble();
        System.out.println("Porcentaje de descuento en tienda 1 (valor de 1 a 100) - (D)");
        Double descuento1 = scanner.nextDouble();
        System.out.println("Precio en Tienda 2 (B)");
        Double precio2 = scanner.nextDouble();
        System.out.println("Precio en Tienda 3 (C)");
        Double precio3 = scanner.nextDouble();

        // creamos las 3 tiendas
        Tienda tienda1 = new Tienda("Tienda 1", precio1, descuento1);
        //33 % es lo mismo que pague 2 lleve 3.
        Tienda tienda2 = new Tienda("Tienda 2", precio2, 33.3333);
        Tienda tienda3 = new Tienda("Tienda 3", precio3, 0.0);

        // calculamos e imprimimos el resultado.
        List<Tienda> tiendas = Arrays.asList(
                tienda1,
                tienda2,
                tienda3
        );

        System.out.println("El precio que pagaría Bélen en cada tienda es: ");

        //Recorremos la lista de tiendas para imprimir su valor para Bélen
        for (Tienda tienda : tiendas) {
            // Imprimimos el valor dentro de la tienda.
            System.out.println("\t " + tienda.valorEnTienda());
        }

        // calculamos la tienda donde cuesta menos comprar 3 camisetas.
        Tienda tiendaDondeCuestaMenos = calcularTiendaDondeCuestaMenos(tiendas);

        System.out.println("La tienda donde Bélen puede pagar el menor valor por 3 camisetas es");
        System.out.println(tiendaDondeCuestaMenos.valorEnTienda());

    }
}