Encontrar al corredor que no termina en Java con frecuencias de nombres

Para encontrar al corredor que no termina, cuenta personas por nombre en lugar de comprobar solo si el nombre existe. Resta las frecuencias de quienes terminan de las de participantes; el ejercicio garantiza que exactamente un nombre conserva un recuento de 1.

Las condiciones de entrada permiten hasta 100 000 participantes, un corredor menos que termina y nombres repetidos. Los nombres contienen 1–20 letras inglesas minúsculas. Se supone que la lista de quienes terminan es una lista válida de participantes de la que se ha quitado a una persona.

Flujo de procesamiento

Cuenta a cada participante, resta a cada corredor que termina y devuelve el nombre cuyo recuento restante es uno.

Guardar la diferencia de recuentos

Guarda esta clase completa como Solution.java. El código del artículo original se compiló para Java 11 y se ejecutó en JDK 17.

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public String solution(String[] participant, String[] completion) {
        Map<String, Integer> counts = new HashMap<>();
        for (String name : participant) counts.merge(name, 1, Integer::sum);
        for (String name : completion) counts.put(name, counts.get(name) - 1);
        for (Map.Entry<String, Integer> entry : counts.entrySet()) {
            if (entry.getValue() == 1) return entry.getKey();
        }
        throw new IllegalArgumentException("Expected exactly one missing runner");
    }
}

merge(name, 1, Integer::sum) inicia un nombre nuevo en 1 e incrementa los existentes. Cada corredor que termina reduce en uno el recuento de su nombre. Con participantes [ana, bob, ana] y quienes terminan [bob, ana], para ana queda 2 - 1 = 1.

La diferencia de Set perdería el hecho de que dos personas se llamaban ana. Los recuentos mantienen la multiplicidad y representan así a una persona ausente. Reordenar el array de quienes terminan no cambia el resultado.

No depender del orden de HashMap

HashMap no garantiza el orden de iteración. Devolver la primera entrada positiva funciona porque una entrada válida deja exactamente una, no porque exista un orden concreto. El código devuelve el nombre cuyo recuento restante es 1.

La excepción final no es una validación completa de las entradas. Una API general de conciliación necesitaría reglas y comprobaciones adicionales para corredores desconocidos en la lista final o varias personas ausentes.

Con nombres limitados a 20 caracteres y operaciones hash de tiempo constante en promedio, el tiempo es O(n), con O(u) de espacio adicional para u nombres distintos. Ningún benchmark demuestra que los streams o los bucles sean universalmente más rápidos.

Cuando solo importan los tipos distintos, basta con un Set; compara el límite de selección del ejercicio Ponketmon.