Ejercicio resuelto: diccionarios, conjuntos y tuplas en Python

La solución separa el trabajo en dos funciones puras y un main que solo lee y escribe. leer_registros recorre las líneas, filtra, detecta duplicados y construye el diccionario de conjuntos. comunes_a_todos calcula la intersección. Así cada parte se puede probar por separado y la corrección de cada apartado de la rúbrica se localiza en una función concreta.

import sys


def leer_registros(lineas):
    """Devuelve (asistentes, duplicados, ignoradas).

    asistentes: dict taller -> set de alumnos, en orden de primera aparicion.
    """
    registros = set()      # tuplas (taller, alumno) ya vistas
    asistentes = {}
    duplicados = 0
    ignoradas = 0
    for linea in lineas:
        partes = linea.split()
        if not partes:
            continue                  # linea vacia: no cuenta
        if len(partes) != 2:
            ignoradas += 1
            continue
        par = (partes[0], partes[1])
        if par in registros:
            duplicados += 1
            continue
        registros.add(par)
        taller, alumno = par
        if taller not in asistentes:
            asistentes[taller] = set()
        asistentes[taller].add(alumno)
    return asistentes, duplicados, ignoradas


def comunes_a_todos(asistentes):
    """Alumnos presentes en todos los talleres (set vacio si no hay talleres)."""
    if not asistentes:
        return set()
    conjuntos = list(asistentes.values())
    comunes = set(conjuntos[0])       # copia: no tocar el original
    for alumnos in conjuntos[1:]:
        comunes &= alumnos
    return comunes


def main():
    lineas = sys.stdin.read().splitlines()
    asistentes, duplicados, ignoradas = leer_registros(lineas)
    for taller, alumnos in asistentes.items():
        print(f"{taller}: {len(alumnos)}")
    comunes = comunes_a_todos(asistentes)
    if comunes:
        print("TODOS: " + ", ".join(sorted(comunes)))
    else:
        print("TODOS: -")
    print(f"DUPLICADOS: {duplicados}")
    print(f"IGNORADAS: {ignoradas}")


if __name__ == "__main__":
    main()

main lee toda la entrada con sys.stdin.read().splitlines(). Así obtiene una lista de líneas sin el salto final y funciona igual si la última línea termina o no en \n. Con la entrada vacía la lista también queda vacía y el resto del programa no necesita ningún tratamiento especial.

En leer_registros, linea.split() sin argumentos parte por cualquier secuencia de espacios y descarta los de los extremos. Por eso una línea formada solo por espacios produce una lista vacía y se salta con continue sin contarla. Si la lista no tiene exactamente dos elementos, la línea suma uno a ignoradas. En el caso «intersección vacía y líneas inválidas», soloUnaPalabra y tres palabras aqui dan IGNORADAS: 2, mientras que la línea en blanco no se cuenta.

Cada línea válida se convierte en la tupla par. El conjunto registros recuerda todas las tuplas ya vistas. Si par ya está, se incrementa duplicados y no se hace nada más. En el ejemplo, python ana y sql ana aparecen dos veces cada una, de ahí DUPLICADOS: 2. Usar una tupla y no una lista es obligatorio: una lista es mutable, no es hashable y no puede entrar en un set.

Las inscripciones nuevas se agregan a asistentes. Si el taller no existe todavía, se crea su conjunto vacío y, como el diccionario conserva el orden de inserción, ese taller queda colocado en el lugar de su primera aparición. En el ejemplo salen python, sql y redes en ese orden, y cada uno con 2 alumnos distintos. En el caso de tres talleres con los mismos alumnos, el orden c, a, b se respeta aunque no sea alfabético.

Un matiz: el control de duplicados con registros es necesario para contarlos. Para el recuento de alumnos no haría falta, porque añadir dos veces el mismo alumno a un conjunto no cambia su tamaño. Son dos responsabilidades distintas y conviene no mezclarlas.

comunes_a_todos devuelve un conjunto vacío si no hay talleres. Si los hay, copia el primer conjunto con set(conjuntos[0]) e interseca en el sitio con los demás. En el ejemplo, {ana, luis} con {ana, luis} da {ana, luis} y, con {ana, marta}, queda {ana}. En el caso de intersección vacía, {ana, luis} con {marta} da el conjunto vacío y se imprime TODOS: -. Con un solo taller, el bucle no itera y los comunes son sus propios alumnos, como en el caso bash pedro.

Por último, sorted(comunes) convierte el conjunto, que no tiene orden, en una lista ordenada, y ", ".join la une con el separador pedido. Por eso el caso de los tres talleres imprime TODOS: x, y, z aunque los alumnos se inscribieran en otro orden.