Ejercicios de Java resueltos

import java.util.*; public class Main {    record Historia(String id, int puntos, int diaTerminada) { }   // diaTerminada = 0 si no se terminó     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int dias = sc.nextInt();        List<Historia> hs = new ArrayList<>();        while (sc.hasNext()) hs.add(new Historia(sc.next(), sc.nextInt(), sc.nextInt()));        // TODO: mostrar el burndown día a día, la velocidad y las historias pendientes    }}

import java.util.*; public class Main {    record Tarea(String id, int duracion, List<String> previas) { }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Tarea> tareas = new LinkedHashMap<>();        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) continue;            // Formato: ID duración [previa1,previa2,...]            String[] p = l.split("\\s+");            List<String> previas = p.length > 2 ? List.of(p[2].split(",")) : List.of();            tareas.put(p[0], new Tarea(p[0], Integer.parseInt(p[1]), previas));        }        // TODO: orden topológico, inicio y fin más tempranos, duración del proyecto,        //       holgura de cada tarea y camino crítico (o error si hay un ciclo)    }}

import java.util.*; public class Main {    // Este código compila pero tiene CUATRO errores. Encuéntralos con el depurador (o con trazas) y corrígelos.    static String resumen(int[] notas) {        int suma = 0, aprobados = 0, max = 0, min = 0;        for (int i = 1; i < notas.length; i++) {            suma += notas[i];            if (notas[i] > 5) aprobados++;            if (notas[i] > max) max = notas[i];            if (notas[i] < min) min = notas[i];        }        double media = suma / notas.length;        return String.format(Locale.US, "media %.2f, aprobados %d de %d, máxima %d, mínima %d",                media, aprobados, notas.length, max, min);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) continue;            int[] notas = Arrays.stream(l.split("\\s+")).mapToInt(Integer::parseInt).toArray();            System.out.println(Arrays.toString(notas) + " → " + resumen(notas));        }    }}

import java.util.*; public class Main {    // Primera posición i tal que a[i] >= x (a.length si no hay ninguna). El array está ordenado.    // Tiene errores que solo aparecen en algunos casos: encuéntralos.    static int primeraMayorOIgual(int[] a, int x) {        int lo = 0, hi = a.length - 1;        int vueltas = 0;                           // protección para que no se cuelgue mientras lo depuras        while (lo < hi && vueltas++ < 100) {            int medio = (lo + hi) / 2;            if (a[medio] < x) lo = medio;            else hi = medio - 1;        }        return lo;    }     static int contar(int[] a, int x) {        return primeraMayorOIgual(a, x + 1) - primeraMayorOIgual(a, x);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int[] a = Arrays.stream(sc.nextLine().trim().split("\\s+")).mapToInt(Integer::parseInt).toArray();        while (sc.hasNextInt()) {            int x = sc.nextInt();            System.out.println("x=" + x + ": primera posición >= x → " + primeraMayorOIgual(a, x) + ", apariciones → " + contar(a, x));        }    }}

import java.util.*;import java.util.function.DoubleUnaryOperator; public class Main {    // Tarifa de envío según el peso en kg. -1 significa «no admitido».    //   peso <= 0        → -1    //   0 < peso <= 1    → 4.5    //   1 < peso <= 5    → 7    //   5 < peso <= 20   → 12    //   peso > 20        → -1    static double tarifa(double peso) {        if (peso <= 0) return -1;        if (peso <= 1) return 4.5;        if (peso <= 5) return 7;        if (peso <= 20) return 12;        return -1;    }     // TODO: escribe aquí tus casos de prueba: {peso, resultado esperado}    static final double[][] CASOS = {        {3, 7},    };     // ---- No modifiques lo que sigue: versiones con un error cada una («mutantes»)    static final Map<String, DoubleUnaryOperator> MUTANTES = new LinkedHashMap<>();    static {        MUTANTES.put("M1 (< 1 en vez de <= 1)", p -> p <= 0 ? -1 : p < 1 ? 4.5 : p <= 5 ? 7 : p <= 20 ? 12 : -1);        MUTANTES.put("M2 (< 5 en vez de <= 5)", p -> p <= 0 ? -1 : p <= 1 ? 4.5 : p < 5 ? 7 : p <= 20 ? 12 : -1);        MUTANTES.put("M3 (< 20 en vez de <= 20)", p -> p <= 0 ? -1 : p <= 1 ? 4.5 : p <= 5 ? 7 : p < 20 ? 12 : -1);        MUTANTES.put("M4 (< 0 en vez de <= 0)", p -> p < 0 ? -1 : p <= 1 ? 4.5 : p <= 5 ? 7 : p <= 20 ? 12 : -1);        MUTANTES.put("M5 (sin límite superior)", p -> p <= 0 ? -1 : p <= 1 ? 4.5 : p <= 5 ? 7 : 12);        MUTANTES.put("M6 (7.5 en vez de 7)", p -> p <= 0 ? -1 : p <= 1 ? 4.5 : p <= 5 ? 7.5 : p <= 20 ? 12 : -1);    }     public static void main(String[] args) {        String fallo = null;        for (double[] c : CASOS)            if (tarifa(c[0]) != c[1] && fallo == null) fallo = "tarifa(" + c[0] + ") da " + tarifa(c[0]) + ", no " + c[1];        System.out.println("Casos correctos con el original: " + (fallo == null ? "sí" : "no (" + fallo + ")"));        List<String> vivos = new ArrayList<>();        for (var m : MUTANTES.entrySet()) {            boolean detectado = false;            for (double[] c : CASOS) if (m.getValue().applyAsDouble(c[0]) != c[1]) detectado = true;            if (!detectado) vivos.add(m.getKey());        }        System.out.println("Mutantes detectados: " + (MUTANTES.size() - vivos.size()) + " de " + MUTANTES.size());        System.out.println("Sobreviven: " + (vivos.isEmpty() ? "ninguno" : String.join(", ", vivos)));    }}

import java.util.*; public class Main {    interface Precio { double calcular(int edad, boolean socio, boolean finDeSemana); }     // Precio de la entrada a un museo:    //   edad < 0 → -1 (error)    //   base 10 €; los fines de semana, 12 €    //   menores de 12: 50 % de descuento; desde 65: 40 % de descuento    //   los socios tienen además 2 € menos sobre el precio ya descontado (nunca por debajo de 0)    static final Precio ORIGINAL = (edad, socio, finde) -> {        if (edad < 0) return -1;        double p = finde ? 12 : 10;        if (edad < 12) p *= 0.5;        else if (edad >= 65) p *= 0.6;        if (socio) p = Math.max(0, p - 2);        return p;    };     // TODO: tus casos: {edad, socio (0/1), fin de semana (0/1), precio esperado}    static final double[][] CASOS = {        {30, 0, 0, 10},    };     // ---- No modifiques lo que sigue    static final Map<String, Precio> MUTANTES = new LinkedHashMap<>();    static {        MUTANTES.put("M1 (<= 12)", (e, s, f) -> e < 0 ? -1 : aplicar(f ? 12 : 10, e <= 12, e >= 65, s));        MUTANTES.put("M2 (> 65)", (e, s, f) -> e < 0 ? -1 : aplicar(f ? 12 : 10, e < 12, e > 65, s));        MUTANTES.put("M3 (<= 0 es error)", (e, s, f) -> e <= 0 ? -1 : aplicar(f ? 12 : 10, e < 12, e >= 65, s));        MUTANTES.put("M4 (socio antes del %)", (e, s, f) -> {            if (e < 0) return -1;            double p = (f ? 12 : 10) - (s ? 2 : 0);            return e < 12 ? p * 0.5 : e >= 65 ? p * 0.6 : p;        });        MUTANTES.put("M5 (sin tope en 0)", (e, s, f) -> {            if (e < 0) return -1;            double p = f ? 12 : 10;            if (e < 12) p *= 0.5; else if (e >= 65) p *= 0.6;            return s ? p - 2 : p;        });        MUTANTES.put("M6 (ignora el fin de semana con descuento)", (e, s, f) -> e < 0 ? -1 : aplicar((f && e >= 12 && e < 65) ? 12 : 10, e < 12, e >= 65, s));        MUTANTES.put("M7 (el socio solo descuenta a adultos)", (e, s, f) -> e < 0 ? -1 : aplicar(f ? 12 : 10, e < 12, e >= 65, s && e >= 12 && e < 65));        MUTANTES.put("M8 (65 o más: 50 %)", (e, s, f) -> {            if (e < 0) return -1;            double p = f ? 12 : 10;            if (e < 12 || e >= 65) p *= 0.5;            if (s) p = Math.max(0, p - 2);            return p;        });    }     static double aplicar(double p, boolean nino, boolean mayor, boolean socio) {        if (nino) p *= 0.5; else if (mayor) p *= 0.6;        if (socio) p = Math.max(0, p - 2);        return p;    }     static boolean igual(double a, double b) { return Math.abs(a - b) < 1e-9; }     public static void main(String[] args) {        String fallo = null;        for (double[] c : CASOS) {            double r = ORIGINAL.calcular((int) c[0], c[1] == 1, c[2] == 1);            if (!igual(r, c[3]) && fallo == null) fallo = Arrays.toString(c) + " da " + r;        }        System.out.println("Casos correctos con el original: " + (fallo == null ? "sí" : "no (" + fallo + ")"));        List<String> vivos = new ArrayList<>();        for (var m : MUTANTES.entrySet()) {            boolean detectado = false;            for (double[] c : CASOS)                if (!igual(m.getValue().calcular((int) c[0], c[1] == 1, c[2] == 1), c[3])) detectado = true;            if (!detectado) vivos.add(m.getKey());        }        System.out.println("Mutantes detectados: " + (MUTANTES.size() - vivos.size()) + " de " + MUTANTES.size());        System.out.println("Sobreviven: " + (vivos.isEmpty() ? "ninguno" : String.join(", ", vivos)));    }}

import java.util.*;import java.util.regex.*; public class Main {    static final int MAX_LINEAS_METODO = 8, MAX_PARAMETROS = 3;    static final Pattern METODO = Pattern.compile(            "^\\s*(public|private|protected|static|\\s)+[\\w<>\\[\\]]+\\s+(\\w+)\\s*\\(([^)]*)\\)\\s*\\{");     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> lineas = new ArrayList<>();        while (sc.hasNextLine()) lineas.add(sc.nextLine());        List<String> avisos = analizar(lineas);        avisos.forEach(System.out::println);        System.out.println(avisos.size() + (avisos.size() == 1 ? " aviso" : " avisos"));    }     static List<String> analizar(List<String> lineas) {        List<String> avisos = new ArrayList<>();        // TODO: recorrer las líneas y aplicar las cuatro reglas        return avisos;    }}

import java.util.*; public class Main {    static final Map<String, List<String>> padres = new LinkedHashMap<>();   // commit → sus padres    static final Map<String, String> ramas = new TreeMap<>();                // rama → commit al que apunta     // Todos los antepasados de un commit, incluido él mismo    static Set<String> antepasados(String c) {        // TODO        return new HashSet<>();    }     // Antepasado común «más reciente» (el que no es antepasado de otro antepasado común); null si no hay    static String baseDeFusion(String a, String b) {        // TODO        return null;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] t = sc.nextLine().trim().split("\\s+");            switch (t[0]) {                case "COMMIT" -> padres.put(t[1], t.length > 2 ? List.of(t[2].split(",")) : List.of());                case "RAMA" -> ramas.put(t[1], t[2]);                case "BASE" -> System.out.println("merge-base " + t[1] + " " + t[2] + " → " + baseDeFusion(ramas.get(t[1]), ramas.get(t[2])));                case "FUSIONAR" -> {        // FUSIONAR destino origen: ¿qué haría git merge origen estando en destino?                    String d = ramas.get(t[1]), o = ramas.get(t[2]);                    String base = baseDeFusion(d, o);                    String r;                    if (o.equals(base)) r = "ya actualizado (nada que fusionar)";                    else if (d.equals(base)) r = "fast-forward: " + t[1] + " pasa de " + d + " a " + o;                    else r = "fusión de tres vías (base " + base + "): se crea un commit de fusión";                    System.out.println("git merge " + t[2] + " en " + t[1] + " → " + r);                }            }        }    }}

import java.util.*; interface Inventario {    int stock(String producto);    void descontar(String producto, int unidades);} interface Correo {    void enviar(String destinatario, String asunto);} // Clase que se quiere probar: no sabe si habla con una base de datos real o con un dobleclass ServicioPedidos {    private final Inventario inventario;    private final Correo correo;     ServicioPedidos(Inventario inventario, Correo correo) {        this.inventario = inventario;        this.correo = correo;    }     boolean pedir(String cliente, String producto, int unidades) {        if (unidades <= 0) return false;        if (inventario.stock(producto) < unidades) {            correo.enviar("almacen@tienda.es", "Sin stock: " + producto);            return false;        }        inventario.descontar(producto, unidades);        correo.enviar(cliente, "Pedido confirmado: " + unidades + " x " + producto);        return true;    }} // TODO: un doble de Inventario con un stock fijado por la prueba que anote las llamadas a descontarclass InventarioFalso implements Inventario {    InventarioFalso(int stockFijo) { }    public int stock(String producto) { return 0; }    public void descontar(String producto, int unidades) { }    List<String> descuentos() { return List.of(); }} // TODO: un doble de Correo que guarde cada envío como "destinatario | asunto"class CorreoEspia implements Correo {    public void enviar(String destinatario, String asunto) { }    List<String> enviados() { return List.of(); }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] t = sc.nextLine().trim().split(" ");   // stock cliente producto unidades            InventarioFalso inv = new InventarioFalso(Integer.parseInt(t[0]));            CorreoEspia correo = new CorreoEspia();            boolean ok = new ServicioPedidos(inv, correo).pedir(t[1], t[2], Integer.parseInt(t[3]));            System.out.println("pedir(" + t[1] + ", " + t[2] + ", " + t[3] + ") con stock " + t[0] + " → " + ok);            System.out.println("  descuentos: " + inv.descuentos());            System.out.println("  correos: " + correo.enviados());        }    }}

import java.lang.annotation.*;import java.lang.reflect.*;import java.util.*; // Anotaciones propias, como @Test y @BeforeEach de JUnit@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Prueba { }@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface Antes { } class FalloAsercion extends RuntimeException {    FalloAsercion(String m) { super(m); }} class Afirmar {    static void iguales(Object esperado, Object real) {        if (!Objects.equals(esperado, real)) throw new FalloAsercion("se esperaba <" + esperado + "> pero fue <" + real + ">");    }    static void cierto(boolean c, String mensaje) {        if (!c) throw new FalloAsercion(mensaje);    }} // ---- Las pruebas de ejemplo (no las modifiques)class PilaTest {    private Deque<Integer> pila;     @Antes void preparar() { pila = new ArrayDeque<>(); pila.push(1); pila.push(2); }     @Prueba void cimaEsElUltimo() { Afirmar.iguales(2, pila.peek()); }    @Prueba void sacarReduce() { pila.pop(); Afirmar.iguales(1, pila.size()); }    @Prueba void cadaPruebaEmpiezaLimpia() { Afirmar.iguales(2, pila.size()); }    @Prueba void fallaAProposito() { Afirmar.iguales(3, pila.size()); }    @Prueba void lanzaExcepcion() { new ArrayDeque<Integer>().pop(); }    void noEsUnaPrueba() { throw new IllegalStateException("no debería ejecutarse"); }} public class Main {    // Ejecuta todos los métodos @Prueba de la clase, en orden alfabético, con una instancia nueva cada vez    static void ejecutar(Class<?> clase) throws Exception {        // TODO    }     public static void main(String[] args) throws Exception {        ejecutar(PilaTest.class);    }}

import java.util.*; public class Main {    // Diagrama de estados de un pedido (estado inicial: CARRITO)    //   CARRITO   --pagar-->     PAGADO    //   CARRITO   --cancelar-->  CANCELADO    //   PAGADO    --enviar-->    ENVIADO    //   PAGADO    --cancelar-->  CANCELADO   [acción: devolver el dinero]    //   ENVIADO   --entregar-->  ENTREGADO    //   ENVIADO   --perder-->    PAGADO      [acción: reenviar; como mucho 2 veces, después CANCELADO con devolución]    //   ENTREGADO y CANCELADO son estados finales    enum Estado { CARRITO, PAGADO, ENVIADO, ENTREGADO, CANCELADO }     static Estado estado = Estado.CARRITO;    static int perdidas = 0;     // Aplica un evento y devuelve el texto que describe lo ocurrido    static String aplicar(String evento) {        // TODO        return "";    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNext()) {            String ev = sc.next();            Estado antes = estado;            String r = aplicar(ev);            System.out.println(antes + " --" + ev + "--> " + r);        }        System.out.println("Estado final: " + estado);    }}

import java.lang.reflect.*;import java.util.*; // ---- Modelo de ejemplo (no lo modifiques)abstract class Persona {    protected String nombre;    private String dni;    public String getNombre() { return nombre; }}interface Evaluable { double nota(); }class Alumno extends Persona implements Evaluable {    private int curso;    private List<Matricula> matriculas;    public double nota() { return 0; }    public void matricular(Asignatura a) { }}class Profesor extends Persona {    private double salario;    private List<Asignatura> imparte;}class Asignatura {    private String codigo;    int horas;    private Profesor titular;}class Matricula {    private Asignatura asignatura;    private double nota;} public class Main {    static final List<Class<?>> MODELO = List.of(Persona.class, Evaluable.class, Alumno.class, Profesor.class, Asignatura.class, Matricula.class);     static String visibilidad(int mod) {        return Modifier.isPublic(mod) ? "+" : Modifier.isPrivate(mod) ? "-" : Modifier.isProtected(mod) ? "#" : "~";    }     // Genera el diagrama de clases en PlantUML a partir de las clases compiladas    static String plantUml(List<Class<?>> clases) {        StringBuilder sb = new StringBuilder("@startuml\n");        // TODO        return sb.append("@enduml").toString();    }     public static void main(String[] args) {        System.out.println(plantUml(MODELO));    }}

import java.util.*; public class Main {     // Devuelve la media de las notas (con decimales)    static double media(int[] notas) {        int suma = 0;        for (int i = 1; i <= notas.length - 1; i++) {            suma += notas[i];        }        return suma / notas.length;    }     // Devuelve la nota más alta    static int maxima(int[] notas) {        int max = notas[0];        for (int n : notas) {            if (n < max) max = n;        }        return max;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        int[] notas = new int[n];        for (int i = 0; i < n; i++) notas[i] = sc.nextInt();        System.out.printf(Locale.US, "Media: %.2f%n", media(notas));        System.out.println("Máxima: " + maxima(notas));    }}

import java.util.*; public class Main {     static String clasificar(int edad) {        // TODO: implementa la especificación        return "";    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            System.out.println(clasificar(sc.nextInt()));        }    }}

import java.util.*; public class Main {     static String tipo(int a, int b, int c) {        // TODO: clasifica el triángulo        return "";    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            System.out.println(tipo(sc.nextInt(), sc.nextInt(), sc.nextInt()));        }    }}

import java.util.*; public class Main {     static final double IVA = 0.21;     static double descuentoCliente(String tipo) {        // TODO: 0.15 para VIP, 0.05 para SOCIO y 0 para el resto        return 0;    }     static double descuentoVolumen(int unidades) {        // TODO: 0.10 a partir de 10 unidades        return 0;    }     static double aplicarDescuento(double importe, double descuento) {        return importe * (1 - descuento);    }     static double precioFinal(double base, int unidades, String tipo) {        double importe = base * unidades;        importe = aplicarDescuento(importe, descuentoCliente(tipo));        importe = aplicarDescuento(importe, descuentoVolumen(unidades));        // TODO: aplica el IVA usando la constante        return importe;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in).useLocale(Locale.US);        while (sc.hasNext()) {            double base = sc.nextDouble();            int unidades = sc.nextInt();            String tipo = sc.next();            System.out.printf(Locale.US, "%.2f%n", precioFinal(base, unidades, tipo));        }    }}

import java.util.*; abstract class Figura {    protected String nombre;     public Figura(String nombre) { this.nombre = nombre; }     public abstract double area();     @Override    public String toString() {        return String.format(Locale.US, "%s: %.2f", nombre, area());    }} class Circulo extends Figura {    private double radio;     public Circulo(double radio) {        super("Círculo");        // TODO: guarda el radio    }     @Override    public double area() {        return 0; // TODO: π·r²    }} class Rectangulo extends Figura {    // TODO: atributos base y altura     public Rectangulo(double base, double altura) {        super("Rectángulo");        // TODO: guarda base y altura    }     @Override    public double area() {        return 0; // TODO: base·altura    }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in).useLocale(Locale.US);        List<Figura> figuras = new ArrayList<>();        while (sc.hasNext()) {            String tipo = sc.next();            if (tipo.equals("C")) figuras.add(new Circulo(sc.nextDouble()));            else figuras.add(new Rectangulo(sc.nextDouble(), sc.nextDouble()));        }        double total = 0;        for (Figura f : figuras) {            System.out.println(f);            total += f.area();        }        System.out.printf(Locale.US, "Total: %.2f%n", total);    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();        // TODO: traduce el pseudocódigo del enunciado    }}

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();        // TODO: algoritmo de Euclides mostrando la traza    }}

import java.util.Scanner; public class Main {    static String aBase(int n, int base) {        // TODO: divisiones sucesivas entre la base        return "";    }     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;        // TODO: ciclo de captación y ejecución de instrucciones    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        long total = sc.nextLong();        // TODO: días, horas, minutos y segundos    }}

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();        // TODO: muestra las seis líneas del enunciado    }}

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();      // euros        double interesAnual = sc.nextDouble(); // en %        int anios = sc.nextInt();        // TODO: cuota mensual, intereses totales y las tres primeras cuotas    }}

import java.util.Scanner; public class Main {    static String simbolico(int permisos) {        // TODO: rwx por cada bit encendido, - por cada apagado        return "";    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int permisos = Integer.parseInt(sc.next(), 8);      // p. ej. 754 en octal        System.out.println("Inicial: " + String.format("%03o", permisos) + " " + simbolico(permisos));        while (sc.hasNext()) {            String orden = sc.next();                       // +x, -w, =r…            String quien = sc.next();                        // u, g, o o a            // TODO: aplicar la orden con operadores de 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();         // TODO: muestra la calificación correspondiente        System.out.println("?");    }}

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");            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 = false; // TODO: calcula si es bisiesto         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();            // TODO: validar la fecha y calcular el día siguiente        }    }}

import java.util.*; public class Main {    static double escala(double base) {        // TODO: impuesto por tramos de una base        return 0;    }     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();        // TODO: base, mínimo personal y familiar, cuota, tipo efectivo y neto    }}

import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int n = sc.nextInt();         // TODO: muestra la tabla de multiplicar de n    }}

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;         // TODO: suma los dígitos de n con un bucle while         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 = 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();        // TODO: secuencia de a y número con más pasos entre a y b    }}

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"};        // TODO: días del mes, día de la semana del día 1 y la cuadrícula    }}

import java.util.Scanner; public class Main {     static boolean esPrimo(int n) {        // TODO: devuelve true si n es primo        return false;    }     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) {        // TODO: implementa el factorial de forma recursiva        return 0;    }     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 void aplicarDescuento(double precio, int porcentaje) {        precio = precio - precio * porcentaje / 100;    }     public static void main(String[] args) {        double precio = 50;        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) {        // TODO: mover n discos de origen a destino usando auxiliar    }     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 long expresion() {        // TODO: términos separados por + o -        return 0;    }     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};         // TODO: encuentra el máximo y su posición        int max = numeros[0];        int posMax = 0;        // Tu código aquí         // TODO: encuentra el mínimo y su posición        int min = numeros[0];        int posMin = 0;        // Tu código aquí         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 = 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));         // TODO: invierte el array en su lugar (sin array auxiliar)        // Tu código aquí         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};         // TODO: calcula todas las estadísticas en un solo recorrido        double suma = 0;        int aprobados = 0;        int suspensos = 0;        double maxima = notas[0];        double minima = notas[0];         // Tu bucle aquí         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}        };         // TODO: imprime la suma de cada fila        // Fila 0: 6, Fila 1: 15, Fila 2: 24        for (int i = 0; i < matriz.length; i++) {            int sumaFila = 0;            // Tu código aquí            System.out.println("Fila " + i + ": " + sumaFila);        }         // TODO: imprime la suma de cada columna        // Col 0: 12, Col 1: 15, Col 2: 18        for (int j = 0; j < matriz[0].length; j++) {            int sumaCol = 0;            // Tu código aquí            System.out.println("Col " + j + ": " + sumaCol);        }    }}

import java.util.*; public class Main {    static boolean[][] siguiente(boolean[][] t) {        // TODO: calcular la siguiente generación        return t;    }     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) == '#';        // TODO: avanzar las generaciones, detectar si se estabiliza y mostrar el resultado    }}

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;         // TODO: cuenta las vocales de la frase         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 == "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();         boolean palindromo = false; // TODO         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;        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) {        // TODO: desplazar cada letra según la letra de la clave que le toca        return texto;    }     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+");        // TODO: repartir en líneas y justificarlas    }}

public class Main {    static class Alumno {        private String nombre;        private double nota;         Alumno(String nombre, double nota) {            nombre = nombre;            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) {        // TODO: rechazar denominador 0, simplificar y dejar el signo en el numerador        this.num = num;        this.den = den;    }     private static long mcd(long a, long b) {        return b == 0 ? Math.abs(a) : mcd(b, a % b);    }     Fraccion sumar(Fraccion o) {        // TODO        return this;    }     Fraccion restar(Fraccion o) {        // TODO        return this;    }     Fraccion multiplicar(Fraccion o) {        // TODO        return this;    }     Fraccion dividir(Fraccion o) {        // TODO: lanzar ArithmeticException("división entre cero") si o vale 0        return this;    }     @Override    public String toString() {        // TODO: si el denominador es 1, solo el numerador        return 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);    }     String insertar(int valor) {        // TODO        return "";    }     String comprar(String codigo) {        // TODO        return "";    }     String devolver() {        // TODO        return "";    }     String estado() {        // TODO        return "";    }} 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 {    // TODO: descubierto hasta -300; comisión de 2 € al cierre si el saldo es negativo    CuentaCorriente(String iban, double saldo) { super(iban, saldo); }    void retirar(double importe) { }    void cierreMes() { }    String tipo() { return "Corriente"; }} class CuentaAhorro extends Cuenta {    // TODO: sin descubierto, máximo 3 retiradas al mes, 0,5 % de interés al cierre    CuentaAhorro(String iban, double saldo) { super(iban, saldo); }    void retirar(double importe) { }    void cierreMes() { }    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; }         public boolean equals(Producto otro) {            return codigo.equals(otro.codigo);        }    }     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);    }} 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 "+"; }    // TODO: evaluar, derivar y simplificar    double evaluar(Map<String, Double> vars) { return 0; }    Expr derivar(String v) { return this; }} class Resta extends Binaria {    Resta(Expr a, Expr b) { super(a, b); }    String simbolo() { return "-"; }    // TODO: evaluar, derivar y simplificar    double evaluar(Map<String, Double> vars) { return 0; }    Expr derivar(String v) { return this; }} class Producto extends Binaria {    Producto(Expr a, Expr b) { super(a, b); }    String simbolo() { return "*"; }    // TODO: evaluar, derivar y simplificar    double evaluar(Map<String, Double> vars) { return 0; }    Expr derivar(String v) { return this; }} 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) {        // TODO: actualizar partidos, resultado y goles    }} public class Main {    // TODO: puntos (de más a menos), diferencia de goles, goles a favor y, por último, nombre (A-Z)    static final Comparator<Equipo> CLASIFICACION = (a, b) -> 0;     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.*; @FunctionalInterfaceinterface Regla {    // Lista de errores; vacía si el texto cumple la regla    List<String> comprobar(String s);     default Regla y(Regla otra) {        // TODO: se deben cumplir las dos; errores de ambas        return this;    }     default Regla o(Regla otra) {        // TODO: basta con que se cumpla una; si fallan las dos, un único error «e1 o e2»        return this;    }     static Regla minimo(int n) {        // TODO: «mínimo n caracteres»        return s -> List.of();    }     static Regla contiene(String clase, String nombre) {        // TODO: el texto debe tener algún carácter de la clase [clase]; si no, «falta nombre»        return s -> List.of();    }     static Regla noContiene(String palabra) {        // TODO: sin distinguir mayúsculas; si la contiene, «no puede contener «palabra»»        return s -> 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;            // TODO: validar la línea; si es correcta, acumular unidades × precio en el producto        }        // TODO: mostrar el resumen ordenado por importe (de mayor a menor)    }}

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) {        // TODO        return new ArrayList<>();    }     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"));        for (String t : tareas) {            if (t.startsWith("x ")) {                tareas.remove(t);            }        }        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.put(p, 1);        }        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) {        // TODO        return new ArrayList<>();    }     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) {        // TODO: búsqueda en anchura        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.io.*;import java.util.*; public class Main {     static double leerMedia(File fichero) throws IOException {        double suma = 0;        int contador = 0;        // TODO: lee el fichero línea a línea y acumula las notas         return contador == 0 ? 0 : suma / contador;    }     public static void main(String[] args) throws IOException {        // Guarda en notas.csv las líneas recibidas por teclado        File fichero = new File("notas.csv");        Scanner sc = new Scanner(System.in);        try (PrintWriter pw = new PrintWriter(new FileWriter(fichero))) {            while (sc.hasNextLine()) pw.println(sc.nextLine());        }         System.out.printf(Locale.US, "Media: %.2f%n", leerMedia(fichero));    }}

import java.io.*;import java.util.*; public class Main {     static class Producto implements Serializable {        private static final long serialVersionUID = 1L;        String nombre;        double precio;        Producto(String nombre, double precio) { this.nombre = nombre; this.precio = precio; }    }     static void guardar(List<Producto> productos, File fichero) throws IOException {        // TODO: escribe la lista en el fichero    }     @SuppressWarnings("unchecked")    static List<Producto> cargar(File fichero) throws IOException, ClassNotFoundException {        // TODO: lee la lista desde el fichero        return new ArrayList<>();    }     public static void main(String[] args) throws Exception {        List<Producto> productos = new ArrayList<>();        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().split(";");            if (p.length == 2) productos.add(new Producto(p[0], Double.parseDouble(p[1])));        }         File fichero = new File("productos.obj");        guardar(productos, fichero);        List<Producto> leidos = cargar(fichero);         double total = 0;        for (Producto p : leidos) total += p.precio;        System.out.printf(Locale.US, "%d productos, total %.2f%n", leidos.size(), total);    }}

import java.io.*;import java.nio.file.*;import javax.xml.parsers.*;import org.w3c.dom.*; public class Main {     static void procesar(File fichero) throws Exception {        int total = 0, disponibles = 0;        // TODO: carga el XML con DOM y cuenta los libros         System.out.println("Libros: " + total + ", disponibles: " + disponibles);    }     public static void main(String[] args) throws Exception {        File fichero = new File("biblioteca.xml");        Files.write(fichero.toPath(), System.in.readAllBytes());        procesar(fichero);    }}

import java.io.*;import java.util.*; public class Main {    static final int TAM = 4 + 20 + 8; // id + nombre(10 chars) + salario     static void escribir(RandomAccessFile raf, int id, String nombre, double salario) throws IOException {        raf.writeInt(id);        StringBuilder sb = new StringBuilder(nombre);        sb.setLength(10); // rellena o recorta a 10 caracteres        raf.writeChars(sb.toString());        raf.writeDouble(salario);    }     static String leerRegistro(RandomAccessFile raf, int n) throws IOException {        // TODO: sitúate en el registro n y lee sus tres campos        return "";    }     public static void main(String[] args) throws IOException {        try (RandomAccessFile raf = new RandomAccessFile("empleados.dat", "rw")) {            raf.setLength(0);            escribir(raf, 1, "Ana", 1850.5);            escribir(raf, 2, "Luis", 2100);            escribir(raf, 3, "Marta", 2475.25);            escribir(raf, 4, "Jorge", 1990);             int n = new Scanner(System.in).nextInt();            System.out.println(leerRegistro(raf, n));        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in).useDelimiter("\\A");        String texto = sc.hasNext() ? sc.next().replace("\r", "") : "";        List<List<String>> registros = new ArrayList<>();        // TODO: analizar el CSV carácter a carácter (separador ; y comillas dobles)    }}

import java.nio.*;import java.util.*;import java.util.zip.CRC32; public class Main {    static byte[] desdeHex(String h) {        byte[] b = new byte[h.length() / 2];        for (int i = 0; i < b.length; i++) b[i] = (byte) Integer.parseInt(h.substring(2 * i, 2 * i + 2), 16);        return b;    }     public static void main(String[] args) {        byte[] datos = desdeHex(new Scanner(System.in).nextLine().trim());        ByteBuffer buf = ByteBuffer.wrap(datos);          // big-endian, como DataInputStream        // TODO: leer cabecera, registros y CRC    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String plantilla = sc.nextLine();        List<String[]> params = new ArrayList<>();          // {tipo, valor}        while (sc.hasNextLine()) {            String l = sc.nextLine();            if (l.isBlank()) continue;            int dos = l.indexOf(':');            params.add(new String[] { l.substring(0, dos), l.substring(dos + 1) });        }        // TODO: localizar los ? fuera de los literales y montar las dos versiones    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String[] conf = sc.nextLine().trim().split(" ");     // «max M espera W»        int max = Integer.parseInt(conf[1]), espera = Integer.parseInt(conf[3]);        List<String[]> eventos = new ArrayList<>();           // {tiempo, accion, cliente}        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (!l.isEmpty()) eventos.add(l.split(" "));        }        // TODO: simular el pool (conexiones libres, en uso, cola de espera y tiempos límite)    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Integer> confirmado = new LinkedHashMap<>();   // lo que ve cualquiera        for (String par : sc.nextLine().trim().split(" ")) {            if (!par.contains("=")) continue;                     // «cuentas A1=100 A2=50 …»            String[] kv = par.split("=");            confirmado.put(kv[0], Integer.parseInt(kv[1]));        }        // Por sesión: cambios pendientes (null si no hay transacción) y puntos de guardado        Map<String, Map<String, Integer>> pendientes = new HashMap<>();        Map<String, LinkedHashMap<String, Map<String, Integer>>> puntos = new HashMap<>();        // TODO: procesar las órdenes de las sesiones A y B    }}

import java.util.*; public class Main {    record Autor(int id, String nombre) { }    record Libro(int id, int autorId, String titulo) { }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<Autor> autores = new ArrayList<>();        List<Libro> libros = new ArrayList<>();        String estrategia = "LAZY";        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.startsWith("autor ")) {                String[] p = l.split(" ", 3);                autores.add(new Autor(Integer.parseInt(p[1]), p[2]));            } else if (l.startsWith("libro ")) {                String[] p = l.split(" ", 4);                libros.add(new Libro(Integer.parseInt(p[1]), Integer.parseInt(p[2]), p[3]));            } else if (l.startsWith("estrategia ")) {                estrategia = l.substring(11).trim();            }        }        autores.sort(Comparator.comparingInt(Autor::id));        libros.sort(Comparator.comparingInt(Libro::id));        // TODO: simular «SELECT a FROM Autor a» y el acceso a a.getLibros() de cada autor    }}

import java.util.*; public class Main {    static class Entidad {        Long id;        String tabla;        Map<String, String> campos = new LinkedHashMap<>();        String estado = "NUEVA";                   // NUEVA, GESTIONADA, SEPARADA, ELIMINADA        Map<String, String> instantanea;           // copia al pasar a gestionada o tras el último flush    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Entidad> variables = new HashMap<>();        Map<Long, Map<String, String>> baseDatos = new TreeMap<>();        List<Entidad> contexto = new ArrayList<>();    // contexto de persistencia (en orden de entrada)        long[] siguienteId = { 1 };        while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            if (linea.isEmpty()) continue;            String[] p = linea.split(" ", 3);            // TODO: new, persist, set, find, detach, merge, remove, flush, commit, close y estado        }    }}

import java.util.*; public class Main {    static String json(List<String> valores) {        List<String> partes = new ArrayList<>();        for (String v : valores)            partes.add(v == null ? "null" : "\"" + v.replace("\\", "\\\\").replace("\"", "\\\"") + "\"");        return "[" + String.join(", ", partes) + "]";    }     static List<String> leerArray(String texto) {        // TODO: elementos separados por comas, comillas con escapes y NULL        return new ArrayList<>();    }     static List<String> leerCompuesto(String texto) {        // TODO: campos separados por comas, vacío = nulo y comillas dobladas        return new ArrayList<>();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String l = sc.nextLine();            if (l.isBlank()) continue;            String tipo = l.substring(0, l.indexOf(' ')), texto = l.substring(l.indexOf(' ') + 1).trim();            List<String> v = tipo.equals("array") ? leerArray(texto) : leerCompuesto(texto);            System.out.println(tipo + " " + json(v) + " · " + v.size() + (v.size() == 1 ? " valor" : " valores")                + " · nulos: " + v.stream().filter(Objects::isNull).count());        }    }}

import java.util.*; public class Main {    static class Objeto {        String id, clase;        Map<String, String> datos = new LinkedHashMap<>();       // campos simples        Map<String, String> referencias = new LinkedHashMap<>(); // campo → id del objeto apuntado    }     static Map<String, Objeto> almacen = new LinkedHashMap<>();    static Set<String> activados = new HashSet<>();     static void activar(String id, int profundidad, String sangria, String prefijo) {        // TODO: mostrar el objeto y activar sus referencias con profundidad - 1    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            if (p[0].equals("objeto")) {                     // objeto ID Clase campo=valor ref=@ID …                Objeto o = new Objeto();                o.id = p[1]; o.clase = p[2];                for (int i = 3; i < p.length; i++) {                    String[] kv = p[i].split("=");                    if (kv[1].startsWith("@")) o.referencias.put(kv[0], kv[1].substring(1));                    else o.datos.put(kv[0], kv[1]);                }                almacen.put(o.id, o);            } else if (p[0].equals("activar")) {           // activar ID profundidad                activados.clear();                System.out.println("== activar " + p[1] + " con profundidad " + p[2]);                activar(p[1], Integer.parseInt(p[2]), "", "");                System.out.println("Objetos leídos del disco: " + activados.size());            }        }    }}

import java.util.*; public class Main {    static class Tabla {        String nombre, padre, unico;        List<String> columnas = new ArrayList<>();        List<Map<String, String>> filas = new ArrayList<>();        List<String> hijas = new ArrayList<>();    }     static Map<String, Tabla> tablas = new LinkedHashMap<>();     // TODO: static void recoger(Tabla consultada, Tabla t, boolean solo, List<String> salida)     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) continue;            String[] p = l.split(" ");            // TODO: tabla, insertar, consultar y consultar solo        }    }}

import java.beans.*;import java.io.Serializable;import java.util.Scanner; public class Main {     public static class Termostato implements Serializable {        private final PropertyChangeSupport soporte = new PropertyChangeSupport(this);        private int temperatura = 20;         public Termostato() {}         public int getTemperatura() { return temperatura; }         public void setTemperatura(int nueva) {            // TODO: asigna el nuevo valor y avisa a los oyentes del cambio            temperatura = nueva;        }         public void addPropertyChangeListener(PropertyChangeListener l) { soporte.addPropertyChangeListener(l); }        public void removePropertyChangeListener(PropertyChangeListener l) { soporte.removePropertyChangeListener(l); }    }     public static void main(String[] args) {        Termostato t = new Termostato();        t.addPropertyChangeListener(e ->            System.out.println(e.getPropertyName() + ": " + e.getOldValue() + " -> " + e.getNewValue()));         Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) t.setTemperatura(sc.nextInt());        System.out.println("Final: " + t.getTemperatura());    }}

import java.beans.*;import java.util.Scanner; public class Main {     public static class CuentaBancaria {        private final VetoableChangeSupport vetos = new VetoableChangeSupport(this);        private double saldo = 100;         public double getSaldo() { return saldo; }         public void setSaldo(double nuevo) throws PropertyVetoException {            // TODO: pregunta a los oyentes y, si nadie veta, cambia el saldo            saldo = nuevo;        }         public void addVetoableChangeListener(VetoableChangeListener l) { vetos.addVetoableChangeListener(l); }    }     public static void main(String[] args) {        CuentaBancaria cuenta = new CuentaBancaria();        cuenta.addVetoableChangeListener(e -> {            if ((double) e.getNewValue() < 0) throw new PropertyVetoException("saldo negativo", e);        });         Scanner sc = new Scanner(System.in);        while (sc.hasNextInt()) {            int movimiento = sc.nextInt();            try {                cuenta.setSaldo(cuenta.getSaldo() + movimiento);                System.out.println("OK " + movimiento + " -> " + cuenta.getSaldo());            } catch (PropertyVetoException ex) {                System.out.println("Vetado " + movimiento + ": " + ex.getMessage());            }        }    }}

import java.beans.*;import java.io.*;import java.util.Scanner; public class Main {     public static class Configuracion {        private String tema = "claro";        private int tamanoLetra = 14;         public Configuracion() {}        public String getTema() { return tema; }        public void setTema(String tema) { this.tema = tema; }        public int getTamanoLetra() { return tamanoLetra; }        public void setTamanoLetra(int t) { this.tamanoLetra = t; }    }     static void guardar(Configuracion c, File fichero) throws IOException {        // TODO: guarda el bean en XML con XMLEncoder    }     static Configuracion cargar(File fichero) throws IOException {        // TODO: recupera el bean con XMLDecoder        return new Configuracion();    }     public static void main(String[] args) throws IOException {        Scanner sc = new Scanner(System.in);        Configuracion c = new Configuracion();        c.setTema(sc.next());        c.setTamanoLetra(sc.nextInt());         File f = new File("config.xml");        guardar(c, f);        Configuracion leida = cargar(f);        System.out.println(leida.getTema() + " " + leida.getTamanoLetra());        System.out.println("XML generado: " + (f.length() > 0));    }}

import java.util.*; public class Main {     public interface DaoListener { void datosCambiados(String accion, String nombre); }     public interface AlumnoDao {        void guardar(String nombre, double nota);        boolean borrar(String nombre);        Map<String, Double> listar();        void addDaoListener(DaoListener l);    }     public static class AlumnoDaoMemoria implements AlumnoDao {        private final Map<String, Double> alumnos = new TreeMap<>();        private final List<DaoListener> oyentes = new ArrayList<>();         public void guardar(String nombre, double nota) {            // TODO: guarda y avisa a los oyentes        }         public boolean borrar(String nombre) {            // TODO: borra y avisa a los oyentes si existía            return false;        }         public Map<String, Double> listar() { return Collections.unmodifiableMap(alumnos); }         public void addDaoListener(DaoListener l) { oyentes.add(l); }    }     public static void main(String[] args) {        AlumnoDao dao = new AlumnoDaoMemoria();        dao.addDaoListener((accion, nombre) -> System.out.println("[evento] " + accion + " " + nombre));         Scanner sc = new Scanner(System.in);        while (sc.hasNext()) {            String orden = sc.next();            switch (orden) {                case "G" -> dao.guardar(sc.next(), Double.parseDouble(sc.next()));                case "B" -> { String n = sc.next(); if (!dao.borrar(n)) System.out.println("No existe " + n); }                case "L" -> dao.listar().forEach((n, nota) -> System.out.println(n + " " + nota));                default -> System.out.println("Orden desconocida");            }        }    }}

import java.util.*; public class Main {    static Map<String, List<String>> dependencias = new LinkedHashMap<>();    static Map<String, String> ambitos = new HashMap<>();    static Map<String, Integer> singletons = new HashMap<>();   // componente → número de instancia    static List<String> creados = new ArrayList<>();            // singletons en orden de creación (para cerrar)    static int contador = 0;     // TODO: static String validar(String nombre, List<String> camino, String quien)    //       static int resolver(String nombre)     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            switch (p[0]) {                case "componente" -> {                      // componente N [depende=A,B] [ambito=prototype]                    List<String> deps = new ArrayList<>();                    String ambito = "singleton";                    for (int i = 2; i < p.length; i++) {                        if (p[i].startsWith("depende=")) deps.addAll(List.of(p[i].substring(8).split(",")));                        if (p[i].startsWith("ambito=")) ambito = p[i].substring(7);                    }                    dependencias.put(p[1], deps);                    ambitos.put(p[1], ambito);                }                case "obtener" -> {                    System.out.println("obtener " + p[1]);                    // TODO: validar y, si no hay error, resolver                }                case "cerrar" -> {                    // TODO: destruir los singletons en orden inverso al de creación                    System.out.println("Contenedor cerrado");                }            }        }    }}

import java.io.*;import java.nio.file.*;import java.util.*; public class Main {     static int filtrar(Path origen, Path destino) throws IOException {        // TODO: copia a destino las líneas de origen que contienen "ERROR"        return 0;    }     public static void main(String[] args) throws IOException {        Path log = Path.of("app.log");        Files.write(log, new String(System.in.readAllBytes()).lines().toList());         Path errores = Path.of("errores.log");        int n = filtrar(log, errores);        System.out.println("Errores: " + n);        if (Files.exists(errores)) Files.readAllLines(errores).forEach(System.out::println);    }}

import java.io.*;import java.nio.file.*;import java.util.*; public class Main {     static String convertir(Path csv) throws IOException {        List<String> lineas = Files.readAllLines(csv);        String[] cabecera = lineas.get(0).split(";");        List<String> objetos = new ArrayList<>();        // TODO: recorre las líneas de datos y construye un objeto JSON por línea         return "[" + String.join(",", objetos) + "]";    }     public static void main(String[] args) throws IOException {        Path csv = Path.of("personas.csv");        Files.write(csv, new String(System.in.readAllBytes()).lines().toList());        System.out.println(convertir(csv));    }}

import java.io.*;import java.nio.file.*;import java.util.*;import javax.xml.parsers.*;import org.w3c.dom.*; public class Main {     static Map<String, Double> medias(File fichero) throws Exception {        Map<String, Double> resultado = new TreeMap<>();        // TODO: calcula el precio medio de cada categoría         return resultado;    }     public static void main(String[] args) throws Exception {        File f = new File("catalogo.xml");        Files.write(f.toPath(), System.in.readAllBytes());        medias(f).forEach((cat, media) -> System.out.printf(Locale.US, "%s %.2f%n", cat, media));    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, String> campos = new LinkedHashMap<>();        while (sc.hasNextLine()) {            String linea = sc.nextLine();            int i = linea.indexOf('=');            if (i > 0) campos.put(linea.substring(0, i).trim(), linea.substring(i + 1).trim());        }        // TODO: valida cada campo y muestra los errores como lo haría el formulario    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int ancho = Integer.parseInt(sc.nextLine().split(" ")[1]);        int hueco = Integer.parseInt(sc.nextLine().split(" ")[1]);        List<String[]> columnas = new ArrayList<>();   // {nombre, tipo, valor}        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (!l.isEmpty()) columnas.add(l.split(" "));        }        // TODO: calcula la posición y el ancho de cada columna como un GridPane    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, String> padre = new HashMap<>();        List<String[]> manejadores = new ArrayList<>();   // {tipo (filtro|manejador), nodo, consume?}        String objetivo = null;        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            switch (p[0]) {                case "nodo" -> padre.put(p[1], p[2]);          // nodo HIJO PADRE                case "filtro", "manejador" -> manejadores.add(p);                case "clic" -> objetivo = p[1];                default -> { }            }        }        // TODO: simula la cadena de despacho del evento (captura y burbuja)    }}

import java.text.Normalizer;import java.util.*;import java.util.regex.*; public class Main {    static String normalizar(String s) {        String sinTildes = Normalizer.normalize(s.toLowerCase(), Normalizer.Form.NFD).replaceAll("\\p{M}", "");        return sinTildes.replaceAll("[^a-z0-9: ]", " ").replaceAll("\\s+", " ").trim();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String frase = sc.nextLine();            if (frase.isBlank()) continue;            String t = normalizar(frase);            // TODO: reconoce la intención y sus datos        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<List<double[]>> gestos = new ArrayList<>();        List<double[]> actual = new ArrayList<>();        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) { if (!actual.isEmpty()) { gestos.add(actual); actual = new ArrayList<>(); } continue; }            String[] p = l.split(" ");               // tiempo_ms x y            actual.add(new double[]{Double.parseDouble(p[0]), Double.parseDouble(p[1]), Double.parseDouble(p[2])});        }        if (!actual.isEmpty()) gestos.add(actual);        // TODO: clasifica cada gesto (toque, pulsación larga, deslizamiento o arrastre)    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<Map<String, double[]>> manos = new ArrayList<>();        Map<String, double[]> actual = new LinkedHashMap<>();        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.equals("---")) { manos.add(actual); actual = new LinkedHashMap<>(); continue; }            if (l.isEmpty()) continue;            String[] p = l.split(" ");                 // punto x y  (coordenadas normalizadas de 0 a 1)            actual.put(p[0], new double[]{Double.parseDouble(p[1]), Double.parseDouble(p[2])});        }        if (!actual.isEmpty()) manos.add(actual);        String[] DEDOS = {"pulgar", "indice", "corazon", "anular", "menique"};        // TODO: decide qué dedos están extendidos y qué gesto hace cada mano    }}

import java.util.*; public class Main {    // TODO: completa el componente de valoración    static class Valoracion {        private double valor = 0;         void setValor(double v) { }        void clic(int estrella) { }        String pintar() { return ""; }    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Valoracion v = new Valoracion();        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            if (p[0].equals("set")) v.setValor(Double.parseDouble(p[1]));            else if (p[0].equals("clic")) v.clic(Integer.parseInt(p[1]));            else continue;            System.out.println(v.pintar());        }    }}

import java.util.*;import java.util.function.*; public class Main {    // TODO: implementa una propiedad observable con listeners y enlace (bind) como las de JavaFX    static class Propiedad {        final String nombre;        Propiedad(String nombre) { this.nombre = nombre; }        int get() { return 0; }        void set(int v) { }        void escuchar() { }        void bind(Propiedad otra) { }        void unbind() { }    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, Propiedad> props = new LinkedHashMap<>();        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            if (p.length < 2) continue;            Propiedad a = props.computeIfAbsent(p[1], Propiedad::new);            switch (p[0]) {                case "set" -> a.set(Integer.parseInt(p[2]));                case "escuchar" -> a.escuchar();                case "bind" -> a.bind(props.computeIfAbsent(p[2], Propiedad::new));                case "unbind" -> a.unbind();                case "get" -> System.out.println(a.nombre + " = " + a.get());            }        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String mascara = sc.nextLine().substring("mascara ".length());   // # dígito, A letra, ? cualquiera; lo demás es literal        List<String> teclas = new ArrayList<>(Arrays.asList(sc.nextLine().split(" ")));        // TODO: simula un campo de texto con máscara pulsando las teclas en orden    }}

import java.util.*; public class Main {    // TODO: luminancia relativa y contraste según WCAG    static double contraste(String a, String b) { return 0; }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            if (p.length < 2) continue;            double r = contraste(p[0], p[1]);            // TODO: muestra el contraste y si cumple AA y AAA para texto normal y grande        }    }}

import java.util.*; public class Main {    record Control(String id, int x, int y, int tabIndex, boolean habilitado) { }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<Control> controles = new ArrayList<>();        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");   // id x y tabindex habilitado(si|no)            if (p.length < 5) continue;            controles.add(new Control(p[0], Integer.parseInt(p[1]), Integer.parseInt(p[2]), Integer.parseInt(p[3]), p[4].equals("si")));        }        // TODO: calcula el orden en que recibe el foco cada control al pulsar Tab    }}

import java.text.Normalizer;import java.util.*; public class Main {    static final String VOCALES = "aeiouáéíóúü";    static final String FUERTES = "aeoáéíóú";   // las débiles i, u sin tilde forman diptongo     // TODO: cuenta las sílabas de una palabra en castellano    static int silabas(String palabra) { return 0; }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        StringBuilder todo = new StringBuilder();        while (sc.hasNextLine()) todo.append(sc.nextLine()).append(' ');        String texto = todo.toString().trim();        // TODO: calcula el índice de legibilidad de Fernández Huerta    }}

import java.util.*;import java.util.regex.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String version = sc.nextLine().split(" ")[1];        // versión actual, p. ej. 1.4.2        List<String> commits = new ArrayList<>();        while (sc.hasNextLine()) { String l = sc.nextLine().trim(); if (!l.isEmpty()) commits.add(l); }        // TODO: calcula la nueva versión semántica y genera el CHANGELOG    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> lineas = new ArrayList<>();        while (sc.hasNextLine()) lineas.add(sc.nextLine());        // TODO: extrae los comentarios Javadoc de los métodos públicos y genera la documentación en Markdown    }}

import java.util.*;import java.util.regex.*;import java.text.Normalizer; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> lineas = new ArrayList<>();        while (sc.hasNextLine()) lineas.add(sc.nextLine());        // TODO: revisa el manual y muestra los problemas encontrados    }}

import java.util.*; public class Main {    // TODO: compara dos versiones semánticas (negativo si a < b, 0 si iguales, positivo si a > b)    static int comparar(String a, String b) { return 0; }     // TODO: ¿cumple la versión el rango? (^X.Y.Z, ~X.Y.Z o una versión exacta)    static boolean cumple(String version, String rango) { return false; }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<String> versiones = new ArrayList<>(Arrays.asList(sc.nextLine().trim().split(" ")));        versiones.sort(Main::comparar);        System.out.println("Ordenadas: " + String.join(" < ", versiones));        while (sc.hasNextLine()) {            String rango = sc.nextLine().trim();            if (rango.isEmpty()) continue;            String mejor = null;            for (String v : versiones) if (cumple(v, rango) && !v.contains("-")) mejor = v;   // la más alta estable            System.out.println(rango + " → " + (mejor == null ? "ninguna" : mejor));        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String[] proyecto = sc.nextLine().trim().split(" ");     // proyecto LICENCIA (MIT, Apache-2.0, GPL-3.0, Propietaria)        String licProyecto = proyecto[1];        List<String[]> deps = new ArrayList<>();                 // nombre licencia enlace(estatico|dinamico)        while (sc.hasNextLine()) { String l = sc.nextLine().trim(); if (!l.isEmpty()) deps.add(l.split(" ")); }        // TODO: revisa si cada dependencia es compatible con la licencia del proyecto    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, String> conf = new HashMap<>();        Map<String, String[]> local = new TreeMap<>(), remoto = new TreeMap<>();   // ruta → {tamaño, hash}        Map<String, String[]> actual = null;        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) continue;            if (l.equals("[local]")) { actual = local; continue; }            if (l.equals("[remoto]")) { actual = remoto; continue; }            String[] p = l.split(" ");            if (actual == null) conf.put(p[0], p[1]);              // version_instalada, version_nueva, minima, porcentaje, usuario            else actual.put(p[0], new String[]{p[1], p[2]});        }        // TODO: decide si este usuario recibe la actualización y qué ficheros descargar o borrar    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");     // campo tipo min max            if (p.length < 4) continue;            String campo = p[0], tipo = p[1];            int min = Integer.parseInt(p[2]), max = Integer.parseInt(p[3]);            // TODO: genera los casos de prueba por valores límite y clases de equivalencia        }    }}

import java.util.*; public class Main {    // TODO: implementa precioFinal según la especificación del enunciado    static double precioFinal(double importe, String codigo, boolean socio) {        return importe;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // Cada línea: nombre_prueba importe codigo(o -) socio(si|no) esperado        // TODO: ejecuta cada caso, compara con el esperado (tolerancia 0.005) y muestra el informe    }}

import java.util.*; public class Main {    // Modelo de una pantalla de acceso: campos usuario y clave, botón entrar y un mensaje    static class PantallaAcceso {        String usuario = "", clave = "", mensaje = "";        boolean entrarHabilitado = false, dentro = false;        int intentos = 0;        static final Map<String, String> CUENTAS = Map.of("ana", "Segura123", "luis", "Clave2026");         // TODO: escribir en un campo, pulsar el botón y actualizar el estado según las reglas        void escribir(String campo, String texto) { }        void pulsarEntrar() { }    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // TODO: ejecuta el guion de prueba paso a paso y comprueba cada «espera»    }}

import java.util.*; public class Main {    static final String LETRAS = "TRWAGMYFPDXBNJZSQVHLCKE";     static boolean nifValido(String nif) {        // TODO        return false;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String l = sc.nextLine();            if (!l.isBlank()) System.out.println(nifValido(l) ? "válido" : "no válido");        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // TODO: lee las líneas categoría;importe y muestra el informe    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int tam = sc.nextInt(), pagina = sc.nextInt();        sc.nextLine();        List<String> elementos = new ArrayList<>();        while (sc.hasNextLine()) {            String l = sc.nextLine();            if (!l.isBlank()) elementos.add(l);        }        // TODO    }}

import java.util.*; public class Main {     static int comparar(String a, String b) {        // TODO: negativo si a < b, 0 si son iguales, positivo si a > b        return a.compareTo(b);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNext()) {            int c = comparar(sc.next(), sc.next());            System.out.println(c < 0 ? "<" : c > 0 ? ">" : "=");        }    }}

import java.util.*; public class Main {    static final String[] NOMBRES = {"ldpi", "mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"};    static final int[] DPI = {120, 160, 240, 320, 480, 640};     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");      // nombre anchoPx altoPx pulgadas            if (p.length < 4) continue;            // TODO: calcula densidad, tamaño en dp y carpeta de recursos        }    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // Estados: NINGUNO, CREADA, INICIADA, REANUDADA, PAUSADA, DETENIDA, DESTRUIDA        // TODO: simula el ciclo de vida de una Activity ante cada evento    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        TreeMap<Integer, Double> cuota = new TreeMap<>();            // nivel de API → % de dispositivos activos        List<String[]> apis = new ArrayList<>();                    // nombre nivelMinimo        int minSdk = 0;        double objetivo = 0;        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            switch (p[0]) {                case "cuota" -> cuota.put(Integer.parseInt(p[1]), Double.parseDouble(p[2]));                case "api" -> apis.add(new String[]{p[1], p[2]});                case "minSdk" -> minSdk = Integer.parseInt(p[1]);                case "objetivo" -> objetivo = Double.parseDouble(p[1]);                default -> { }            }        }        // TODO: cobertura del minSdk, minSdk recomendado y comprobaciones de versión necesarias    }}

import java.util.*; public class Main {    record Elemento(String id, String contenido) { }     static List<Elemento> leer(String linea) {        List<Elemento> l = new ArrayList<>();        if (linea.isBlank()) return l;        for (String par : linea.trim().split(" ")) {            String[] p = par.split(":");            l.add(new Elemento(p[0], p[1]));        }        return l;    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        List<Elemento> antes = leer(sc.nextLine()), despues = leer(sc.hasNextLine() ? sc.nextLine() : "");        // TODO: calcula los cambios entre las dos listas como DiffUtil    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Deque<String> pila = new ArrayDeque<>();      // la cima es la pantalla visible        pila.push(sc.nextLine().trim().split(" ")[1]);  // inicio DESTINO        // TODO: procesa navigate y back como el componente Navigation    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        Map<String, String[]> servidor = new TreeMap<>(), local = new TreeMap<>();   // id → {valor, marca de tiempo}        List<String[]> pendientes = new ArrayList<>();                            // cambios hechos sin conexión        String seccion = "";        while (sc.hasNextLine()) {            String l = sc.nextLine().trim();            if (l.isEmpty()) continue;            if (l.startsWith("[")) { seccion = l; continue; }            String[] p = l.split(" ");            switch (seccion) {                case "[servidor]" -> servidor.put(p[0], new String[]{p[1], p[2]});                case "[base]" -> local.put(p[0], new String[]{p[1], p[2]});                case "[cambios]" -> pendientes.add(p);              // op id valor tiempo  (op: crear, editar, borrar)                default -> { }            }        }        // TODO: aplica los cambios pendientes al servidor resolviendo conflictos y muestra el resultado    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int paso = Integer.parseInt(sc.nextLine().trim().split(" ")[1]);              // «paso 20» (ms)        double velocidad = Double.parseDouble(sc.nextLine().trim().split(" ")[1]);   // «velocidad 120» (px/s)        String[] deltas = sc.nextLine().trim().split(" ");                            // ms de cada fotograma        final int MAXIMO = 250;                                                       // evita la «espiral de la muerte»        double x = 0, xAnterior = 0;        int acumulado = 0, totalPasos = 0;        // TODO: bucle con paso fijo, acumulador e interpolación    }}

import java.util.*; public class Main {    record Caja(String nombre, int x, int y, int ancho, int alto) { }     static boolean chocan(Caja a, Caja b) {        return a.x() < b.x() + b.ancho() && a.x() + a.ancho() > b.x()            && a.y() < b.y() + b.alto() && a.y() + a.alto() > b.y();    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int celda = Integer.parseInt(sc.nextLine().trim().split(" ")[1]);   // «celda 64»        List<Caja> cajas = new ArrayList<>();        while (sc.hasNextLine()) {            String[] p = sc.nextLine().trim().split(" ");            if (p.length < 5) continue;            cajas.add(new Caja(p[0], Integer.parseInt(p[1]), Integer.parseInt(p[2]), Integer.parseInt(p[3]), Integer.parseInt(p[4])));        }        // TODO: fuerza bruta frente a rejilla espacial    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        String[] m = sc.nextLine().trim().split(" ");                     // «pared x y ancho alto»        double px = Double.parseDouble(m[1]), py = Double.parseDouble(m[2]);        double pw = Double.parseDouble(m[3]), ph = Double.parseDouble(m[4]);        int fps = Integer.parseInt(sc.nextLine().trim().split(" ")[1]);   // «fps 60»        int tuneles = 0, balas = 0;        while (sc.hasNextLine()) {            String[] b = sc.nextLine().trim().split(" ");            if (b.length < 5) continue;            String nombre = b[0];            double x0 = Double.parseDouble(b[1]), y0 = Double.parseDouble(b[2]);            double vx = Double.parseDouble(b[3]), vy = Double.parseDouble(b[4]);            balas++;            // TODO: detección discreta frente a continua (barrido)        }        System.out.println("Efecto túnel: " + tuneles + " de " + balas + " balas");    }}

import java.util.*; public class Main {     static String resultado(char[][] t) {        // TODO        return "Sigue la partida";    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        char[][] t = new char[3][];        for (int i = 0; i < 3; i++) t[i] = sc.next().toCharArray();        System.out.println(resultado(t));    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int f = sc.nextInt(), c = sc.nextInt();        char[][] t = new char[f][];        for (int i = 0; i < f; i++) t[i] = sc.next().toCharArray();        // TODO: calcula y muestra la siguiente generación        for (char[] fila : t) System.out.println(new String(fila));    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int puntos = 0, vidas = 3, combo = 0, mejor = 0;        while (sc.hasNext()) {            String evento = sc.next();            // TODO        }        System.out.println("Puntos: " + puntos);        System.out.println("Vidas: " + vidas);        System.out.println("Mejor combo: " + mejor);    }}

import java.util.*; public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int f = sc.nextInt(), c = sc.nextInt();        char[][] m = new char[f][];        for (int i = 0; i < f; i++) m[i] = sc.next().toCharArray();        // TODO: BFS desde E hasta J        System.out.println("Sin camino");    }}

import java.io.*;import java.util.*; public class Main {    static boolean esPrimo(long n) {        if (n < 2) return false;        for (long d = 2; d * d <= n; d++) if (n % d == 0) return false;        return true;    }     static long contar(long desde, long hasta) {        long c = 0;        for (long i = desde; i <= hasta; i++) if (esPrimo(i)) c++;        return c;    }     public static void main(String[] args) throws Exception {        // Modo trabajador: el proceso hijo cuenta su tramo y escribe el resultado        if (args.length == 3 && args[0].equals("trabajador")) {            System.out.println(contar(Long.parseLong(args[1]), Long.parseLong(args[2])));            return;        }        Scanner sc = new Scanner(System.in);        long limite = sc.nextLong();        int procesos = sc.nextInt();        // TODO: repartir [1, limite] en tramos, lanzar un proceso hijo por tramo,        //       leer su resultado y mostrar el resumen    }}

import java.util.*; public class Main {    record Proceso(String id, int llegada, int rafaga) { }     // Devuelve la línea de tiempo: una letra (id) por unidad de tiempo, o '-' si la CPU está libre    static String fcfs(List<Proceso> ps) {        // TODO: el primero que llega se ejecuta entero        return "";    }     static String sjf(List<Proceso> ps) {        // TODO: no expropiativo; de los que han llegado, el de ráfaga más corta        return "";    }     static String roundRobin(List<Proceso> ps, int quantum) {        // TODO: turnos de como mucho quantum unidades        return "";    }     // Calcula y muestra los tiempos de espera a partir de la línea de tiempo    static void informe(String nombre, String linea, List<Proceso> ps) {        StringBuilder sb = new StringBuilder(nombre + ": " + linea + " |");        double suma = 0;        for (Proceso p : ps) {            int fin = linea.lastIndexOf(p.id().charAt(0)) + 1;            int espera = fin - p.llegada() - p.rafaga();            suma += espera;            sb.append(" ").append(p.id()).append("=").append(espera);        }        sb.append(String.format(Locale.US, " | media %.2f", suma / ps.size()));        System.out.println(sb);    }     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int quantum = sc.nextInt();        List<Proceso> ps = new ArrayList<>();        while (sc.hasNext()) ps.add(new Proceso(sc.next(), sc.nextInt(), sc.nextInt()));        informe("FCFS", fcfs(ps), ps);        informe("SJF ", sjf(ps), ps);        informe("RR  ", roundRobin(ps, quantum), ps);    }}

import java.util.*; public class Main {    public static void main(String[] args) throws InterruptedException {        Scanner sc = new Scanner(System.in);        int hilos = sc.nextInt();        List<Long> lista = new ArrayList<>();        while (sc.hasNextLong()) lista.add(sc.nextLong());        long[] datos = lista.stream().mapToLong(Long::longValue).toArray();         long[] parciales = new long[hilos];      // cada hilo escribe solo en su posición        // TODO: crear los hilos, repartir el array en bloques, arrancarlos y esperar a que terminen         long total = 0;        for (int i = 0; i < hilos; i++) {            System.out.println("Hilo " + i + ": " + parciales[i]);            total += parciales[i];        }        System.out.println("Total: " + total);    }}

import java.util.*; class BufferAcotado {    private final int[] datos;    private int inicio = 0, cantidad = 0;     BufferAcotado(int capacidad) {        datos = new int[capacidad];    }     // Espera mientras el búfer está lleno    public synchronized void poner(int v) throws InterruptedException {        // TODO    }     // Espera mientras el búfer está vacío    public synchronized int sacar() throws InterruptedException {        // TODO        return -1;    }} public class Main {    static final int FIN = -1;                    // «píldora venenosa»: avisa al consumidor de que no hay más     public static void main(String[] args) throws InterruptedException {        Scanner sc = new Scanner(System.in);        int capacidad = sc.nextInt(), productores = sc.nextInt(), porProductor = sc.nextInt();        BufferAcotado buffer = new BufferAcotado(capacidad);        int[] consumidosDe = new int[productores];        long[] suma = new long[1];         List<Thread> hilos = new ArrayList<>();        for (int p = 0; p < productores; p++) {            final int id = p;            hilos.add(new Thread(() -> {                try {                    // Cada valor codifica su productor: id * 1000 + número                    for (int k = 1; k <= porProductor; k++) buffer.poner(id * 1000 + k);                } catch (InterruptedException e) { Thread.currentThread().interrupt(); }            }));        }        Thread consumidor = new Thread(() -> {            try {                int v;                while ((v = buffer.sacar()) != FIN) {                    consumidosDe[v / 1000]++;                    suma[0] += v % 1000;                }            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }        });        consumidor.start();        for (Thread h : hilos) h.start();        for (Thread h : hilos) h.join();        buffer.poner(FIN);        consumidor.join();         for (int p = 0; p < productores; p++) System.out.println("Productor " + p + ": " + consumidosDe[p] + " elementos consumidos");        System.out.println("Suma de los números: " + suma[0]);    }}

import java.io.*;import java.net.*;import java.util.*; public class Main {    // Atiende a UN cliente: lee órdenes línea a línea y responde a cada una    static void atender(Socket cliente) throws IOException {        // TODO: leer cada línea, responder según el protocolo y terminar con ADIOS    }     public static void main(String[] args) throws Exception {        try (ServerSocket servidor = new ServerSocket(0)) {          // puerto libre cualquiera            Thread hiloServidor = new Thread(() -> {                try (Socket c = servidor.accept()) {                    atender(c);                } catch (IOException e) {                    System.out.println("Error del servidor: " + e.getMessage());                }            });            hiloServidor.start();             // Cliente: envía cada línea de la entrada y muestra la respuesta            Scanner sc = new Scanner(System.in);            try (Socket s = new Socket("localhost", servidor.getLocalPort());                 PrintWriter out = new PrintWriter(new OutputStreamWriter(s.getOutputStream(), "UTF-8"), true);                 BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream(), "UTF-8"))) {                while (sc.hasNextLine()) {                    String orden = sc.nextLine();                    out.println(orden);                    String r;                    try {                        r = in.readLine();                    } catch (IOException e) {                        r = null;                                      // el servidor cerró la conexión                    }                    System.out.println("> " + orden);                    System.out.println("< " + (r == null ? "(conexión cerrada)" : r));                    if (r == null || orden.equals("ADIOS")) break;                }            }            hiloServidor.join();        }    }}

import java.io.*;import java.net.*;import java.nio.charset.StandardCharsets;import java.util.*; public class Main {    static final int ESPERA_MS = 150, MAX_INTENTOS = 5;     // ---- Servidor (ya hecho): pierde paquetes a propósito para simular una red mala    static class Servidor extends Thread {        final DatagramSocket ds;        final List<String> recibidos = new ArrayList<>();        int paquetes = 0, duplicados = 0, ultimoSeq = 0;         Servidor() throws SocketException { ds = new DatagramSocket(0); }         public void run() {            byte[] buf = new byte[1024];            try {                while (true) {                    DatagramPacket p = new DatagramPacket(buf, buf.length);                    ds.receive(p);                    paquetes++;                    if (paquetes % 4 == 0) continue;                  // se pierde el paquete que llega                    String msg = new String(p.getData(), 0, p.getLength(), StandardCharsets.UTF_8);                    int seq = Integer.parseInt(msg.substring(0, msg.indexOf(':')));                    String datos = msg.substring(msg.indexOf(':') + 1);                    if (seq == ultimoSeq) duplicados++;                // ya lo teníamos: era una retransmisión                    else if (seq == ultimoSeq + 1) { ultimoSeq = seq; if (!datos.equals("FIN")) recibidos.add(datos); }                    if (paquetes % 3 == 0) continue;                  // se pierde el ACK de respuesta                    byte[] ack = ("ACK " + seq).getBytes(StandardCharsets.UTF_8);                    ds.send(new DatagramPacket(ack, ack.length, p.getSocketAddress()));                    if (datos.equals("FIN")) return;                }            } catch (IOException e) { }        }    }     // Envía un mensaje y espera su ACK; si no llega a tiempo, lo reenvía.    // Devuelve el número de intentos, o -1 si se agotan.    static int enviarFiable(DatagramSocket ds, SocketAddress destino, int seq, String texto) throws IOException {        // TODO        byte[] datos = (seq + ":" + texto).getBytes(StandardCharsets.UTF_8);        ds.send(new DatagramPacket(datos, datos.length, destino));        return 1;    }     public static void main(String[] args) throws Exception {        Servidor srv = new Servidor();        srv.start();        SocketAddress destino = new InetSocketAddress("localhost", srv.ds.getLocalPort());        Scanner sc = new Scanner(System.in);        List<String> mensajes = new ArrayList<>();        while (sc.hasNextLine()) { String l = sc.nextLine().trim(); if (!l.isEmpty()) mensajes.add(l); }        mensajes.add("FIN");        try (DatagramSocket ds = new DatagramSocket()) {            for (int i = 0; i < mensajes.size(); i++) {                int intentos = enviarFiable(ds, destino, i + 1, mensajes.get(i));                System.out.println("Mensaje " + (i + 1) + " «" + mensajes.get(i) + "»: "                        + (intentos < 0 ? "sin respuesta" : intentos + (intentos == 1 ? " intento" : " intentos")));            }        }        srv.join(2000);        srv.ds.close();        System.out.println("El servidor recibió en orden: " + String.join(" | ", srv.recibidos));        System.out.println("Retransmisiones duplicadas descartadas: " + srv.duplicados);    }}

import com.sun.net.httpserver.*;import java.io.*;import java.net.*;import java.net.http.*;import java.nio.charset.StandardCharsets;import java.util.*;import java.util.concurrent.*;import java.util.concurrent.atomic.AtomicInteger; public class Main {    static final Map<Integer, String> tareas = new ConcurrentSkipListMap<>();   // id → texto, ordenadas por id    static final AtomicInteger siguienteId = new AtomicInteger(1);     static void responder(HttpExchange ex, int estado, String cuerpo) throws IOException {        byte[] b = cuerpo.getBytes(StandardCharsets.UTF_8);        ex.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");        ex.sendResponseHeaders(estado, b.length == 0 ? -1 : b.length);        if (b.length > 0) ex.getResponseBody().write(b);        ex.close();    }     static String json(int id, String texto) {        return "{\"id\":" + id + ",\"texto\":\"" + texto.replace("\\", "\\\\").replace("\"", "\\\"") + "\"}";    }     // Atiende /tareas y /tareas/{id}    static void manejar(HttpExchange ex) throws IOException {        // TODO: GET /tareas, POST /tareas, GET /tareas/{id}, DELETE /tareas/{id} y los errores        responder(ex, 501, "");    }     public static void main(String[] args) throws Exception {        HttpServer srv = HttpServer.create(new InetSocketAddress("localhost", 0), 0);        srv.createContext("/tareas", Main::manejar);        srv.start();        String base = "http://localhost:" + srv.getAddress().getPort();         HttpClient cliente = HttpClient.newHttpClient();        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] t = sc.nextLine().trim().split(" ", 3);       // MÉTODO ruta [cuerpo]            HttpRequest.BodyPublisher cuerpo = t.length > 2                    ? HttpRequest.BodyPublishers.ofString(t[2]) : HttpRequest.BodyPublishers.noBody();            HttpRequest req = HttpRequest.newBuilder(URI.create(base + t[1])).method(t[0], cuerpo).build();            HttpResponse<String> r = cliente.send(req, HttpResponse.BodyHandlers.ofString());            System.out.println(t[0] + " " + t[1] + " → " + r.statusCode() + (r.body().isEmpty() ? "" : " " + r.body()));        }        srv.stop(0);    }}

import java.util.*; class CircuitBreaker {    enum Estado { CERRADO, ABIERTO, SEMIABIERTO }     private final int umbralFallos;       // fallos seguidos para abrir    private final int espera;             // instantes que permanece abierto    private Estado estado = Estado.CERRADO;    private int fallosSeguidos = 0;    private int abiertoDesde = 0;     CircuitBreaker(int umbralFallos, int espera) {        this.umbralFallos = umbralFallos;        this.espera = espera;    }     Estado estado() { return estado; }     // ¿Se puede llamar al servicio en el instante t? (puede pasar de ABIERTO a SEMIABIERTO)    boolean permitir(int t) {        // TODO        return true;    }     // Se informa del resultado de una llamada que se permitió    void registrar(boolean exito, int t) {        // TODO    }} public class Main {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        CircuitBreaker cb = new CircuitBreaker(sc.nextInt(), sc.nextInt());        String resultados = sc.next();               // una letra por instante: E = el servicio responde, F = falla        int llamadas = 0, rechazadas = 0;        for (int t = 0; t < resultados.length(); t++) {            String linea;            if (cb.permitir(t)) {                llamadas++;                boolean ok = resultados.charAt(t) == 'E';                cb.registrar(ok, t);                linea = (ok ? "llamada OK " : "llamada FALLA");            } else {                rechazadas++;                linea = "rechazada   ";            }            System.out.println("t=" + t + " " + linea + " → " + cb.estado());        }        System.out.println("Llamadas al servicio: " + llamadas + ", rechazadas sin llamar: " + rechazadas);    }}

import java.security.*;import java.security.spec.*;import java.util.*;import javax.crypto.*;import javax.crypto.spec.*; public class Main {    static final int ITERACIONES = 120_000;     // Deriva 32 bytes de la contraseña con PBKDF2-HMAC-SHA256    static byte[] derivar(String clave, byte[] sal, int iteraciones) throws GeneralSecurityException {        PBEKeySpec spec = new PBEKeySpec(clave.toCharArray(), sal, iteraciones, 256);        return SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(spec).getEncoded();    }     // Devuelve "pbkdf2$iteraciones$salBase64$hashBase64" con una sal aleatoria de 16 bytes    static String guardar(String clave) throws GeneralSecurityException {        // TODO        return clave;    }     // Comprueba una contraseña contra lo guardado, en tiempo constante    static boolean verificar(String clave, String guardado) throws GeneralSecurityException {        // TODO        return guardado.equals(clave);    }     public static void main(String[] args) throws Exception {        Scanner sc = new Scanner(System.in);        while (sc.hasNextLine()) {            String[] t = sc.nextLine().split(" ", 3);            switch (t[0]) {                case "VECTOR" -> {          // VECTOR salHex clave: resultado reproducible con 1000 iteraciones                    byte[] sal = HexFormat.of().parseHex(t[1]);                    System.out.println("Hash: " + HexFormat.of().formatHex(derivar(t[2], sal, 1000)));                }                case "PROBAR" -> {          // PROBAR claveGuardada claveIntroducida                    String g1 = guardar(t[1]), g2 = guardar(t[1]);                    String[] p = g1.split("\\
quot;);                    System.out.println("Formato: " + p.length + " partes, algoritmo " + p[0] + ", " + (p.length > 1 ? p[1] : "?") + " iteraciones, sal de "                            + Base64.getDecoder().decode(p.length > 2 ? p[2] : "").length + " bytes, hash de "                            + Base64.getDecoder().decode(p.length > 3 ? p[3] : "").length + " bytes");                    System.out.println("Dos guardados de la misma clave son distintos: " + !g1.equals(g2));                    System.out.println("La clave guardada no aparece en el texto: " + !g1.contains(t[1]));                    System.out.println("Verificar «" + t[2] + "»: " + verificar(t[2], g1));                }            }        }    }}

import java.nio.charset.StandardCharsets;import java.security.*;import java.util.*;import javax.crypto.*;import javax.crypto.spec.*; public class Main {    static final Base64.Encoder B64 = Base64.getUrlEncoder().withoutPadding();    static final Base64.Decoder D64 = Base64.getUrlDecoder();     static byte[] hmac(byte[] clave, String datos) throws GeneralSecurityException {        Mac mac = Mac.getInstance("HmacSHA256");        mac.init(new SecretKeySpec(clave, "HmacSHA256"));        return mac.doFinal(datos.getBytes(StandardCharsets.UTF_8));    }     // Token: base64url(cabecera) + "." + base64url(datos) + "." + base64url(HMAC de las dos primeras partes)    // La cabecera es {"alg":"HS256","typ":"JWT"} y los datos {"sub":"usuario","rol":"rol","exp":instante}    static String crear(byte[] clave, String usuario, String rol, long exp) throws GeneralSecurityException {        // TODO        return "";    }     // Devuelve "VÁLIDO usuario rol", o "INVÁLIDO: motivo" (formato, firma o caducado)    static String verificar(byte[] clave, String token, long ahora) throws GeneralSecurityException {        // TODO        return "VÁLIDO";    }     // Extrae un campo de un JSON plano y sencillo como el de los datos    static String campo(String json, String nombre) {        int i = json.indexOf("\"" + nombre + "\":");        if (i < 0) return null;        int ini = i + nombre.length() + 3;        if (json.charAt(ini) == '"') return json.substring(ini + 1, json.indexOf('"', ini + 1));        int fin = ini;        while (fin < json.length() && (Character.isDigit(json.charAt(fin)) || json.charAt(fin) == '-')) fin++;        return json.substring(ini, fin);    }     public static void main(String[] args) throws Exception {        byte[] clave = "clave-secreta-del-servidor-de-32b".getBytes(StandardCharsets.UTF_8);        byte[] otraClave = "otra-clave-que-no-es-la-buena-32".getBytes(StandardCharsets.UTF_8);        Scanner sc = new Scanner(System.in);        String usuario = sc.next(), rol = sc.next();        long exp = sc.nextLong();        String token = crear(clave, usuario, rol, exp);        System.out.println("Token: " + token);        while (sc.hasNext()) {            String prueba = sc.next();            long ahora = sc.nextLong();            String t = switch (prueba) {                case "normal" -> token;                case "otra-clave" -> crear(otraClave, usuario, rol, exp);                case "cambiar-rol" -> {               // el atacante edita los datos y deja la firma original                    String[] p = token.split("\\.");                    String datos = new String(D64.decode(p.length > 1 ? p[1] : ""), StandardCharsets.UTF_8).replace(rol, "admin");                    yield p[0] + "." + B64.encodeToString(datos.getBytes(StandardCharsets.UTF_8)) + "." + (p.length > 2 ? p[2] : "");                }                default -> "esto.no.es-un-token.valido";            };            System.out.println(prueba + " en t=" + ahora + ": " + verificar(clave, t, ahora));        }    }}

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 Locale ES = Locale.forLanguageTag("es-ES");    static final Map<String, Libro> libros = new HashMap<>();    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]);        }    }     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) {        // TODO    }     static void altaSocio(int numero, String nombre) {        // TODO    }     static void prestar(int dia, int numero, String isbn) {        // TODO: comprueba las condiciones en el orden del enunciado    }     static void devolver(int dia, int numero, String isbn) {        // TODO: retraso, multa y bloqueo    }     static void informe() {        // TODO    }     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 0; // TODO: diferencia de goles        }         int puntos() {            return 0; // TODO: 3 por victoria y 1 por empate        }    }     static final Locale ES = Locale.forLanguageTag("es-ES");    static final Map<String, Equipo> equipos = new LinkedHashMap<>();     public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int numLinea = 0;        while (sc.hasNextLine()) {            String linea = sc.nextLine();            numLinea++;            // TODO: ignora las líneas vacías, valida el resto y registra el resultado en los dos equipos        }        // TODO: ordena los equipos, imprime la tabla y las dos líneas finales    }     static boolean esValida(String[] partes) {        return false; // TODO    }     static Equipo equipo(String nombre) {        return equipos.computeIfAbsent(nombre, Equipo::new);    }     static void registrar(Equipo t, int aFavor, int enContra) {        // TODO    }     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"));        // TODO: una fila por equipo con el formato del enunciado    }}

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) {        // TODO        return -1;    }     /** Desglose en billetes de 50, 20 y 10 con el menor número de billetes: «3x50 1x20 1x10». */    static String desglose(long euros) {        // TODO        return "";    }     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];         while (sc.hasNextLine()) {            String linea = sc.nextLine().trim();            // TODO: PIN (3 intentos), SALDO, INGRESAR, RETIRAR y SALIR        }    }}