Compresión (informática)

En informática , `zipping` es una función que transforma una tupla de secuencias en una secuencia de tuplas . El nombre "zip" proviene de la acción de una cremallera, que intercala dos secuencias previamente disjuntas. La función inversa es `unzip` .

Dadas las tres palabras cat , fish y be , donde | cat | es 3, | fish | es 4 y | be | es 2. Sea${\displaystyle \ell }$denota la longitud de la palabra más larga, que es fish ;${\displaystyle \ell =4}$. El zip de cat , fish , be es entonces 4 tuplas de elementos:

${\displaystyle (c,f,b)(a,i,e)(t,s,\#)(\#,h,\#)}$

donde # es un símbolo que no está en el alfabeto original. En Haskell, esto trunca a la secuencia más corta.${\displaystyle {\underline {\ell }}}$, dónde${\displaystyle {\underline {\ell }}=2}$:

zip3 "gato" "pez" " ser" -- [('c','f','b'),('a','i','e')]

Sea Σ un alfabeto , # un símbolo que no está en Σ .

Sean x ₁ x ₂ ... x _{| x |} , y ₁ y ₂ ... y _{| y |} , z ₁ z ₂ ... z _{| z |} , ... n palabras (es decir, secuencias finitas ) de elementos de Σ . Sea${\displaystyle \ell }$denota la longitud de la palabra más larga, es decir, el máximo de | x |, | y |, | z |, ... .

El zip de estas palabras es una secuencia finita de n- tuplas de elementos de ( Σ ∪ {#}) , es decir, un elemento de${\displaystyle ((\Sigma \cup \{\#\})^{n})^{*}}$:

${\displaystyle (x_{1},y_{1},\ldots )(x_{2},y_{2},\ldots )\ldots (x_{\ell },y_{\ell },\ldots )}$,

donde para cualquier índice i > | w | , el w _i es #.

El conjunto de coordenadas x, y, z, ... se denota como zip( x, y, z, ... ) o x ⋆ y ⋆ z ⋆ ...

La operación inversa a zip se denomina a veces unzip.

Una variación de la operación zip se define por:

${\displaystyle (x_{1},y_{1},\ldots )(x_{2},y_{2},\ldots )\ldots (x_{\underline {\ell }},y_{\underline {\ell }},\ldots )}$

dónde${\displaystyle {\underline {\ell }}}$es la longitud mínima de las palabras de entrada. Evita el uso de un elemento adjunto.${\displaystyle \#}$pero destruye información sobre elementos de las secuencias de entrada más allá de${\displaystyle {\underline {\ell }}}$.

Las funciones zip suelen estar disponibles en los lenguajes de programación , a menudo denominadas zip . En los dialectos de Lisp, se puede simplemente aplicar la función deseada a las listas deseadas; map es variádica en Lisp, por lo que puede aceptar un número arbitrario de listas como argumento. Un ejemplo de Clojure : ^{[ 1 ]}

;; `nums' contiene una lista infinita de números (0 1 2 3 ...) ( def nums ( rango )) ( def tens [ 10 20 30 ]) ( def firstname "Alice" )Para combinar (0 1 2 3 ...) y [10 20 30] en un vector, invoque `map vector` sobre ellos; lo mismo con la lista ( map vector nums tens ) ; ⇒ ([0 10] [1 20] [2 30]) ( map list nums tens ) ; ⇒ ((0 10) (1 20) (2 30)) ( map str nums tens ) ; ⇒ ("010" "120" "230");; `map' trunca a la secuencia más corta; observe que faltan \c y \e en "Alice" ( map vector nums tens firstname ) ; ⇒ ([0 10 \A] [1 20 \l] [2 30 \i]) ( map str nums tens firstname ) ; ⇒ ("010A" "120l" "230i");; Para descomprimir, aplique `map vector' o `map list' ( apply map list ( map vector nums tens firstname )) ;; ⇒ ((0 1 2) (10 20 30) (\A \l \i))

En Common Lisp :

( defparameter nums ' ( 1 2 3 )) ( defparameter tens ' ( 10 20 30 )) ( defparameter firstname "Alice" )( lista de números de mapa de coches ) ;; ⇒ ((1 10) (2 20) (3 30))( lista mapcar #' nums decenas ( coerce firstname 'list )) ;; ⇒ ((1 10 #\A) (2 20 #\l) (3 30 #\i)) — trunca en la lista más corta;; Descomprime ( aplicar #' mapcar #' lista ( mapcar #' lista nums decenas ( coercer firstname 'lista ))) ;; ⇒ ((1 2 3) (10 20 30) (#\A #\l #\i))

Lenguajes como Python proporcionan una función zip() . ^{[ 2 ]} zip() junto con el operador * descomprime una lista: ^{[ 2 ]}

>>> nums = [ 1 , 2 , 3 ] >>> tens = [ 10 , 20 , 30 ] >>> firstname = 'Alice'>>> zipped = list ( zip ( nums , tens )) >>> zipped [(1, 10), (2, 20), (3, 30)]>>> lista ( zip ( * comprimido )) # descomprimir [(1, 2, 3), (10, 20, 30)]>>> zipped2 = list ( zip ( nums , tens , list ( firstname ))) >>> zipped2 # zip, trunca en el más corto [(1, 10, 'A'), (2, 20, 'l'), (3, 30, 'i')] >>> list ( zip ( * zipped2 )) # unzip [(1, 2, 3), (10, 20, 30), ('A', 'l', 'i')]

Haskell tiene un método para comprimir secuencias, pero requiere una función específica para cada aridad ( zip para dos secuencias, zip3 para tres, etc.), ^{[ 3 ]} de manera similar, las funciones unzip y unzip3 están disponibles para descomprimir:

-- nums contiene una lista infinita de números [1, 2, 3, ...] nums = [ 1 .. ] tens = [ 10 , 20 , 30 ] firstname = "Alice"zip nums tens -- ⇒ [(1,10), (2,20), (3,30)] — zip, trunca una lista infinita unzip $ zip nums tens -- ⇒ ([1,2,3], [10,20,30]) — unzipzip3 nums tens firstname -- ⇒ [(1,10,'A'), (2,20,'l'), (3,30,'i')] — zip, trunca unzip3 $ zip3 nums tens firstname -- ⇒ ([1,2,3], [10,20,30], "Ali") — unzip

Lista de idiomas según la compatibilidad con zip:

• Mapa (función de orden superior)