codificar: de los grupos a los pares (elemento, cantidad)La función se arma con tres piezas que ya están resueltas por
separado: empaquetar agrupa los elementos iguales que están
seguidos, map transforma cada grupo en una sola cosa, y esa cosa
es una tupla. Antes de ver el resultado hay que decir cuántos pares salen, que
es la pregunta donde se equivoca casi todo el mundo, y después escoger el
resultado entre cuatro candidatos. Los cuatro salieron de correr código: tres
son lo que devuelven otras funciones parecidas.
La lista que recibe map es la de los grupos, no
la de la entrada. De ahí sale grupo.head, que es el elemento
porque todos los del grupo son iguales, y grupo.length, que es
cuántas veces venía seguido.
Primero el número de pares; al acertarlo aparecen las cuatro opciones del resultado. Cada opción equivocada dice de qué función es ese valor.
Valen para cualquier lista, no solo para las tres de arriba.
El número de pares es el número de grupos, y no el
de elementos distintos. map pone exactamente una salida por
cada elemento de la lista que recibe, así que la longitud del resultado es
la de los grupos; y empaquetar solo junta lo que viene seguido.
Con List(1, 1, 2, 1, 1, 1) el 1 aparece en dos grupos
separados por el 2, y por eso salen tres pares y no dos: los dos grupos del
1 quedan contados aparte.
Esa separación es lo que hace reversible la codificación. Si los grupos
del mismo elemento se fundieran, (1,5), (2,1) ya no diría en
qué orden venían los elementos y la lista original no se podría recuperar.
Tal como está, recorrer los pares y repetir cada elemento su cantidad de
veces devuelve la entrada.
El reparto del trabajo entre las tres piezas se lee en los tipos. La
recursión con span vive en empaquetar, que pasa de
List[T] a List[List[T]]; codificar no
tiene recursión propia, solo el map que lleva eso a
List[(T, Int)]. La tupla es lo que permite que cada grupo se
reduzca a dos datos de tipos distintos sin perder ninguno.