Nóminas de una plantilla con distintos contratos

1import java.util.ArrayList;
2import java.util.List;
3import java.util.Locale;
4import java.util.Scanner;
5
6interface Retribuible {
7    /** Bruto del mes, en céntimos. */
8    long bruto();
9
10    /** Retención de IRPF de la tabla simplificada de la empresa: un tipo según el tramo del bruto mensual. */
11    default long retencion() {
12        long b = bruto();
13        int centesimas = b <= 100000 ? 200 : b <= 200000 ? 1200 : b <= 300000 ? 1800 : 2400;
14        return Main.porcentaje(b, centesimas);
15    }
16
17    /** Cotización del trabajador a la Seguridad Social: un 6,5 % del bruto en este ejercicio. */
18    default long seguridadSocial() {
19        return Main.porcentaje(bruto(), 650);
20    }
21
22    default long neto() {
23        return bruto() - retencion() - seguridadSocial();
24    }
25}
26
27abstract class Empleado implements Retribuible {
28    private final String nombre;
29
30    Empleado(String nombre) { this.nombre = nombre; }
31
32    String getNombre() { return nombre; }
33
34    abstract String tipo();
35}
36
37class Asalariado extends Empleado {
38    private final long anual;
39    private final int pagas;
40
41    Asalariado(String nombre, long anual, int pagas) {
42        super(nombre);
43        this.anual = anual;
44        this.pagas = pagas;
45    }
46
47    String tipo() { return "asalariado"; }
48
49    // Redondeo al céntimo más cercano con enteros: (2a + p) / 2p
50    public long bruto() { return (anual * 2 + pagas) / (2L * pagas); }
51}
52
53class PorHoras extends Empleado {
54    private final int horas;
55    private final long precioHora;
56
57    PorHoras(String nombre, int horas, long precioHora) {
58        super(nombre);
59        this.horas = horas;
60        this.precioHora = precioHora;
61    }
62
63    String tipo() { return "por horas"; }
64
65    public long bruto() {
66        int normales = Math.min(horas, 160), extra = Math.max(0, horas - 160);
67        return normales * precioHora + Main.porcentaje(extra * precioHora, 12500);   // las extra, al 125 %
68    }
69}
70
71class Comercial extends Empleado {
72    private final long base, ventas, comision;   // comisión en centésimas de %
73
74    Comercial(String nombre, long base, long ventas, long comision) {
75        super(nombre);
76        this.base = base;
77        this.ventas = ventas;
78        this.comision = comision;
79    }
80
81    String tipo() { return "comercial"; }
82
83    public long bruto() { return base + Math.min(Main.porcentaje(ventas, comision), 200000); }
84}
85
86class Becario extends Empleado {
87    private final long ayuda;
88
89    Becario(String nombre, long ayuda) {
90        super(nombre);
91        this.ayuda = ayuda;
92    }
93
94    String tipo() { return "becario"; }
95
96    public long bruto() { return ayuda; }
97
98    // La beca no lleva retención en este ejercicio: se sobrescribe el método por defecto
99    @Override
100    public long retencion() { return 0; }
101}
102
103public class Main {
104    /** cantidad × centésimas / 10000, redondeado al céntimo (las mitades suben). */
105    static long porcentaje(long cantidad, long centesimas) {
106        return (cantidad * centesimas + 5000) / 10000;
107    }
108
109    /** «1234.5» → 123450; -1 si no es un número positivo con hasta 2 decimales. */
110    static long centimos(String texto) {
111        if (!texto.matches("\\d{1,9}(\\.\\d{1,2})?")) return -1;
112        String[] p = texto.split("\\.");
113        return Long.parseLong(p[0]) * 100 + (p.length == 2 ? Long.parseLong((p[1] + "0").substring(0, 2)) : 0);
114    }
115
116    static String euros(long c) {
117        return String.format(Locale.ROOT, "%,d", c / 100).replace(',', '.') + "," + String.format("%02d", c % 100);
118    }
119
120    /** El empleado de una línea, o una excepción con el motivo por el que se ignora. */
121    static Empleado leer(String linea) {
122        int espacio = linea.indexOf(' ');
123        if (espacio < 0) throw new IllegalArgumentException("faltan o sobran datos");
124        String tipo = linea.substring(0, espacio).toUpperCase();
125        String[] d = linea.substring(espacio + 1).split(";", -1);
126        int esperados = switch (tipo) {
127            case "ASALARIADO", "HORAS" -> 3;
128            case "COMERCIAL" -> 4;
129            case "BECARIO" -> 2;
130            default -> throw new IllegalArgumentException("tipo desconocido " + tipo);
131        };
132        if (d.length != esperados || d[0].isBlank()) throw new IllegalArgumentException("faltan o sobran datos");
133        String nombre = d[0].trim();
134        long[] n = new long[d.length];
135        for (int i = 1; i < d.length; i++) {
136            n[i] = centimos(d[i].trim());
137            if (n[i] < 0) throw new IllegalArgumentException("dato no válido");
138        }
139        switch (tipo) {
140            case "ASALARIADO" -> {
141                if (n[2] != 1200 && n[2] != 1400) throw new IllegalArgumentException("dato no válido");
142                return new Asalariado(nombre, n[1], (int) (n[2] / 100));
143            }
144            case "HORAS" -> {
145                if (n[1] % 100 != 0 || n[1] > 30000) throw new IllegalArgumentException("dato no válido");
146                return new PorHoras(nombre, (int) (n[1] / 100), n[2]);
147            }
148            case "COMERCIAL" -> {
149                if (n[3] > 2000) throw new IllegalArgumentException("dato no válido");
150                return new Comercial(nombre, n[1], n[2], n[3]);
151            }
152            default -> {
153                return new Becario(nombre, n[1]);
154            }
155        }
156    }
157
158    public static void main(String[] args) {
159        Scanner sc = new Scanner(System.in);
160        List<Empleado> plantilla = new ArrayList<>();
161        int numero = 0;
162        while (sc.hasNextLine()) {
163            String linea = sc.nextLine().trim();
164            numero++;
165            if (linea.isEmpty()) continue;
166            try {
167                plantilla.add(leer(linea));
168            } catch (IllegalArgumentException e) {
169                System.out.println("Línea " + numero + " ignorada: " + e.getMessage());
170            }
171        }
172        if (plantilla.isEmpty()) {
173            System.out.println("No hay nóminas que calcular.");
174            return;
175        }
176
177        String formato = "%-20s%-12s%11s%11s%11s%11s%n";
178        System.out.printf(formato, "Empleado", "Tipo", "Bruto", "IRPF", "SS", "Neto");
179        long bruto = 0, irpf = 0, ss = 0, neto = 0;
180        Empleado mejor = plantilla.get(0);
181        for (Empleado e : plantilla) {
182            // El mismo código sirve para cualquier empleado: cada clase sabe calcular su bruto
183            System.out.printf(formato, e.getNombre(), e.tipo(), euros(e.bruto()), euros(e.retencion()), euros(e.seguridadSocial()), euros(e.neto()));
184            bruto += e.bruto();
185            irpf += e.retencion();
186            ss += e.seguridadSocial();
187            neto += e.neto();
188            if (e.neto() > mejor.neto()) mejor = e;
189        }
190        System.out.printf(formato, "TOTAL", "", euros(bruto), euros(irpf), euros(ss), euros(neto));
191        System.out.println("Coste para la empresa: " + euros(bruto + porcentaje(bruto, 3000)) + " €");
192        System.out.println("Mayor neto: " + mejor.getNombre() + " (" + euros(mejor.neto()) + " €)");
193    }
194}