Ejercicios resueltos de Programación

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        if (n == 0) {            System.out.println("cero");        } else {            String signo = n > 0 ? "positivo" : "negativo";            String paridad = n % 2 == 0 ? "par" : "impar";            System.out.println(signo + " " + paridad);        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int a = sc.nextInt(), b = sc.nextInt();        int pasos = 0;        while (b != 0) {            pasos++;            int cociente = a / b, resto = a % b;            System.out.println("Paso " + pasos + ": " + a + " = " + cociente + " · " + b + " + " + resto);            a = b;            b = resto;        }        System.out.println("mcd = " + a + " en " + pasos + (pasos == 1 ? " paso" : " pasos"));    }}

import java.util.Scanner; public class Main {    static String aBase(int n, int base) {        if (n == 0) return "0";        String cifras = "0123456789ABCDEF";        StringBuilder sb = new StringBuilder();        while (n > 0) {            sb.append(cifras.charAt(n % base));   // el resto es la cifra            n /= base;        }        return sb.reverse().toString();          // los restos se leen de abajo arriba    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            int n = sc.nextInt();            System.out.println(n + " → binario " + aBase(n, 2) + " · octal " + aBase(n, 8) + " · hexadecimal " + aBase(n, 16));        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String[]> programa = new ArrayList<>();        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (!l.isEmpty() && !l.startsWith(";")) programa.add(l.split("\\s+"));        }        int[] memoria = new int[16];        int acumulador = 0, pc = 0, ejecutadas = 0;        while (true) {            if (pc < 0 || pc >= programa.size()) {                System.out.println("ERROR: el programa termina sin HALT");                return;            }            if (ejecutadas == 1000) {                System.out.println("ERROR: demasiadas instrucciones (¿bucle infinito?)");                return;            }            // Captación: la instrucción a la que apunta el PC; el PC pasa a la siguiente            String[] ins = programa.get(pc);            int linea = pc;            pc++;            ejecutadas++;            int arg = ins.length > 1 && !ins[1].startsWith(";") ? Integer.parseInt(ins[1]) : 0;            // Ejecución            switch (ins[0]) {                case "LOADI" -> acumulador = arg;                case "LOAD" -> acumulador = memoria[arg];                case "STORE" -> memoria[arg] = acumulador;                case "ADD" -> acumulador += memoria[arg];                case "SUB" -> acumulador -= memoria[arg];                case "JMP" -> pc = arg;                case "JZ" -> { if (acumulador == 0) pc = arg; }                case "JNEG" -> { if (acumulador < 0) pc = arg; }                case "PRINT" -> System.out.println(acumulador);                case "HALT" -> {                    System.out.println("HALT tras " + ejecutadas + " instrucciones · acumulador = " + acumulador);                    return;                }                default -> {                    System.out.println("ERROR: instrucción desconocida " + ins[0] + " en la línea " + linea);                    return;                }            }        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        long total = sc.nextLong();        long dias = total / 86400;        long horas = total % 86400 / 3600;        long minutos = total % 3600 / 60;        long segundos = total % 60;        System.out.println(total + " s = " + dias + " d " + horas + " h " + minutos + " min " + segundos + " s");        System.out.printf("Formato reloj: %02d:%02d:%02d (+%d %s)%n", horas, minutos, segundos, dias, dias == 1 ? "día" : "días");    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int a = sc.nextInt(), b = sc.nextInt();        System.out.println("int: " + a + " * " + b + " = " + (a * b));        System.out.println("long: " + a + " * " + b + " = " + ((long) a * b));        System.out.println("división entera: " + a + " / " + b + " = " + (a / b));        double real = (double) a / b;        System.out.println("división real: " + a + " / " + b + " = " + real);        System.out.println("casting: (int) " + real + " = " + (int) real);        int k = Math.abs(a) % 26;        char letra = (char) ('A' + k);        System.out.println("char: 'A' + " + k + " = " + letra + " (código " + (int) letra + ")");    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in).useLocale(Locale.US);        double capital = sc.nextDouble();        double interesAnual = sc.nextDouble();        int anios = sc.nextInt();        int n = anios * 12;        double i = interesAnual / 100 / 12;        double cuota = i == 0 ? capital / n : capital * i / (1 - Math.pow(1 + i, -n));        System.out.printf(Locale.US, "Cuota mensual: %.2f EUR (%d cuotas)%n", cuota, n);        System.out.printf(Locale.US, "Total pagado: %.2f EUR · intereses: %.2f EUR%n", cuota * n, cuota * n - capital);        double pendiente = capital;        for (int k = 1; k <= Math.min(3, n); k++) {            double intereses = pendiente * i;            double amortiza = cuota - intereses;            pendiente -= amortiza;            System.out.printf(Locale.US, "Cuota %d: intereses %.2f · amortiza %.2f · pendiente %.2f%n", k, intereses, amortiza, pendiente);        }    }}

import java.util.Scanner; public class Main {    static String simbolico(int permisos) {        String letras = "rwx";        StringBuilder sb = new StringBuilder();        for (int bit = 8; bit >= 0; bit--) {            sb.append((permisos & (1 << bit)) != 0 ? letras.charAt((8 - bit) % 3) : '-');        }        return sb.toString();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int permisos = Integer.parseInt(sc.next(), 8);        System.out.println("Inicial: " + String.format("%03o", permisos) + " " + simbolico(permisos));        while (sc.hasNext()) {            String orden = sc.next();            String quien = sc.next();            int bits = 0;            for (char c : orden.substring(1).toCharArray()) bits |= c == 'r' ? 4 : c == 'w' ? 2 : 1;            for (char g : (quien.equals("a") ? "ugo" : quien).toCharArray()) {                int desp = g == 'u' ? 6 : g == 'g' ? 3 : 0;   // posición del grupo                int mascara = bits << desp;                switch (orden.charAt(0)) {                    case '+' -> permisos |= mascara;                    case '-' -> permisos &= ~mascara;                    default -> permisos = (permisos & ~(7 << desp)) | mascara;   // = : se borra el grupo y se ponen los bits                }            }            System.out.println(orden + " " + quien + " → " + String.format("%03o", permisos) + " " + simbolico(permisos));        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int nota = sc.nextInt();        if (nota < 0 || nota > 10) {            System.out.println("Nota no valida");        } else if (nota <= 4) {            System.out.println("Suspenso");        } else if (nota == 5) {            System.out.println("Aprobado");        } else if (nota == 6) {            System.out.println("Bien");        } else if (nota <= 8) {            System.out.println("Notable");        } else {            System.out.println("Sobresaliente");        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            int a = sc.nextInt();            boolean bisiesto = (a % 4 == 0 && a % 100 != 0) || a % 400 == 0;            System.out.println(a + (bisiesto ? ": bisiesto" : ": no bisiesto"));        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        int nota = new Scanner(System.in).nextInt();        switch (nota) {            case 5:                System.out.println("Suficiente");                break;            case 6:                System.out.println("Bien");                break;            case 7:            case 8:                System.out.println("Notable");                break;            case 9:            case 10:                System.out.println("Sobresaliente");                break;            default:                System.out.println("Insuficiente");        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int anio = sc.nextInt();         boolean bisiesto = (anio % 4 == 0 && anio % 100 != 0) || anio % 400 == 0;         if (bisiesto) {            System.out.println(anio + " es bisiesto");        } else {            System.out.println(anio + " no es bisiesto");        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            int d = sc.nextInt(), m = sc.nextInt(), a = sc.nextInt();            boolean bisiesto = (a % 4 == 0 && a % 100 != 0) || a % 400 == 0;            String fecha = String.format("%02d/%02d/%04d", d, m, a);            if (m < 1 || m > 12) {                System.out.println(fecha + ": no válida (el mes debe estar entre 1 y 12)");                continue;            }            int[] dias = {31, bisiesto ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};            if (d < 1 || d > dias[m - 1]) {                System.out.println(fecha + ": no válida (ese mes tiene " + dias[m - 1] + " días)");                continue;            }            int sd = d + 1, sm = m, sa = a;            if (sd > dias[m - 1]) {       // fin de mes                sd = 1;                sm++;                if (sm > 12) {            // fin de año                    sm = 1;                    sa++;                }            }            System.out.println(fecha + " → siguiente: " + String.format("%02d/%02d/%04d", sd, sm, sa) + (bisiesto ? " (año bisiesto)" : ""));        }    }}

import java.util.*; public class Main {    static double escala(double base) {        double[] limites = {12450, 20200, 35200, 60000, 300000, Double.MAX_VALUE};        double[] tipos = {0.19, 0.24, 0.30, 0.37, 0.45, 0.47};        double impuesto = 0, anterior = 0;        for (int i = 0; i < limites.length && base > anterior; i++) {            impuesto += (Math.min(base, limites[i]) - anterior) * tipos[i];   // la parte de la base que cae en este tramo            anterior = limites[i];        }        return impuesto;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in).useLocale(Locale.US);        double bruto = sc.nextDouble();        int hijos = sc.nextInt();        int edad = sc.nextInt();        double ss = bruto * 0.0635;        double base = Math.max(0, bruto - ss - 2000);        double minimo = 5550 + (edad > 65 ? 1150 : 0);        double[] porHijo = {2400, 2700, 4000};        for (int h = 0; h < hijos; h++) minimo += h < 3 ? porHijo[h] : 4500;        double cuota = minimo < base ? escala(base) - escala(minimo) : 0;        double neto = bruto - ss - cuota;        System.out.printf(Locale.US, "Base liquidable: %.2f%n", base);        System.out.printf(Locale.US, "Mínimo personal y familiar: %.2f%n", minimo);        System.out.printf(Locale.US, "Cuota de IRPF: %.2f%n", cuota);        System.out.printf(Locale.US, "Tipo efectivo: %.2f %%%n", cuota / bruto * 100);        System.out.printf(Locale.US, "Neto anual: %.2f · al mes (14 pagas): %.2f%n", neto, neto / 14);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();         for (int i = 1; i <= 10; i++) {            System.out.println(n + " x " + i + " = " + (n * i));        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        int n = new Scanner(System.in).nextInt();        int suma = 0;        for (int i = 1; i <= n; i++) {            suma += i;        }        System.out.println("Suma: " + suma);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        int suma = 0;         while (n > 0) {            suma += n % 10;   // la última cifra            n /= 10;          // se quita la última cifra        }         System.out.println("Suma: " + suma);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int suma = 0, contador = 0;        int n = sc.nextInt();        while (n != 0) {            suma += n;            contador++;            n = sc.nextInt();        }        double media = (double) suma / contador;        System.out.printf(java.util.Locale.US, "Media: %.2f%n", media);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int a = sc.nextInt(), b = sc.nextInt();         StringBuilder secuencia = new StringBuilder();        long x = a;        secuencia.append(x);        while (x != 1) {            x = x % 2 == 0 ? x / 2 : 3 * x + 1;            secuencia.append(" → ").append(x);        }        System.out.println(secuencia);         int mejor = a, maxPasos = -1;        long maximo = 0;        for (int n = a; n <= b; n++) {            long v = n;            int pasos = 0;            maximo = Math.max(maximo, v);            while (v != 1) {                v = v % 2 == 0 ? v / 2 : 3 * v + 1;                pasos++;                maximo = Math.max(maximo, v);            }            if (pasos > maxPasos) {   // con > (y no >=) gana el menor en caso de empate                maxPasos = pasos;                mejor = n;            }        }        System.out.println("Entre " + a + " y " + b + ": " + mejor + " necesita " + maxPasos + " pasos; el valor más alto alcanzado es " + maximo);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int anio = sc.nextInt(), mes = sc.nextInt();        String[] nombres = {"Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto",                            "Septiembre", "Octubre", "Noviembre", "Diciembre"};        String[] semana = {"lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"};         boolean bisiesto = (anio % 4 == 0 && anio % 100 != 0) || anio % 400 == 0;        int[] diasMes = {31, bisiesto ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};        int dias = diasMes[mes - 1];         // Zeller: enero y febrero cuentan como los meses 13 y 14 del año anterior        int m = mes, y = anio;        if (m < 3) {            m += 12;            y--;        }        int k = y % 100, j = y / 100;        int h = (1 + 13 * (m + 1) / 5 + k + k / 4 + j / 4 + 5 * j) % 7;        int primero = (h + 5) % 7;   // 0 = lunes … 6 = domingo         System.out.println(nombres[mes - 1] + " " + anio);        System.out.println("Lu Ma Mi Ju Vi Sá Do");        StringBuilder linea = new StringBuilder("   ".repeat(primero));        int finde = 0;        for (int d = 1; d <= dias; d++) {            int col = (primero + d - 1) % 7;            if (col >= 5) finde++;            linea.append(String.format("%2d", d));            if (col == 6 || d == dias) {                System.out.println(linea);                linea.setLength(0);            } else {                linea.append(' ');            }        }        System.out.println(dias + " días · " + finde + " de fin de semana · empieza en " + semana[primero]);    }}

import java.util.Scanner; public class Main {     static boolean esPrimo(int n) {        if (n < 2) return false;        for (int d = 2; d * d <= n; d++) {            if (n % d == 0) return false;   // tiene un divisor: no es primo        }        return true;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int limite = sc.nextInt();        StringBuilder sb = new StringBuilder();        for (int i = 2; i <= limite; i++) {            if (esPrimo(i)) sb.append(i).append(" ");        }        System.out.println(sb.toString().trim());    }}

import java.util.Scanner; public class Main {     static long factorial(int n) {        if (n <= 1) return 1;            // caso base: 0! = 1! = 1        return n * factorial(n - 1);     // caso recursivo    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        System.out.println(n + "! = " + factorial(n));    }}

public class Main {    static double aplicarDescuento(double precio, int porcentaje) {        return precio - precio * porcentaje / 100;    }     public static void main(String[] args) {        double precio = 50;        precio = aplicarDescuento(precio, 20);        System.out.println("Precio final: " + precio);    }}

import java.util.Scanner; public class Main {    static int movimientos = 0;     static void hanoi(int n, char origen, char destino, char auxiliar, boolean mostrar) {        if (n == 0) return;        hanoi(n - 1, origen, auxiliar, destino, mostrar);   // los n-1 de encima, al auxiliar        movimientos++;        if (mostrar) System.out.println("Disco " + n + ": " + origen + " → " + destino);        hanoi(n - 1, auxiliar, destino, origen, mostrar);   // y otra vez encima del disco n    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        hanoi(n, 'A', 'C', 'B', n <= 4);        System.out.println(n + (n == 1 ? " disco: " : " discos: ") + movimientos + (movimientos == 1 ? " movimiento" : " movimientos") + " (2^" + n + " - 1 = " + ((1L << n) - 1) + ")");    }}

import java.util.Scanner; public class Main {    static String texto;    static int pos;     static class ErrorExpresion extends RuntimeException {        ErrorExpresion(String mensaje) { super(mensaje); }    }     static boolean hay(char c) {        return pos < texto.length() && texto.charAt(pos) == c;    }     static long expresion() {        long valor = termino();        while (hay('+') || hay('-')) {            char op = texto.charAt(pos++);            long otro = termino();            valor = op == '+' ? valor + otro : valor - otro;        }        return valor;    }     static long termino() {        long valor = factor();        while (hay('*') || hay('/') || hay('%')) {            char op = texto.charAt(pos++);            long otro = factor();            if (op != '*' && otro == 0) throw new ErrorExpresion("división entre cero");            valor = op == '*' ? valor * otro : op == '/' ? valor / otro : valor % otro;        }        return valor;    }     static long factor() {        if (pos >= texto.length()) throw new ErrorExpresion("la expresión termina antes de tiempo");        if (hay('-')) {            pos++;            return -factor();        }        if (hay('(')) {            pos++;            long valor = expresion();   // la recursividad: una expresión completa dentro del paréntesis            if (!hay(')')) throw new ErrorExpresion("falta «)»");            pos++;            return valor;        }        int inicio = pos;        while (pos < texto.length() && Character.isDigit(texto.charAt(pos))) pos++;        if (inicio == pos) throw new ErrorExpresion("se esperaba un número en la posición " + pos);        return Long.parseLong(texto.substring(inicio, pos));    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String linea = sc.nextLine();            if (linea.isBlank()) continue;            texto = linea.replace(" ", "");            pos = 0;            try {                long valor = expresion();                if (pos < texto.length()) throw new ErrorExpresion("sobra «" + texto.charAt(pos) + "» en la posición " + pos);                System.out.println(linea.trim() + " = " + valor);            } catch (ErrorExpresion e) {                System.out.println(linea.trim() + " → error: " + e.getMessage());            }        }    }}

public class Main {    public static void main(String[] args) {        int[] numeros = {34, 12, 78, 5, 90, 23, 67, 45};         int max = numeros[0];        int posMax = 0;        int min = numeros[0];        int posMin = 0;        for (int i = 1; i < numeros.length; i++) {            if (numeros[i] > max) {                max = numeros[i];                posMax = i;            }            if (numeros[i] < min) {                min = numeros[i];                posMin = i;            }        }         System.out.println("Maximo: " + max + " (posicion " + posMax + ")");        System.out.println("Minimo: " + min + " (posicion " + posMin + ")");    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        int[] t = new int[n];        for (int i = 0; i < n; i++) t[i] = sc.nextInt();        int max = t[0];        for (int x : t) {            if (x > max) max = x;        }        System.out.println("Máxima: " + max);    }}

import java.util.Arrays; public class Main {    public static void main(String[] args) {        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};         System.out.println("Original:  " + Arrays.toString(array));         for (int i = 0, j = array.length - 1; i < j; i++, j--) {            int tmp = array[i];            array[i] = array[j];            array[j] = tmp;        }         System.out.println("Invertido: " + Arrays.toString(array));    }}

public class Main {    public static void main(String[] args) {        double[] notas = {8.5, 4.0, 6.5, 9.0, 3.5, 7.0, 5.0, 8.0, 2.5, 6.0};         double suma = 0;        int aprobados = 0;        int suspensos = 0;        double maxima = notas[0];        double minima = notas[0];         for (double nota : notas) {            suma += nota;            if (nota >= 5) aprobados++;            else suspensos++;            maxima = Math.max(maxima, nota);            minima = Math.min(minima, nota);        }         double media = suma / notas.length;         System.out.printf("Media: %.2f%n", media);        System.out.println("Aprobados: " + aprobados);        System.out.println("Suspensos: " + suspensos);        System.out.printf("Nota maxima: %.1f%n", maxima);        System.out.printf("Nota minima: %.1f%n", minima);    }}

public class Main {    public static void main(String[] args) {        int[][] matriz = {            {1, 2, 3},            {4, 5, 6},            {7, 8, 9}        };         for (int i = 0; i < matriz.length; i++) {            int sumaFila = 0;            for (int j = 0; j < matriz[i].length; j++) {                sumaFila += matriz[i][j];            }            System.out.println("Fila " + i + ": " + sumaFila);        }         for (int j = 0; j < matriz[0].length; j++) {            int sumaCol = 0;            for (int i = 0; i < matriz.length; i++) {                sumaCol += matriz[i][j];            }            System.out.println("Col " + j + ": " + sumaCol);        }    }}

import java.util.*; public class Main {    static boolean[][] siguiente(boolean[][] t) {        int filas = t.length, cols = t[0].length;        boolean[][] nueva = new boolean[filas][cols];        for (int i = 0; i < filas; i++) {            for (int j = 0; j < cols; j++) {                int vecinas = 0;                for (int di = -1; di <= 1; di++) {                    for (int dj = -1; dj <= 1; dj++) {                        int a = i + di, b = j + dj;                        if ((di != 0 || dj != 0) && a >= 0 && a < filas && b >= 0 && b < cols && t[a][b]) vecinas++;                    }                }                nueva[i][j] = t[i][j] ? vecinas == 2 || vecinas == 3 : vecinas == 3;            }        }        return nueva;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int generaciones = sc.nextInt();        List<String> filas = new ArrayList<>();        while (sc.hasNext()) filas.add(sc.next());        boolean[][] t = new boolean[filas.size()][filas.get(0).length()];        for (int i = 0; i < t.length; i++)            for (int j = 0; j < t[0].length; j++) t[i][j] = filas.get(i).charAt(j) == '#';         for (int g = 1; g <= generaciones; g++) {            boolean[][] nueva = siguiente(t);            if (Arrays.deepEquals(nueva, t)) {                System.out.println("Estable desde la generación " + (g - 1));                break;            }            t = nueva;        }         int vivas = 0;        for (boolean[] fila : t) {            StringBuilder sb = new StringBuilder();            for (boolean c : fila) {                sb.append(c ? '#' : '.');                if (c) vivas++;            }            System.out.println(sb);        }        System.out.println("Células vivas: " + vivas);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String frase = sc.nextLine();        int vocales = 0;         for (char c : frase.toCharArray()) {            if ("aeiouAEIOU".indexOf(c) >= 0) vocales++;        }         System.out.println("Vocales: " + vocales);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        String clave = new Scanner(System.in).nextLine();        if (clave.equals("java2025")) {            System.out.println("Acceso concedido");        } else {            System.out.println("Acceso denegado");        }    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String frase = sc.nextLine();         String limpia = frase.replace(" ", "").toLowerCase();        String inversa = new StringBuilder(limpia).reverse().toString();        boolean palindromo = limpia.equals(inversa);         System.out.println(palindromo ? "Es palindromo" : "No es palindromo");    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        String frase = new Scanner(System.in).nextLine();        String limpia = frase.replace(" ", "").toLowerCase();        String inversa = new StringBuilder(limpia).reverse().toString();        System.out.println(limpia.equals(inversa) ? "Es palíndromo" : "No es palíndromo");    }}

import java.util.Scanner; public class Main {    static String vigenere(String texto, String clave, boolean cifrar) {        StringBuilder sb = new StringBuilder();        int k = 0;   // letra de la clave que toca        for (char c : texto.toCharArray()) {            boolean mayus = c >= 'A' && c <= 'Z', minus = c >= 'a' && c <= 'z';            if (!mayus && !minus) {                sb.append(c);   // no es una letra: se copia y no gasta clave                continue;            }            int desp = Character.toUpperCase(clave.charAt(k % clave.length())) - 'A';            if (!cifrar) desp = 26 - desp;            char base = mayus ? 'A' : 'a';            sb.append((char) (base + (c - base + desp) % 26));            k++;        }        return sb.toString();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String modo = sc.nextLine().trim(), clave = sc.nextLine().trim(), texto = sc.nextLine();        System.out.println(vigenere(texto, clave, modo.equals("cifrar")));    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int ancho = Integer.parseInt(sc.nextLine().trim());        StringBuilder todo = new StringBuilder();        while (sc.hasNextLine()) todo.append(sc.nextLine()).append(' ');        String[] palabras = todo.toString().trim().split("\\s+");         for (String p : palabras) {            if (p.length() > ancho) {                System.out.println("Error: la palabra «" + p + "» no cabe en " + ancho + " caracteres");                return;            }        }         // 1. Repartir: en cada línea, todas las palabras que quepan con un espacio entre ellas        List<List<String>> lineas = new ArrayList<>();        List<String> actual = new ArrayList<>();        int largo = 0;        for (String p : palabras) {            if (!actual.isEmpty() && largo + 1 + p.length() > ancho) {                lineas.add(actual);                actual = new ArrayList<>();                largo = 0;            }            largo += (actual.isEmpty() ? 0 : 1) + p.length();            actual.add(p);        }        lineas.add(actual);         // 2. Justificar        for (int i = 0; i < lineas.size(); i++) {            List<String> l = lineas.get(i);            String texto;            if (i == lineas.size() - 1 || l.size() == 1) {                texto = String.join(" ", l);            } else {                int letras = 0;                for (String p : l) letras += p.length();                int huecos = l.size() - 1, espacios = ancho - letras;                StringBuilder sb = new StringBuilder(l.get(0));                for (int h = 0; h < huecos; h++) {                    int n = espacios / huecos + (h < espacios % huecos ? 1 : 0);   // los primeros, uno más                    sb.append(" ".repeat(n)).append(l.get(h + 1));                }                texto = sb.toString();            }            System.out.println("|" + texto + " ".repeat(ancho - texto.length()) + "|");        }        System.out.println(lineas.size() + (lineas.size() == 1 ? " línea" : " líneas") + " de " + ancho + " caracteres");    }}

public class Main {    static class Alumno {        private String nombre;        private double nota;         Alumno(String nombre, double nota) {            this.nombre = nombre;            this.nota = nota;        }         @Override        public String toString() {            return nombre + ": " + nota;        }    }     public static void main(String[] args) {        System.out.println(new Alumno("Lucía", 8.5));        System.out.println(new Alumno("Mario", 6.0));    }}

import java.util.Scanner; class Fraccion {    private final long num;    private final long den;     Fraccion(long num, long den) {        if (den == 0) throw new IllegalArgumentException("denominador 0");        if (den < 0) {          // el signo, en el numerador            num = -num;            den = -den;        }        long m = mcd(num, den);        this.num = num / m;        this.den = den / m;    }     private static long mcd(long a, long b) {        return b == 0 ? Math.abs(a) : mcd(b, a % b);    }     Fraccion sumar(Fraccion o) {        return new Fraccion(num * o.den + o.num * den, den * o.den);    }     Fraccion restar(Fraccion o) {        return new Fraccion(num * o.den - o.num * den, den * o.den);    }     Fraccion multiplicar(Fraccion o) {        return new Fraccion(num * o.num, den * o.den);    }     Fraccion dividir(Fraccion o) {        if (o.num == 0) throw new ArithmeticException("división entre cero");        return new Fraccion(num * o.den, den * o.num);    }     @Override    public String toString() {        return den == 1 ? String.valueOf(num) : num + "/" + den;    }} public class Main {    static Fraccion leer(String s) {        String[] p = s.split("/");        return new Fraccion(Long.parseLong(p[0]), p.length > 1 ? Long.parseLong(p[1]) : 1);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = Integer.parseInt(sc.nextLine().trim());        for (int i = 0; i < n; i++) {            String linea = sc.nextLine().trim();            String[] t = linea.split(" ");            try {                Fraccion a = leer(t[0]), b = leer(t[2]);                Fraccion r = switch (t[1]) {                    case "+" -> a.sumar(b);                    case "-" -> a.restar(b);                    case "*" -> a.multiplicar(b);                    default -> a.dividir(b);                };                System.out.println(linea + " = " + r);            } catch (ArithmeticException | IllegalArgumentException e) {                System.out.println(linea + " → Error: " + e.getMessage());            }        }    }}

import java.util.*; class Producto {    final String codigo, nombre;    final int precio;            // en céntimos    int stock;     Producto(String codigo, String nombre, int precio, int stock) {        this.codigo = codigo;        this.nombre = nombre;        this.precio = precio;        this.stock = stock;    }} class Maquina {    static final int[] VALORES = {200, 100, 50, 20, 10, 5};    private final Map<String, Producto> productos = new LinkedHashMap<>();    private final Map<Integer, Integer> monedas = new TreeMap<>(Comparator.reverseOrder());    private final List<Integer> insertadas = new ArrayList<>();     Maquina() {        for (int v : VALORES) monedas.put(v, 0);    }     static String euros(int centimos) {        return centimos / 100 + "," + String.format("%02d", centimos % 100) + " €";    }     void cargarMonedas(int valor, int cantidad) {        monedas.merge(valor, cantidad, Integer::sum);    }     void añadirProducto(Producto p) {        productos.put(p.codigo, p);    }     private int credito() {        int total = 0;        for (int m : insertadas) total += m;        return total;    }     // «1×2,00 €, 1×0,50 €» a partir de un mapa valor → cantidad    private static String lista(Map<Integer, Integer> cantidades) {        List<String> partes = new ArrayList<>();        for (int v : VALORES) {            int n = cantidades.getOrDefault(v, 0);            if (n > 0) partes.add(n + "×" + euros(v));        }        return partes.isEmpty() ? "nada" : String.join(", ", partes);    }     String insertar(int valor) {        if (Arrays.stream(VALORES).noneMatch(v -> v == valor)) return "Moneda no válida: " + valor;        insertadas.add(valor);        return "Crédito: " + euros(credito());    }     String comprar(String codigo) {        Producto p = productos.get(codigo);        if (p == null) return "No existe el producto " + codigo;        if (p.stock == 0) return p.nombre + " agotado";        int credito = credito();        if (credito < p.precio) return "Saldo insuficiente: faltan " + euros(p.precio - credito);         // Monedas disponibles: la caja más las que se acaban de insertar        Map<Integer, Integer> disponibles = new TreeMap<>(monedas);        for (int m : insertadas) disponibles.merge(m, 1, Integer::sum);        Map<Integer, Integer> cambio = new TreeMap<>();        int resto = credito - p.precio;        for (int v : VALORES) {            int n = Math.min(resto / v, disponibles.get(v));            if (n > 0) {                cambio.put(v, n);                disponibles.put(v, disponibles.get(v) - n);                resto -= n * v;            }        }        if (resto != 0) return "No hay cambio: inserte el importe exacto";         // Se vende: la caja pasa a ser lo disponible menos el cambio entregado        monedas.putAll(disponibles);        insertadas.clear();        p.stock--;        return "Sale " + p.nombre + ". Cambio: " + lista(cambio);    }     String devolver() {        Map<Integer, Integer> cantidades = new TreeMap<>();        for (int m : insertadas) cantidades.merge(m, 1, Integer::sum);        insertadas.clear();        return "Devuelto: " + lista(cantidades);    }     String estado() {        StringBuilder sb = new StringBuilder();        for (Producto p : productos.values()) {            sb.append(p.codigo).append(' ').append(p.nombre).append(' ').append(euros(p.precio))              .append(" (").append(p.stock).append(")\n");        }        int caja = 0;        for (Map.Entry<Integer, Integer> e : monedas.entrySet()) caja += e.getKey() * e.getValue();        return sb.append("Caja: ").append(euros(caja)).append('\n').toString();    }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Maquina m = new Maquina();        while (sc.hasNextLine()) {            String[] t = sc.nextLine().trim().split(" ");            switch (t[0]) {                case "MONEDAS" -> m.cargarMonedas(Integer.parseInt(t[1]), Integer.parseInt(t[2]));                case "PRODUCTO" -> m.añadirProducto(new Producto(t[1], t[2], Integer.parseInt(t[3]), Integer.parseInt(t[4])));                case "INSERTAR" -> System.out.println(m.insertar(Integer.parseInt(t[1])));                case "COMPRAR" -> System.out.println(m.comprar(t[1]));                case "DEVOLVER" -> System.out.println(m.devolver());                case "ESTADO" -> System.out.print(m.estado());                default -> { }            }        }    }}

import java.util.*; abstract class Cuenta {    private final String iban;    protected double saldo;     Cuenta(String iban, double saldoInicial) {        this.iban = iban;        this.saldo = saldoInicial;    }     String getIban() { return iban; }    double getSaldo() { return saldo; }     void ingresar(double importe) {        if (importe <= 0) throw new IllegalArgumentException("importe no válido");        saldo += importe;    }     // Cada tipo de cuenta decide si se puede retirar    abstract void retirar(double importe);     // Se llama al final de cada mes    abstract void cierreMes();     abstract String tipo();     @Override    public String toString() {        return String.format(Locale.US, "%s %s: %.2f", tipo(), iban, saldo);    }} class CuentaCorriente extends Cuenta {    static final double DESCUBIERTO = -300;     CuentaCorriente(String iban, double saldo) { super(iban, saldo); }     void retirar(double importe) {        if (importe <= 0) throw new IllegalArgumentException("importe no válido");        if (saldo - importe < DESCUBIERTO) throw new IllegalStateException("supera el descubierto");        saldo -= importe;    }     void cierreMes() {        if (saldo < 0) saldo -= 2;    }     String tipo() { return "Corriente"; }} class CuentaAhorro extends Cuenta {    private int retiradas = 0;     CuentaAhorro(String iban, double saldo) { super(iban, saldo); }     void retirar(double importe) {        if (importe <= 0) throw new IllegalArgumentException("importe no válido");        if (retiradas == 3) throw new IllegalStateException("máximo de retiradas del mes");        if (importe > saldo) throw new IllegalStateException("saldo insuficiente");        saldo -= importe;        retiradas++;    }     void cierreMes() {        saldo *= 1.005;        retiradas = 0;    }     String tipo() { return "Ahorro"; }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Cuenta> cuentas = new LinkedHashMap<>();        while (sc.hasNextLine()) {            String[] t = sc.nextLine().trim().split(" ");            try {                switch (t[0]) {                    case "CORRIENTE" -> cuentas.put(t[1], new CuentaCorriente(t[1], Double.parseDouble(t[2])));                    case "AHORRO" -> cuentas.put(t[1], new CuentaAhorro(t[1], Double.parseDouble(t[2])));                    case "INGRESAR" -> cuentas.get(t[1]).ingresar(Double.parseDouble(t[2]));                    case "RETIRAR" -> cuentas.get(t[1]).retirar(Double.parseDouble(t[2]));                    case "MES" -> {                        for (Cuenta c : cuentas.values()) c.cierreMes();                        System.out.println("-- cierre de mes --");                    }                    case "VER" -> cuentas.values().forEach(System.out::println);                }            } catch (IllegalArgumentException | IllegalStateException e) {                System.out.println(String.join(" ", t) + " → " + e.getMessage());            }        }    }}

import java.util.*; public class Main {    static class Producto {        final String codigo;        final String nombre;        Producto(String codigo, String nombre) { this.codigo = codigo; this.nombre = nombre; }         @Override        public boolean equals(Object o) {            if (this == o) return true;            if (!(o instanceof Producto otro)) return false;            return codigo.equals(otro.codigo);        }         @Override        public int hashCode() {            return codigo.hashCode();        }    }     public static void main(String[] args) {        List<Producto> lista = new ArrayList<>(List.of(new Producto("A1", "Teclado"), new Producto("B2", "Ratón")));        System.out.println("¿Está B2? " + lista.contains(new Producto("B2", "Ratón inalámbrico")));        System.out.println("¿Está C3? " + lista.contains(new Producto("C3", "Monitor")));    }}

import java.util.*; abstract class Expr {    abstract double evaluar(Map<String, Double> vars);    abstract Expr derivar(String v);    Expr simplificar() { return this; }     static String num(double d) {        return d == Math.floor(d) && !Double.isInfinite(d) ? String.valueOf((long) d) : String.valueOf(d);    }     // ¿Es el número n?    static boolean es(Expr e, double n) {        return e instanceof Num x && x.valor == n;    }} class Num extends Expr {    final double valor;    Num(double valor) { this.valor = valor; }    double evaluar(Map<String, Double> vars) { return valor; }    Expr derivar(String v) { return new Num(0); }    public String toString() { return num(valor); }} class Var extends Expr {    final String nombre;    Var(String nombre) { this.nombre = nombre; }    double evaluar(Map<String, Double> vars) { return vars.get(nombre); }    Expr derivar(String v) { return new Num(nombre.equals(v) ? 1 : 0); }    public String toString() { return nombre; }} // Clase base de las operaciones con dos operandosabstract class Binaria extends Expr {    final Expr izq, der;    Binaria(Expr izq, Expr der) { this.izq = izq; this.der = der; }    abstract String simbolo();    public String toString() { return "(" + izq + " " + simbolo() + " " + der + ")"; }} class Suma extends Binaria {    Suma(Expr a, Expr b) { super(a, b); }    String simbolo() { return "+"; }    double evaluar(Map<String, Double> vars) { return izq.evaluar(vars) + der.evaluar(vars); }    Expr derivar(String v) { return new Suma(izq.derivar(v), der.derivar(v)); }     Expr simplificar() {        Expr a = izq.simplificar(), b = der.simplificar();        if (a instanceof Num x && b instanceof Num y) return new Num(x.valor + y.valor);        if (es(a, 0)) return b;        if (es(b, 0)) return a;        return new Suma(a, b);    }} class Resta extends Binaria {    Resta(Expr a, Expr b) { super(a, b); }    String simbolo() { return "-"; }    double evaluar(Map<String, Double> vars) { return izq.evaluar(vars) - der.evaluar(vars); }    Expr derivar(String v) { return new Resta(izq.derivar(v), der.derivar(v)); }     Expr simplificar() {        Expr a = izq.simplificar(), b = der.simplificar();        if (a instanceof Num x && b instanceof Num y) return new Num(x.valor - y.valor);        if (es(b, 0)) return a;        if (a.toString().equals(b.toString())) return new Num(0);        return new Resta(a, b);    }} class Producto extends Binaria {    Producto(Expr a, Expr b) { super(a, b); }    String simbolo() { return "*"; }    double evaluar(Map<String, Double> vars) { return izq.evaluar(vars) * der.evaluar(vars); }     // (a·b)' = a'·b + a·b'    Expr derivar(String v) {        return new Suma(new Producto(izq.derivar(v), der), new Producto(izq, der.derivar(v)));    }     Expr simplificar() {        Expr a = izq.simplificar(), b = der.simplificar();        if (a instanceof Num x && b instanceof Num y) return new Num(x.valor * y.valor);        if (es(a, 0) || es(b, 0)) return new Num(0);        if (es(a, 1)) return b;        if (es(b, 1)) return a;        return new Producto(a, b);    }} public class Main {    // Lee una expresión en notación prefija: "+ * 2 x 3" es (2 * x) + 3    static Expr leer(Iterator<String> it) {        String t = it.next();        return switch (t) {            case "+" -> new Suma(leer(it), leer(it));            case "-" -> new Resta(leer(it), leer(it));            case "*" -> new Producto(leer(it), leer(it));            default -> Character.isLetter(t.charAt(0)) ? new Var(t) : new Num(Double.parseDouble(t));        };    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Expr e = leer(Arrays.asList(sc.nextLine().trim().split(" ")).iterator());        Map<String, Double> vars = new TreeMap<>();        while (sc.hasNext()) vars.put(sc.next(), Double.parseDouble(sc.next()));        System.out.println("Expresión: " + e);        System.out.println("Simplificada: " + e.simplificar());        System.out.println("Valor: " + Expr.num(e.evaluar(vars)));        Expr d = e.derivar("x");        System.out.println("Derivada respecto de x: " + d);        System.out.println("Derivada simplificada: " + d.simplificar());    }}

import java.util.*; class Equipo {    final String nombre;    int jugados, ganados, empatados, perdidos, golesFavor, golesContra;     Equipo(String nombre) { this.nombre = nombre; }     int puntos() { return ganados * 3 + empatados; }    int diferencia() { return golesFavor - golesContra; }     void registrar(int favor, int contra) {        jugados++;        golesFavor += favor;        golesContra += contra;        if (favor > contra) ganados++;        else if (favor == contra) empatados++;        else perdidos++;    }} public class Main {    static final Comparator<Equipo> CLASIFICACION = Comparator            .comparingInt(Equipo::puntos).reversed()            .thenComparing(Comparator.comparingInt(Equipo::diferencia).reversed())            .thenComparing(Comparator.comparingInt((Equipo e) -> e.golesFavor).reversed())            .thenComparing(e -> e.nombre);     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Equipo> equipos = new HashMap<>();        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            // Formato: Local 2-1 Visitante            String[] t = linea.split(" ");            String[] goles = t[1].split("-");            int gl = Integer.parseInt(goles[0]), gv = Integer.parseInt(goles[1]);            equipos.computeIfAbsent(t[0], Equipo::new).registrar(gl, gv);            equipos.computeIfAbsent(t[2], Equipo::new).registrar(gv, gl);        }        List<Equipo> tabla = new ArrayList<>(equipos.values());        tabla.sort(CLASIFICACION);        System.out.println("Pos Equipo      PJ  G  E  P  GF  GC  DG Pts");        int pos = 1;        for (Equipo e : tabla)            System.out.printf("%3d %-10s %3d %2d %2d %2d %3d %3d %+3d %3d%n", pos++, e.nombre, e.jugados,                    e.ganados, e.empatados, e.perdidos, e.golesFavor, e.golesContra, e.diferencia(), e.puntos());    }}

import java.util.*;import java.util.regex.Pattern; @FunctionalInterfaceinterface Regla {    // Lista de errores; vacía si el texto cumple la regla    List<String> comprobar(String s);     default Regla y(Regla otra) {        return s -> {            List<String> errores = new ArrayList<>(comprobar(s));            errores.addAll(otra.comprobar(s));            return errores;        };    }     default Regla o(Regla otra) {        return s -> {            List<String> e1 = comprobar(s);            if (e1.isEmpty()) return e1;            List<String> e2 = otra.comprobar(s);            if (e2.isEmpty()) return e2;            return List.of(String.join("; ", e1) + " o " + String.join("; ", e2));        };    }     static Regla minimo(int n) {        return s -> s.length() >= n ? List.of() : List.of("mínimo " + n + " caracteres");    }     static Regla contiene(String clase, String nombre) {        Pattern patron = Pattern.compile("[" + clase + "]");        return s -> patron.matcher(s).find() ? List.of() : List.of("falta " + nombre);    }     static Regla noContiene(String palabra) {        return s -> s.toLowerCase().contains(palabra.toLowerCase())                ? List.of("no puede contener «" + palabra + "»")                : List.of();    }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String politica = sc.nextLine().trim();        Regla regla = switch (politica) {            case "BASICA" -> Regla.minimo(6).y(Regla.contiene("0-9", "un número"));            default -> Regla.minimo(10)                    .y(Regla.contiene("0-9", "un número"))                    .y(Regla.contiene("A-Z", "una mayúscula").o(Regla.contiene("^a-zA-Z0-9", "un símbolo")))                    .y(Regla.noContiene("password"))                    .y(Regla.noContiene("1234"));        };        while (sc.hasNextLine()) {            String clave = sc.nextLine();            List<String> errores = regla.comprobar(clave);            System.out.println(errores.isEmpty() ? "✓ " + clave : "✗ " + clave + ": " + String.join("; ", errores));        }    }}

import java.io.*;import java.util.*; public class Main {    public static void main(String[] args) throws IOException {        // La entrada estándar hace de fichero: se lee igual que con un FileReader        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));        Map<String, Double> ventas = new HashMap<>();        int correctas = 0, erroneas = 0;        String cabecera = br.readLine();        String linea;        int numLinea = 1;        while ((linea = br.readLine()) != null) {            numLinea++;            if (linea.isBlank()) continue;            String error = null;            String[] c = linea.split(";", -1);            String producto = "";            int unidades = 0;            double precio = 0;            if (c.length != 4) {                error = "se esperaban 4 campos y hay " + c.length;            } else if ((producto = c[1].trim()).isEmpty()) {                error = "producto vacío";            } else {                try {                    unidades = Integer.parseInt(c[2].trim());                } catch (NumberFormatException e) {                    error = "unidades no válidas («" + c[2].trim() + "»)";                }                if (error == null) {                    try {                        precio = Double.parseDouble(c[3].trim().replace(',', '.'));                    } catch (NumberFormatException e) {                        error = "precio no válido («" + c[3].trim() + "»)";                    }                }                if (error == null && (unidades <= 0 || precio < 0)) error = "valores negativos o cero";            }            if (error != null) {                System.out.println("Línea " + numLinea + ": " + error);                erroneas++;            } else {                ventas.merge(producto, unidades * precio, Double::sum);                correctas++;            }        }         System.out.println("--- " + correctas + " líneas correctas, " + erroneas + " con errores ---");        List<Map.Entry<String, Double>> orden = new ArrayList<>(ventas.entrySet());        orden.sort(Map.Entry.<String, Double>comparingByValue().reversed().thenComparing(Map.Entry.comparingByKey()));        double total = 0;        for (Map.Entry<String, Double> e : orden) {            System.out.printf(Locale.US, "%-10s %9.2f%n", e.getKey(), e.getValue());            total += e.getValue();        }        System.out.printf(Locale.US, "%-10s %9.2f%n", "TOTAL", total);    }}

import java.io.*;import java.util.*; public class Main {    // Devuelve las líneas del diff: " línea" (igual), "-línea" (solo en a), "+línea" (solo en b)    static List<String> diff(List<String> a, List<String> b) {        int n = a.size(), m = b.size();        // lcs[i][j] = longitud de la LCS de a desde i y b desde j        int[][] lcs = new int[n + 1][m + 1];        for (int i = n - 1; i >= 0; i--) {            for (int j = m - 1; j >= 0; j--) {                lcs[i][j] = a.get(i).equals(b.get(j))                        ? lcs[i + 1][j + 1] + 1                        : Math.max(lcs[i + 1][j], lcs[i][j + 1]);            }        }        List<String> res = new ArrayList<>();        int i = 0, j = 0;        while (i < n && j < m) {            if (a.get(i).equals(b.get(j))) {                res.add(" " + a.get(i++));                j++;            } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {                res.add("-" + a.get(i++));            } else {                res.add("+" + b.get(j++));            }        }        while (i < n) res.add("-" + a.get(i++));        while (j < m) res.add("+" + b.get(j++));        return res;    }     public static void main(String[] args) throws IOException {        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));        List<String> a = new ArrayList<>(), b = new ArrayList<>();        List<String> actual = a;        String linea;        while ((linea = br.readLine()) != null) {            if (linea.equals("=====")) { actual = b; continue; }            actual.add(linea);        }        List<String> d = diff(a, b);        int quitadas = 0, añadidas = 0;        for (String l : d) {            System.out.println(l);            if (l.startsWith("-")) quitadas++;            if (l.startsWith("+")) añadidas++;        }        System.out.println("@@ " + quitadas + (quitadas == 1 ? " línea quitada, " : " líneas quitadas, ")                + añadidas + (añadidas == 1 ? " añadida @@" : " añadidas @@"));    }}

import java.util.*; public class Main {    public static void main(String[] args) {        List<String> tareas = new ArrayList<>(List.of("x comprar pan", "estudiar Java", "x llamar a Ana", "x pagar luz", "hacer la práctica"));        tareas.removeIf(t -> t.startsWith("x "));        System.out.println("Pendientes: " + tareas);    }}

import java.util.*; public class Main {    public static void main(String[] args) {        String frase = new Scanner(System.in).nextLine().toLowerCase();        Map<String, Integer> contador = new TreeMap<>();        for (String p : frase.split(" ")) {            contador.merge(p, 1, Integer::sum);        }        contador.forEach((p, n) -> System.out.println(p + " " + n));    }}

import java.util.*; public class Main {    // Devuelve los grupos de anagramas (2 o más palabras), cada uno ordenado alfabéticamente    // y los grupos de más a menos palabras (a igualdad, por su primera palabra)    static List<List<String>> agrupar(List<String> palabras) {        Map<String, TreeSet<String>> grupos = new HashMap<>();        for (String p : palabras) {            String palabra = p.toLowerCase();            char[] letras = palabra.toCharArray();            Arrays.sort(letras);            // Los anagramas tienen las mismas letras ordenadas: esa es la clave del grupo            grupos.computeIfAbsent(new String(letras), k -> new TreeSet<>()).add(palabra);        }        List<List<String>> res = new ArrayList<>();        for (TreeSet<String> g : grupos.values()) {            if (g.size() >= 2) res.add(new ArrayList<>(g));        }        res.sort(Comparator.comparingInt((List<String> g) -> -g.size()).thenComparing(g -> g.get(0)));        return res;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> palabras = new ArrayList<>();        while (sc.hasNext()) palabras.add(sc.next());        List<List<String>> grupos = agrupar(palabras);        if (grupos.isEmpty()) System.out.println("No hay anagramas");        for (List<String> g : grupos) System.out.println(g.size() + ": " + String.join(", ", g));    }}

import java.util.*; public class Main {    // Estación → estaciones vecinas (en orden alfabético)    static Map<String, Set<String>> red = new TreeMap<>();     static void conectar(String a, String b) {        red.computeIfAbsent(a, k -> new TreeSet<>()).add(b);        red.computeIfAbsent(b, k -> new TreeSet<>()).add(a);    }     // Camino con menos paradas de origen a destino (incluidos los dos), o null si no hay    static List<String> ruta(String origen, String destino) {        Map<String, String> desde = new HashMap<>();   // estación → desde cuál se descubrió        Deque<String> cola = new ArrayDeque<>();        desde.put(origen, null);        cola.add(origen);        while (!cola.isEmpty()) {            String actual = cola.poll();            if (actual.equals(destino)) {                LinkedList<String> camino = new LinkedList<>();                for (String e = destino; e != null; e = desde.get(e)) camino.addFirst(e);                return camino;            }            for (String vecina : red.get(actual)) {                if (!desde.containsKey(vecina)) {   // aún no descubierta                    desde.put(vecina, actual);                    cola.add(vecina);                }            }        }        return null;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            String[] t = linea.split(" ");            if (t[0].equals("LINEA")) {                for (int i = 2; i < t.length - 1; i++) conectar(t[i], t[i + 1]);            } else if (t[0].equals("RUTA")) {                if (!red.containsKey(t[1]) || !red.containsKey(t[2])) {                    System.out.println("Estación desconocida");                    continue;                }                List<String> r = ruta(t[1], t[2]);                if (r == null) System.out.println(t[1] + " → " + t[2] + ": sin conexión");                else System.out.println(String.join(" → ", r) + " (" + (r.size() - 1) + " paradas)");            }        }    }}

import java.util.*; public class Main {    static class Libro {        final String isbn;        final String titulo;        int disponibles;         Libro(String isbn, String titulo, int ejemplares) {            this.isbn = isbn;            this.titulo = titulo;            this.disponibles = ejemplares;        }    }     static class Prestamo {        final Libro libro;        final int vence;         Prestamo(Libro libro, int vence) {            this.libro = libro;            this.vence = vence;        }    }     static class Socio {        final int numero;        final String nombre;        final List<Prestamo> prestamos = new ArrayList<>();        int bloqueadoHasta = 0;        double multas = 0;         Socio(int numero, String nombre) {            this.numero = numero;            this.nombre = nombre;        }    }     static final int DIAS_PRESTAMO = 14;    static final int MAX_PRESTAMOS = 3;    static final double MULTA_DIA = 0.50;    static final Locale ES = Locale.forLanguageTag("es-ES");     static final Map<String, Libro> libros = new HashMap<>();    // TreeMap: los socios quedan ordenados por número, como pide el informe    static final Map<Integer, Socio> socios = new TreeMap<>();     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (!linea.isEmpty()) procesar(linea);        }    }     static void procesar(String linea) {        String[] p = linea.split(" ");        switch (p[0]) {            case "LIBRO" -> altaLibro(p[1], Integer.parseInt(p[2]), resto(p, 3));            case "SOCIO" -> altaSocio(Integer.parseInt(p[1]), resto(p, 2));            case "PRESTAR" -> prestar(Integer.parseInt(p[1]), Integer.parseInt(p[2]), p[3]);            case "DEVOLVER" -> devolver(Integer.parseInt(p[1]), Integer.parseInt(p[2]), p[3]);            case "INFORME" -> informe();            default -> System.out.println("Error: orden desconocida " + p[0]);        }    }     /** Las palabras de la línea desde la posición indicada (títulos y nombres pueden tener espacios). */    static String resto(String[] p, int desde) {        return String.join(" ", Arrays.copyOfRange(p, desde, p.length));    }     static void altaLibro(String isbn, int ejemplares, String titulo) {        if (libros.containsKey(isbn)) {            System.out.println("Error: ya existe un libro con el ISBN " + isbn);            return;        }        libros.put(isbn, new Libro(isbn, titulo, ejemplares));        System.out.println("Libro añadido: " + titulo + " (" + ejemplares + (ejemplares == 1 ? " ejemplar)" : " ejemplares)"));    }     static void altaSocio(int numero, String nombre) {        if (socios.containsKey(numero)) {            System.out.println("Error: ya existe un socio con el número " + numero);            return;        }        socios.put(numero, new Socio(numero, nombre));        System.out.println("Socio añadido: " + nombre + " (" + numero + ")");    }     static void prestar(int dia, int numero, String isbn) {        Socio s = socios.get(numero);        Libro l = libros.get(isbn);        if (s == null) {            System.out.println("Error: no existe el socio " + numero);        } else if (l == null) {            System.out.println("Error: no existe el libro " + isbn);        } else if (dia < s.bloqueadoHasta) {            System.out.println("Error: " + s.nombre + " no puede llevarse libros hasta el día " + s.bloqueadoHasta);        } else if (s.prestamos.size() == MAX_PRESTAMOS) {            System.out.println("Error: " + s.nombre + " ya tiene " + MAX_PRESTAMOS + " libros prestados");        } else if (s.prestamos.stream().anyMatch(pr -> pr.libro == l)) {            System.out.println("Error: " + s.nombre + " ya tiene «" + l.titulo + "»");        } else if (l.disponibles == 0) {            System.out.println("Error: no quedan ejemplares de «" + l.titulo + "»");        } else {            l.disponibles--;            s.prestamos.add(new Prestamo(l, dia + DIAS_PRESTAMO));            System.out.println("Préstamo: " + s.nombre + " se lleva «" + l.titulo + "» hasta el día " + (dia + DIAS_PRESTAMO));        }    }     static void devolver(int dia, int numero, String isbn) {        Socio s = socios.get(numero);        Prestamo pr = null;        if (s != null) {            for (Prestamo x : s.prestamos) {                if (x.libro.isbn.equals(isbn)) pr = x;            }        }        if (pr == null) {            System.out.println("Error: el socio " + numero + " no tiene prestado el libro " + isbn);            return;        }        s.prestamos.remove(pr);        pr.libro.disponibles++;        int retraso = dia - pr.vence;        if (retraso <= 0) {            System.out.println("Devolución: «" + pr.libro.titulo + "» a tiempo");            return;        }        double multa = retraso * MULTA_DIA;        s.multas += multa;        // Un nuevo retraso puede alargar el bloqueo, nunca acortarlo        s.bloqueadoHasta = Math.max(s.bloqueadoHasta, dia + retraso);        System.out.println("Devolución: «" + pr.libro.titulo + "» con " + retraso + (retraso == 1 ? " día" : " días")                + " de retraso. Multa: " + euros(multa));    }     static void informe() {        System.out.println("== Informe ==");        int activos = 0;        for (Socio s : socios.values()) activos += s.prestamos.size();        System.out.println("Préstamos activos: " + activos);        double total = 0;        for (Socio s : socios.values()) {            total += s.multas;            if (s.prestamos.isEmpty()) continue;            List<String> titulos = new ArrayList<>();            for (Prestamo pr : s.prestamos) titulos.add("«" + pr.libro.titulo + "»");            System.out.println("- " + s.nombre + " (" + s.numero + "): " + String.join(", ", titulos));        }        System.out.println("Multas: " + euros(total));    }     static String euros(double importe) {        return String.format(ES, "%.2f €", importe);    }}

import java.util.*; public class Main {    static class Equipo {        final String nombre;        int pj, g, e, p, gf, gc;         Equipo(String nombre) {            this.nombre = nombre;        }         int dg() {            return gf - gc;        }         int puntos() {            return 3 * g + e;        }    }     static final Locale ES = Locale.forLanguageTag("es-ES");    // LinkedHashMap: busca por nombre al instante y recuerda el orden de aparición    static final Map<String, Equipo> equipos = new LinkedHashMap<>();     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int numLinea = 0, partidos = 0, goles = 0;        while (sc.hasNextLine()) {            String linea = sc.nextLine();            numLinea++;            if (linea.isBlank()) continue;            String[] partes = linea.split(";", -1);            if (!esValida(partes)) {                System.out.println("Aviso: la línea " + numLinea + " no es un resultado válido y se ignora");                continue;            }            String[] marcador = partes[1].trim().split("-");            int golesLocal = Integer.parseInt(marcador[0]);            int golesVisitante = Integer.parseInt(marcador[1]);            registrar(equipo(partes[0].trim()), golesLocal, golesVisitante);            registrar(equipo(partes[2].trim()), golesVisitante, golesLocal);            partidos++;            goles += golesLocal + golesVisitante;        }        if (partidos == 0) {            System.out.println("No hay resultados válidos.");            return;        }        List<Equipo> tabla = new ArrayList<>(equipos.values());        tabla.sort(Comparator.comparingInt(Equipo::puntos).reversed()                .thenComparing(Comparator.comparingInt(Equipo::dg).reversed())                .thenComparing(Comparator.comparingInt((Equipo x) -> x.gf).reversed())                .thenComparing((Equipo x) -> x.nombre));        imprimirTabla(tabla);        System.out.println();        System.out.println(String.format(ES, "Partidos: %d · Goles: %d · Media: %.2f goles por partido", partidos, goles, (double) goles / partidos));        // El primero de la tabla con menos goles en contra: así un empate lo gana el mejor clasificado        Equipo menos = tabla.get(0);        for (Equipo t : tabla) {            if (t.gc < menos.gc) menos = t;        }        System.out.println("Equipo menos goleado: " + menos.nombre + " (" + menos.gc + (menos.gc == 1 ? " gol" : " goles") + " en contra)");    }     static boolean esValida(String[] partes) {        return partes.length == 3                && !partes[0].isBlank() && !partes[2].isBlank()                && partes[1].trim().matches("[0-9]+-[0-9]+")                && !partes[0].trim().equals(partes[2].trim());    }     static Equipo equipo(String nombre) {        return equipos.computeIfAbsent(nombre, Equipo::new);    }     static void registrar(Equipo t, int aFavor, int enContra) {        t.pj++;        t.gf += aFavor;        t.gc += enContra;        if (aFavor > enContra) t.g++;        else if (aFavor == enContra) t.e++;        else t.p++;    }     static void imprimirTabla(List<Equipo> tabla) {        System.out.println(String.format("%-4s%-20s%3s%3s%3s%3s%4s%4s%5s%5s", "Pos", "Equipo", "PJ", "G", "E", "P", "GF", "GC", "DG", "Pts"));        for (int i = 0; i < tabla.size(); i++) {            Equipo t = tabla.get(i);            String dg = t.dg() > 0 ? "+" + t.dg() : String.valueOf(t.dg());            System.out.println(String.format("%-4d%-20s%3d%3d%3d%3d%4d%4d%5s%5d", i + 1, t.nombre, t.pj, t.g, t.e, t.p, t.gf, t.gc, dg, t.puntos()));        }    }}

import java.util.Locale;import java.util.Scanner; public class Main {    static final long LIMITE_DIARIO = 60000;      // 600 € en céntimos    static final int[] BILLETES = {50, 20, 10};     /** Céntimos → «1.234,50 €». */    static String euros(long centimos) {        String entero = String.format(Locale.ROOT, "%,d", centimos / 100).replace(',', '.');        return entero + "," + String.format("%02d", centimos % 100) + " €";    }     /** «49.95» → 4995 céntimos; -1 si no es una cantidad válida (hasta 2 decimales). */    static long centimos(String texto) {        if (!texto.matches("\\d{1,7}(\\.\\d{1,2})?")) return -1;        String[] partes = texto.split("\\.");        long resultado = Long.parseLong(partes[0]) * 100;        if (partes.length == 2) resultado += Long.parseLong((partes[1] + "0").substring(0, 2));        return resultado;    }     /** Desglose en billetes de 50, 20 y 10 con el menor número de billetes: «3x50 1x20 1x10». */    static String desglose(long euros) {        StringBuilder sb = new StringBuilder();        for (int billete : BILLETES) {            long n = euros / billete;            euros %= billete;            if (n > 0) sb.append(sb.length() > 0 ? " " : "").append(n).append("x").append(billete);        }        return sb.toString();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String[] inicio = sc.nextLine().trim().split("\\s+");        long saldo = centimos(inicio[0]);        String pin = inicio[1];         boolean identificado = false;        int fallos = 0, operaciones = 0;        long retiradoHoy = 0;         while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            String[] partes = linea.split("\\s+");            String orden = partes[0].toUpperCase();            String argumento = partes.length > 1 ? partes[1] : "";             // Sin el PIN correcto solo se acepta la orden PIN            if (!identificado) {                if (!orden.equals("PIN")) {                    System.out.println("Introduzca el PIN");                } else if (argumento.equals(pin)) {                    identificado = true;                    System.out.println("PIN correcto");                } else if (++fallos == 3) {                    System.out.println("PIN incorrecto. Tarjeta retenida");                    return;                } else {                    int quedan = 3 - fallos;                    System.out.println("PIN incorrecto. " + (quedan == 1 ? "Queda 1 intento" : "Quedan " + quedan + " intentos"));                }                continue;            }             switch (orden) {                case "PIN" -> System.out.println("Ya ha introducido el PIN");                case "SALDO" -> System.out.println("Saldo: " + euros(saldo));                case "INGRESAR" -> {                    long cantidad = centimos(argumento);                    if (cantidad <= 0) {                        System.out.println("Cantidad no válida");                    } else {                        saldo += cantidad;                        operaciones++;                        System.out.println("Ingresados " + euros(cantidad) + ". Saldo: " + euros(saldo));                    }                }                case "RETIRAR" -> {                    long cantidad = centimos(argumento);                    if (cantidad <= 0 || cantidad % 1000 != 0) {                        System.out.println("Importe no válido: debe ser múltiplo de 10 €");                    } else if (cantidad > saldo) {                        System.out.println("Saldo insuficiente");                    } else if (retiradoHoy + cantidad > LIMITE_DIARIO) {                        System.out.println("Supera el límite diario: hoy puede retirar hasta " + euros(LIMITE_DIARIO - retiradoHoy));                    } else {                        saldo -= cantidad;                        retiradoHoy += cantidad;                        operaciones++;                        System.out.println("Retirados " + euros(cantidad) + ": " + desglose(cantidad / 100) + ". Saldo: " + euros(saldo));                    }                }                case "SALIR" -> {                    System.out.println("Operaciones: " + operaciones + " · Retirado hoy: " + euros(retiradoHoy));                    System.out.println("Retire su tarjeta");                    return;                }                default -> System.out.println("Operación desconocida");            }        }        // Se acabó la entrada sin SALIR: el cajero cierra la sesión igualmente        if (identificado) {            System.out.println("Operaciones: " + operaciones + " · Retirado hoy: " + euros(retiradoHoy));            System.out.println("Retire su tarjeta");        }    }}

import java.util.ArrayDeque;import java.util.Deque;import java.util.Locale;import java.util.Scanner; public class Main {    static int filas, columnas;    static char[][] tablero;    static int[][] cuenta;     /** Minas en las 8 casillas vecinas de (f, c). */    static int minasAlrededor(int f, int c) {        int n = 0;        for (int df = -1; df <= 1; df++) {            for (int dc = -1; dc <= 1; dc++) {                int ff = f + df, cc = c + dc;                if ((df != 0 || dc != 0) && ff >= 0 && ff < filas && cc >= 0 && cc < columnas && tablero[ff][cc] == '*') n++;            }        }        return n;    }     /** Marca como visitada toda la zona de ceros conectada (también en diagonal) con (f, c). */    static void despejar(int f, int c, boolean[][] visto) {        Deque<int[]> pendientes = new ArrayDeque<>();        pendientes.push(new int[]{f, c});        visto[f][c] = true;        while (!pendientes.isEmpty()) {            int[] actual = pendientes.pop();            for (int df = -1; df <= 1; df++) {                for (int dc = -1; dc <= 1; dc++) {                    int ff = actual[0] + df, cc = actual[1] + dc;                    if (ff >= 0 && ff < filas && cc >= 0 && cc < columnas && !visto[ff][cc] && cuenta[ff][cc] == 0) {                        visto[ff][cc] = true;                        pendientes.push(new int[]{ff, cc});                    }                }            }        }    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String cabecera = sc.hasNextLine() ? sc.nextLine().trim() : "";        if (!cabecera.matches("\\d{1,2} \\d{1,2}")) {            System.out.println("Tablero no válido: línea 1");            return;        }        filas = Integer.parseInt(cabecera.split(" ")[0]);        columnas = Integer.parseInt(cabecera.split(" ")[1]);        if (filas < 1 || filas > 30 || columnas < 1 || columnas > 30) {            System.out.println("Tablero no válido: línea 1");            return;        }        tablero = new char[filas][];        for (int f = 0; f < filas; f++) {            if (!sc.hasNextLine()) {                System.out.println("Tablero no válido: faltan filas");                return;            }            String linea = sc.nextLine().trim();            if (linea.length() != columnas || !linea.matches("[*.]+")) {                System.out.println("Tablero no válido: línea " + (f + 2));                return;            }            tablero[f] = linea.toCharArray();        }         // Números de cada casilla (-1 en las minas)        cuenta = new int[filas][columnas];        int minas = 0;        System.out.println("Tablero:");        for (int f = 0; f < filas; f++) {            StringBuilder sb = new StringBuilder();            for (int c = 0; c < columnas; c++) {                if (tablero[f][c] == '*') {                    cuenta[f][c] = -1;                    minas++;                    sb.append('*');                } else {                    cuenta[f][c] = minasAlrededor(f, c);                    sb.append(cuenta[f][c]);                }            }            System.out.println(sb);        }         int total = filas * columnas;        String porcentaje = String.format(Locale.ROOT, "%.1f", minas * 100.0 / total).replace('.', ',');        System.out.println("Minas: " + minas + " de " + total + " casillas (" + porcentaje + " %)");         // La primera casilla (por filas) con más minas alrededor        int mejorF = -1, mejorC = -1, max = 0;        for (int f = 0; f < filas; f++) {            for (int c = 0; c < columnas; c++) {                if (cuenta[f][c] > max) {                    max = cuenta[f][c];                    mejorF = f;                    mejorC = c;                }            }        }        if (max == 0) {            System.out.println("Casilla más peligrosa: ninguna");        } else {            System.out.println("Casilla más peligrosa: fila " + (mejorF + 1) + ", columna " + (mejorC + 1) + " (" + max + (max == 1 ? " mina" : " minas") + " alrededor)");        }         // Cada recorrido que empieza en un cero sin visitar es una zona nueva        boolean[][] visto = new boolean[filas][columnas];        int zonas = 0;        for (int f = 0; f < filas; f++) {            for (int c = 0; c < columnas; c++) {                if (cuenta[f][c] == 0 && !visto[f][c]) {                    zonas++;                    despejar(f, c, visto);                }            }        }        System.out.println("Zonas despejadas: " + zonas);    }}

import java.util.Scanner; public class Main {    static final String ALFABETO = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";    static final int N = ALFABETO.length();   // 27 letras     /** La clave en mayúsculas, o null si tiene algo que no sea una letra del alfabeto. */    static String validarClave(String texto) {        String clave = texto.toUpperCase();        if (clave.isEmpty()) return null;        for (char c : clave.toCharArray()) {            if (ALFABETO.indexOf(c) < 0) return null;        }        return clave;    }     /** Cifra (sentido = 1) o descifra (sentido = -1). Solo cambian las letras del alfabeto, que conservan su caja. */    static String vigenere(String texto, String clave, int sentido) {        StringBuilder sb = new StringBuilder();        int k = 0;   // posición en la clave: solo avanza con las letras        for (char c : texto.toCharArray()) {            int pos = ALFABETO.indexOf(Character.toUpperCase(c));            if (pos < 0) {                sb.append(c);                continue;            }            int desplazamiento = ALFABETO.indexOf(clave.charAt(k % clave.length()));            char nueva = ALFABETO.charAt(((pos + sentido * desplazamiento) % N + N) % N);            sb.append(Character.isLowerCase(c) ? Character.toLowerCase(nueva) : nueva);            k++;        }        return sb.toString();    }     /** «Letras: 23 · Más frecuentes: O 5, Ñ 3, E 2». */    static String analizar(String texto) {        int[] veces = new int[N];        int letras = 0;        for (char c : texto.toCharArray()) {            int pos = ALFABETO.indexOf(Character.toUpperCase(c));            if (pos >= 0) {                veces[pos]++;                letras++;            }        }        if (letras == 0) return "Letras: 0";        StringBuilder sb = new StringBuilder("Letras: " + letras + " · Más frecuentes: ");        boolean[] usada = new boolean[N];        for (int vuelta = 0; vuelta < 3; vuelta++) {            int mejor = -1;            for (int i = 0; i < N; i++) {                // Con «>» gana la primera en el alfabeto si hay empate                if (!usada[i] && veces[i] > 0 && (mejor < 0 || veces[i] > veces[mejor])) mejor = i;            }            if (mejor < 0) break;            usada[mejor] = true;            if (vuelta > 0) sb.append(", ");            sb.append(ALFABETO.charAt(mejor)).append(' ').append(veces[mejor]);        }        return sb.toString();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String clave = null;        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            int espacio = linea.indexOf(' ');            String orden = (espacio < 0 ? linea : linea.substring(0, espacio)).toUpperCase();            String argumento = espacio < 0 ? "" : linea.substring(espacio + 1).trim();             switch (orden) {                case "CLAVE" -> {                    String nueva = validarClave(argumento);                    if (nueva == null) {                        System.out.println("Clave no válida: solo letras de la A a la Z y la Ñ");                    } else {                        clave = nueva;                        System.out.println("Clave guardada (" + clave.length() + (clave.length() == 1 ? " letra)" : " letras)"));                    }                }                case "CIFRAR", "DESCIFRAR" -> {                    if (clave == null) System.out.println("Falta la clave");                    else if (argumento.isEmpty()) System.out.println("Falta el texto");                    else if (orden.equals("CIFRAR")) System.out.println("Cifrado: " + vigenere(argumento, clave, 1));                    else System.out.println("Descifrado: " + vigenere(argumento, clave, -1));                }                case "ANALIZAR" -> System.out.println(analizar(argumento));                default -> System.out.println("Orden desconocida: " + orden);            }        }    }}

import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Locale;import java.util.Map;import java.util.Scanner; abstract class Vehiculo {    private final String matricula;    private final int entrada;   // minutos desde las 00:00     Vehiculo(String matricula, int entrada) {        this.matricula = matricula;        this.entrada = entrada;    }     String getMatricula() { return matricula; }    int getEntrada() { return entrada; }     abstract String tipo();    /** Céntimos por cada 15 minutos empezados. */    abstract long precioFraccion();    /** Lo máximo que se cobra en un día, en céntimos. */    abstract long maximoDiario();     /** Importe en céntimos de una estancia: 10 minutos gratis y, después, cada cuarto de hora empezado, con un máximo. */    long importe(int minutos) {        if (minutos <= 10) return 0;        long fracciones = (minutos + 14) / 15;        return Math.min(fracciones * precioFraccion(), maximoDiario());    }} class Coche extends Vehiculo {    Coche(String matricula, int entrada) { super(matricula, entrada); }    String tipo() { return "coche"; }    long precioFraccion() { return 60; }    long maximoDiario() { return 1800; }} class Moto extends Vehiculo {    Moto(String matricula, int entrada) { super(matricula, entrada); }    String tipo() { return "moto"; }    long precioFraccion() { return 30; }    long maximoDiario() { return 900; }} class Furgoneta extends Vehiculo {    Furgoneta(String matricula, int entrada) { super(matricula, entrada); }    String tipo() { return "furgoneta"; }    long precioFraccion() { return 90; }    long maximoDiario() { return 2500; }} public class Main {    static final List<String> TIPOS = List.of("coche", "moto", "furgoneta");    static final Map<String, Integer> PLAZAS = Map.of("coche", 4, "moto", 2, "furgoneta", 1);     static final Map<String, Vehiculo> dentro = new HashMap<>();    static long recaudado = 0;    static int salidas = 0;     /** «08:15» → 495 minutos; -1 si no es una hora válida. */    static int minutos(String hora) {        if (!hora.matches("([01]\\d|2[0-3]):[0-5]\\d")) return -1;        return Integer.parseInt(hora.substring(0, 2)) * 60 + Integer.parseInt(hora.substring(3));    }     static String euros(long centimos) {        return String.format(Locale.ROOT, "%d,%02d €", centimos / 100, centimos % 100);    }     static String duracion(int minutos) {        int h = minutos / 60, m = minutos % 60;        if (h == 0) return m + " min";        return m == 0 ? h + " h" : h + " h " + m + " min";    }     static int ocupadas(String tipo) {        int n = 0;        for (Vehiculo v : dentro.values()) if (v.tipo().equals(tipo)) n++;        return n;    }     static void entra(String hora, String tipo, String matricula) {        int min = minutos(hora);        if (min < 0) { System.out.println("Hora no válida: " + hora); return; }        if (!TIPOS.contains(tipo)) { System.out.println("Tipo no válido: " + tipo); return; }        // Matrículas españolas: 4 cifras y 3 consonantes (sin vocales, Ñ ni Q)        if (!matricula.matches("\\d{4}[BCDFGHJKLMNPRSTVWXYZ]{3}")) { System.out.println("Matrícula no válida: " + matricula); return; }        if (dentro.containsKey(matricula)) { System.out.println(matricula + " ya está dentro"); return; }        if (ocupadas(tipo) == PLAZAS.get(tipo)) { System.out.println("No quedan plazas de " + tipo); return; }         Vehiculo v = switch (tipo) {            case "coche" -> new Coche(matricula, min);            case "moto" -> new Moto(matricula, min);            default -> new Furgoneta(matricula, min);        };        dentro.put(matricula, v);        System.out.println("Entra " + matricula + " (" + tipo + ") a las " + hora);    }     static void sale(String hora, String matricula) {        int min = minutos(hora);        if (min < 0) { System.out.println("Hora no válida: " + hora); return; }        Vehiculo v = dentro.get(matricula);        if (v == null) { System.out.println(matricula + " no está en el parking"); return; }        if (min < v.getEntrada()) { System.out.println("La hora de salida es anterior a la entrada"); return; }         int estancia = min - v.getEntrada();        long importe = v.importe(estancia);   // cada tipo de vehículo aplica su tarifa        dentro.remove(matricula);        recaudado += importe;        salidas++;        System.out.println("Sale " + matricula + " (" + v.tipo() + ") tras " + duracion(estancia) + ": " + euros(importe));    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            String[] p = linea.split("\\s+");            switch (p[0].toUpperCase()) {                case "ENTRA" -> {                    if (p.length != 4) System.out.println("Orden incompleta");                    else entra(p[1], p[2].toLowerCase(), p[3].toUpperCase());                }                case "SALE" -> {                    if (p.length != 3) System.out.println("Orden incompleta");                    else sale(p[1], p[2].toUpperCase());                }                case "OCUPACION" -> {                    List<String> partes = new ArrayList<>();                    for (String tipo : TIPOS) partes.add(tipo + " " + ocupadas(tipo) + "/" + PLAZAS.get(tipo));                    System.out.println("Ocupación: " + String.join(" · ", partes));                }                default -> System.out.println("Orden desconocida");            }        }         System.out.println("Recaudación: " + euros(recaudado) + " (" + salidas + (salidas == 1 ? " salida)" : " salidas)"));        List<String> quedan = new ArrayList<>(dentro.keySet());        quedan.sort(null);        System.out.println("Siguen dentro: " + (quedan.isEmpty() ? "ninguno" : String.join(", ", quedan)));    }}

import java.util.ArrayDeque;import java.util.ArrayList;import java.util.Deque;import java.util.List;import java.util.Map;import java.util.Scanner;import java.util.TreeMap; public class Main {    /** Error de una expresión, con el mensaje que se muestra. */    static class ErrorExpresion extends Exception {        ErrorExpresion(String mensaje) { super(mensaje); }    }     // TreeMap: las variables salen siempre por orden alfabético    static final Map<String, Long> variables = new TreeMap<>();     static boolean esOperador(String t) {        return t.equals("+") || t.equals("-") || t.equals("*") || t.equals("/") || t.equals("%") || t.equals("~");    }     static int prioridad(String op) {        return switch (op) {            case "~" -> 3;            case "*", "/", "%" -> 2;            case "+", "-" -> 1;            default -> 0;        };    }     /** «x * (2 - 15)» → [x, *, (, 2, -, 15, )]. */    static List<String> separar(String texto) throws ErrorExpresion {        List<String> tokens = new ArrayList<>();        int i = 0;        while (i < texto.length()) {            char c = texto.charAt(i);            if (Character.isWhitespace(c)) {                i++;            } else if (Character.isDigit(c) || Character.isLetter(c) || c == '_') {                int j = i;                while (j < texto.length() && (Character.isLetterOrDigit(texto.charAt(j)) || texto.charAt(j) == '_')) j++;                tokens.add(texto.substring(i, j));                i = j;            } else if ("+-*/%()".indexOf(c) >= 0) {                tokens.add(String.valueOf(c));                i++;            } else {                throw new ErrorExpresion("carácter no válido '" + c + "'");            }        }        return tokens;    }     /** Algoritmo de la estación de maniobras (shunting-yard): notación infija → postfija. */    static List<String> aPostfija(List<String> tokens) throws ErrorExpresion {        List<String> salida = new ArrayList<>();        Deque<String> pila = new ArrayDeque<>();        String anterior = null;        for (String t : tokens) {            if (t.equals("(")) {                pila.push(t);            } else if (t.equals(")")) {                while (!pila.isEmpty() && !pila.peek().equals("(")) salida.add(pila.pop());                if (pila.isEmpty()) throw new ErrorExpresion("paréntesis sin abrir");                pila.pop();            } else if (esOperador(t)) {                // Un menos al principio, tras «(» o tras otro operador cambia el signo: es el operador unario ~                boolean unario = t.equals("-") && (anterior == null || anterior.equals("(") || esOperador(anterior));                String op = unario ? "~" : t;                // Los binarios son asociativos por la izquierda (sacan los de igual prioridad); ~ por la derecha                while (!pila.isEmpty() && !pila.peek().equals("(")                        && (unario ? prioridad(pila.peek()) > prioridad(op) : prioridad(pila.peek()) >= prioridad(op))) {                    salida.add(pila.pop());                }                pila.push(op);                t = op;            } else {                salida.add(t);   // número o variable            }            anterior = t;        }        while (!pila.isEmpty()) {            String op = pila.pop();            if (op.equals("(")) throw new ErrorExpresion("paréntesis sin cerrar");            salida.add(op);        }        return salida;    }     static long evaluar(List<String> postfija) throws ErrorExpresion {        Deque<Long> pila = new ArrayDeque<>();        try {            for (String t : postfija) {                if (t.equals("~")) {                    if (pila.isEmpty()) throw new ErrorExpresion("expresión incompleta");                    pila.push(Math.negateExact(pila.pop()));                } else if (esOperador(t)) {                    if (pila.size() < 2) throw new ErrorExpresion("expresión incompleta");                    long b = pila.pop(), a = pila.pop();                    if ((t.equals("/") || t.equals("%")) && b == 0) throw new ErrorExpresion("división entre cero");                    pila.push(switch (t) {                        case "+" -> Math.addExact(a, b);                        case "-" -> Math.subtractExact(a, b);                        case "*" -> Math.multiplyExact(a, b);                        case "/" -> a / b;                        default -> a % b;                    });                } else if (Character.isDigit(t.charAt(0))) {                    if (!t.matches("\\d+")) throw new ErrorExpresion("número no válido " + t);                    pila.push(Long.parseLong(t));                } else {                    Long valor = variables.get(t);                    if (valor == null) throw new ErrorExpresion("variable desconocida " + t);                    pila.push(valor);                }            }        } catch (NumberFormatException e) {            throw new ErrorExpresion("número demasiado grande");        } catch (ArithmeticException e) {            throw new ErrorExpresion("desbordamiento");        }        if (pila.size() != 1) throw new ErrorExpresion("expresión incompleta");        return pila.pop();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            if (linea.equalsIgnoreCase("VARIABLES")) {                List<String> lista = new ArrayList<>();                variables.forEach((nombre, valor) -> lista.add(nombre + " = " + valor));                System.out.println("Variables: " + (lista.isEmpty() ? "ninguna" : String.join(", ", lista)));                continue;            }            // «nombre = expresión» es una asignación            String nombre = null, expresion = linea;            if (linea.matches("[A-Za-z_]\\w*\\s*=.*")) {                int igual = linea.indexOf('=');                nombre = linea.substring(0, igual).trim();                expresion = linea.substring(igual + 1);            }            try {                List<String> postfija = aPostfija(separar(expresion));                String textoPostfija = String.join(" ", postfija);                try {                    long valor = evaluar(postfija);                    if (nombre != null) variables.put(nombre, valor);                    System.out.println(linea + " → " + textoPostfija + " → " + (nombre != null ? nombre + " = " : "") + valor);                } catch (ErrorExpresion e) {                    System.out.println(linea + " → " + (textoPostfija.isEmpty() ? "" : textoPostfija + " → ") + "Error: " + e.getMessage());                }            } catch (ErrorExpresion e) {                System.out.println(linea + " → Error: " + e.getMessage());            }        }    }}

import java.util.ArrayList;import java.util.List;import java.util.Scanner; public class Main {    /** Campos de una línea CSV separados por comas, con comillas dobles opcionales ("" es una comilla). null si hay comillas sin cerrar. */    static List<String> campos(String linea) {        List<String> lista = new ArrayList<>();        StringBuilder actual = new StringBuilder();        boolean entreComillas = false;        for (int i = 0; i < linea.length(); i++) {            char c = linea.charAt(i);            if (entreComillas) {                if (c != '"') {                    actual.append(c);                } else if (i + 1 < linea.length() && linea.charAt(i + 1) == '"') {                    actual.append('"');                    i++;                } else {                    entreComillas = false;                }            } else if (c == '"') {                entreComillas = true;            } else if (c == ',') {                lista.add(actual.toString().trim());                actual.setLength(0);            } else {                actual.append(c);            }        }        if (entreComillas) return null;        lista.add(actual.toString().trim());        return lista;    }     /** Texto JSON entre comillas, con las comillas, barras y tabuladores escapados. */    static String cadena(String s) {        StringBuilder sb = new StringBuilder("\"");        for (char c : s.toCharArray()) {            switch (c) {                case '"' -> sb.append("\\\"");                case '\\' -> sb.append("\\\\");                case '\t' -> sb.append("\\t");                default -> sb.append(c);            }        }        return sb.append('"').toString();    }     /** El valor JSON de un campo: null, número, booleano o texto. */    static String valor(String campo) {        if (campo.isEmpty()) return "null";        // Un número JSON no admite ceros a la izquierda: «08001» es un código postal, no el 8001        if (campo.matches("-?(0|[1-9]\\d*)(\\.\\d+)?")) return campo;        if (campo.equals("true") || campo.equals("false")) return campo;        return cadena(campo);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> cabecera = null;        List<String> objetos = new ArrayList<>();        List<Integer> ignoradas = new ArrayList<>();        int numero = 0;        while (sc.hasNextLine()) {            String linea = sc.nextLine();            numero++;            if (linea.isBlank()) continue;            List<String> c = campos(linea);            if (cabecera == null) {                cabecera = c;                continue;            }            if (c == null || c.size() != cabecera.size()) {                ignoradas.add(numero);                continue;            }            StringBuilder obj = new StringBuilder("  {\n");            for (int i = 0; i < c.size(); i++) {                obj.append("    ").append(cadena(cabecera.get(i))).append(": ").append(valor(c.get(i)));                obj.append(i < c.size() - 1 ? ",\n" : "\n");            }            objetos.add(obj.append("  }").toString());        }         if (cabecera == null) {            System.out.println("El fichero está vacío");            return;        }        System.out.println(objetos.isEmpty() ? "[]" : "[\n" + String.join(",\n", objetos) + "\n]");        String lista = ignoradas.isEmpty() ? "" : " (" + String.join(", ", ignoradas.stream().map(String::valueOf).toList()) + ")";        System.out.println("Registros: " + objetos.size() + " · Líneas ignoradas: " + ignoradas.size() + lista);    }}

import java.util.ArrayList;import java.util.List;import java.util.Locale;import java.util.Scanner; interface Retribuible {    /** Bruto del mes, en céntimos. */    long bruto();     /** Retención de IRPF de la tabla simplificada de la empresa: un tipo según el tramo del bruto mensual. */    default long retencion() {        long b = bruto();        int centesimas = b <= 100000 ? 200 : b <= 200000 ? 1200 : b <= 300000 ? 1800 : 2400;        return Main.porcentaje(b, centesimas);    }     /** Cotización del trabajador a la Seguridad Social: un 6,5 % del bruto en este ejercicio. */    default long seguridadSocial() {        return Main.porcentaje(bruto(), 650);    }     default long neto() {        return bruto() - retencion() - seguridadSocial();    }} abstract class Empleado implements Retribuible {    private final String nombre;     Empleado(String nombre) { this.nombre = nombre; }     String getNombre() { return nombre; }     abstract String tipo();} class Asalariado extends Empleado {    private final long anual;    private final int pagas;     Asalariado(String nombre, long anual, int pagas) {        super(nombre);        this.anual = anual;        this.pagas = pagas;    }     String tipo() { return "asalariado"; }     // Redondeo al céntimo más cercano con enteros: (2a + p) / 2p    public long bruto() { return (anual * 2 + pagas) / (2L * pagas); }} class PorHoras extends Empleado {    private final int horas;    private final long precioHora;     PorHoras(String nombre, int horas, long precioHora) {        super(nombre);        this.horas = horas;        this.precioHora = precioHora;    }     String tipo() { return "por horas"; }     public long bruto() {        int normales = Math.min(horas, 160), extra = Math.max(0, horas - 160);        return normales * precioHora + Main.porcentaje(extra * precioHora, 12500);   // las extra, al 125 %    }} class Comercial extends Empleado {    private final long base, ventas, comision;   // comisión en centésimas de %     Comercial(String nombre, long base, long ventas, long comision) {        super(nombre);        this.base = base;        this.ventas = ventas;        this.comision = comision;    }     String tipo() { return "comercial"; }     public long bruto() { return base + Math.min(Main.porcentaje(ventas, comision), 200000); }} class Becario extends Empleado {    private final long ayuda;     Becario(String nombre, long ayuda) {        super(nombre);        this.ayuda = ayuda;    }     String tipo() { return "becario"; }     public long bruto() { return ayuda; }     // La beca no lleva retención en este ejercicio: se sobrescribe el método por defecto    @Override    public long retencion() { return 0; }} public class Main {    /** cantidad × centésimas / 10000, redondeado al céntimo (las mitades suben). */    static long porcentaje(long cantidad, long centesimas) {        return (cantidad * centesimas + 5000) / 10000;    }     /** «1234.5» → 123450; -1 si no es un número positivo con hasta 2 decimales. */    static long centimos(String texto) {        if (!texto.matches("\\d{1,9}(\\.\\d{1,2})?")) return -1;        String[] p = texto.split("\\.");        return Long.parseLong(p[0]) * 100 + (p.length == 2 ? Long.parseLong((p[1] + "0").substring(0, 2)) : 0);    }     static String euros(long c) {        return String.format(Locale.ROOT, "%,d", c / 100).replace(',', '.') + "," + String.format("%02d", c % 100);    }     /** El empleado de una línea, o una excepción con el motivo por el que se ignora. */    static Empleado leer(String linea) {        int espacio = linea.indexOf(' ');        if (espacio < 0) throw new IllegalArgumentException("faltan o sobran datos");        String tipo = linea.substring(0, espacio).toUpperCase();        String[] d = linea.substring(espacio + 1).split(";", -1);        int esperados = switch (tipo) {            case "ASALARIADO", "HORAS" -> 3;            case "COMERCIAL" -> 4;            case "BECARIO" -> 2;            default -> throw new IllegalArgumentException("tipo desconocido " + tipo);        };        if (d.length != esperados || d[0].isBlank()) throw new IllegalArgumentException("faltan o sobran datos");        String nombre = d[0].trim();        long[] n = new long[d.length];        for (int i = 1; i < d.length; i++) {            n[i] = centimos(d[i].trim());            if (n[i] < 0) throw new IllegalArgumentException("dato no válido");        }        switch (tipo) {            case "ASALARIADO" -> {                if (n[2] != 1200 && n[2] != 1400) throw new IllegalArgumentException("dato no válido");                return new Asalariado(nombre, n[1], (int) (n[2] / 100));            }            case "HORAS" -> {                if (n[1] % 100 != 0 || n[1] > 30000) throw new IllegalArgumentException("dato no válido");                return new PorHoras(nombre, (int) (n[1] / 100), n[2]);            }            case "COMERCIAL" -> {                if (n[3] > 2000) throw new IllegalArgumentException("dato no válido");                return new Comercial(nombre, n[1], n[2], n[3]);            }            default -> {                return new Becario(nombre, n[1]);            }        }    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<Empleado> plantilla = new ArrayList<>();        int numero = 0;        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            numero++;            if (linea.isEmpty()) continue;            try {                plantilla.add(leer(linea));            } catch (IllegalArgumentException e) {                System.out.println("Línea " + numero + " ignorada: " + e.getMessage());            }        }        if (plantilla.isEmpty()) {            System.out.println("No hay nóminas que calcular.");            return;        }         String formato = "%-20s%-12s%11s%11s%11s%11s%n";        System.out.printf(formato, "Empleado", "Tipo", "Bruto", "IRPF", "SS", "Neto");        long bruto = 0, irpf = 0, ss = 0, neto = 0;        Empleado mejor = plantilla.get(0);        for (Empleado e : plantilla) {            // El mismo código sirve para cualquier empleado: cada clase sabe calcular su bruto            System.out.printf(formato, e.getNombre(), e.tipo(), euros(e.bruto()), euros(e.retencion()), euros(e.seguridadSocial()), euros(e.neto()));            bruto += e.bruto();            irpf += e.retencion();            ss += e.seguridadSocial();            neto += e.neto();            if (e.neto() > mejor.neto()) mejor = e;        }        System.out.printf(formato, "TOTAL", "", euros(bruto), euros(irpf), euros(ss), euros(neto));        System.out.println("Coste para la empresa: " + euros(bruto + porcentaje(bruto, 3000)) + " €");        System.out.println("Mayor neto: " + mejor.getNombre() + " (" + euros(mejor.neto()) + " €)");    }}