Zip (ilmu komputer)

Dalam ilmu komputer, **zip** adalah fungsi yang memetakan rangkap dari barisan menjadi barisan dari rangkap. Nama *zip* berasal dari bahasa Inggris *zipping* atau *zipper* (ritsleting) yang secara selang-seling menggabungkan dua barisan yang terpisah. Inversi fungsi ini disebut *unzip*.

## Contoh
Misalkan ada tiga kata *ia*, *tuk*, dan *palu* (2, 3, dan 4 karakter). Misalkan pula \ell menandakan jumlah karakter terbanyak dari ketiganya, yaitu \ell = 4 (kata *palu*). Hasil operasi zip terhadap *ia*, *tuk*, dan *palu* adalah barisan berisi 4 rangkap berikut:

: (i, t, p), (a, u, a), (\#, k, l), (\#, \#, u)

dengan  adalah simbol di luar alfabet yang awalnya dipakai.

Pada bahasa pemrograman tertentu seperti Haskell, fungsi ini hanya mengembalikan sebanyak jumlah karakter terpendek, yaitu \ell = 2 (kata *ia*):


```haskell
zip3 "ia" "tuk" "palu"
-- [('i','t','p'),('a','u','a')]
```


## Definisi
Misalkan &Sigma; adalah alfabet dan  adalah simbol di luar &Sigma;.

Misalkan  adalah  kata (barisan berhingga) yang tersusun dari anggota &Sigma;. Misalkan pula \ell adalah panjang maksimum kata, yaitu maksimum dari 

Hasil operasi zip dari kata-kata tersebut adalah barisan berhingga dari rangkap- yang disusun dari anggota , dengan kata lain anggota dari :

: (x_1, y_1, z_1, \ldots, (x_2, y_2, z_2, \ldots), \ldots, (x_\ell, y_\ell, z_\ell, \ldots), \ldots

dengan  adalah  untuk  dan  adalah tiap kata.

Operasi zip terhadap  disimbolkan sebagai  atau . Inversi operasi zip disimbolkan sebagai .

Variasi operasi zip yang hanya mengembalikan dengan panjang minimum kata bisa didefinisikan sebagai berikut:

: (x_1, y_1, z_1, \ldots, (x_2, y_2, z_2, \ldots), \ldots, (x_\underline{\ell}, y_\underline{\ell}, z_\underline{\ell}, \ldots)

dengan \underline{\ell} adalah panjang *minimum* dari kata-kata yang diberikan. Variasi ini menghindari anggota tambahan , tetapi menghapus informasi tentang barisan masukan setelah ke-\underline{\ell}.

## Dalam bahasa pemrograman
Fungsi zip tersedia dalam beberapa bahasa pemrograman dan biasa disebut `zip`. Dalam dialek Lisp, operasi zip bisa dilakukan dengan fungsi <code>map</code> yang diterapkan terhadap daftar yang diinginkan. Fungsi `map` dalam Lisp bersifat variadik sehingga bisa menerima banyak argumen. Berikut contoh dalam bahasa Clojure:


```clojure
;; `bilangan` berisi daftar bilangan sampai tak hingga (0 1 2 3 ...)
(def bilangan (range))
(def puluhan [10 20 30])
(def namadepan "Milea")

;; Untuk zip (0 1 2 3 ...) dan [10 20 30] ke dalam vector, panggil `map vector` terhadapnya; begitu pula untuk list
(map vector bilangan puluhan)           ; ⇒ ([0 10] [1 20] [2 30])
(map list bilangan puluhan)             ; ⇒ ((0 10) (1 20) (2 30))
(map str bilangan puluhan)              ; ⇒ ("010" "120" "230")

;; `map` memotong sampai barisan terpendek; perhatikan "e" dan "a" dari "Milea"
(map vector bilangan puluhan namadepan) ; ⇒ ([0 10 "M"] [1 20 "i"] [2 30 "l"])
(map str bilangan puluhan namadepan)    ; ⇒ ("010M" "120i" "230l")

;; Untuk unzip, terapkan `map vector` atau `map list`
(apply map list (map vector bilangan puluhan namadepan))
;; ⇒ ((0 1 2) (10 20 30) ("M" "i" "l"))
```


Bahasa-bahasa seperti Python memberikan fungsi `zip()`. Python versi lawas (2.x) membolehkan pemetaan dengan `None` untuk menghasilkan efek yang sama. Fungsi `zip()` dengan `*` melakukan operasi unzip.

Contoh berikut berlaku untuk Python 2.x. Terdapat perbedaan antara versi 2 dan 3 terhadap hasil dari fungsi `zip()`, yaitu sebagai daftar (versi 2) dan objek malas (versi 3).


```pycon
>>> bilangan = [1, 2, 3]
>>> puluhan = [10, 20, 30]
>>> namadepan = 'Milea'

>>> zipped = zip(bilangan, puluhan)
>>> zipped
[(1, 10), (2, 20), (3, 30)]

>>> zip(*zipped) # unzip
[(1, 2, 3), (10, 20, 30)]

>>> zipped2 = zip(bilangan, puluhan, list(namadepan))
>>> zipped2 # zip, memangkas sampai yang paling pendek
[(1, 10, 'M'), (2, 20, 'i'), (3, 30, 'l')]
>>> zip(*zipped2) # unzip
[(1, 2, 3), (10, 20, 30), ('M', 'i', 'l')]

>>> # pemetaan dengan `None` tidak memangkasnya; dianggap usang dalam Python 3.
>>> map(None, bilangan, puluhan, list(namadepan))
[(1, 10, 'M'), (2, 20, 'i'), (3, 30, 'l'), (None, None, 'e'), (None, None, 'a')]
```


Haskell memiliki metode untuk operasi zip, tetapi wajib menggunakan fungsi khusus untuk tiap ariti (misal `zip` untuk dua daftar, `zip3` untuk tiga daftar, dst.); selain itu, fungsi `unzip` dan `unzip3` juga tersedia untuk operasi unzip.


```haskell
-- nums berisi daftar bilangan sampai tak hingga [1, 2, 3, ...]
bilangan = [1..]
puluhan = [10, 20, 30]
namadepan = "Milea"

zip bilangan puluhan
-- ⇒ [(1,10), (2,20), (3,30)] — zip, memangkas daftar tak hingga
unzip $ zip bilangan puluhan
-- ⇒ ([1,2,3], [10,20,30]) — unzip

zip3 bilangan puluhan namadepan
-- ⇒ [(1,10,'M'), (2,20,'i'), (3,30,'l')] — zip, memangkas
unzip3 $ zip3 bilangan puluhan namadepan
-- ⇒ ([1,2,3], [10,20,30], "Mil") — unzip
```


## Perbandingan bahasa
Berikut daftar bahasa yang mendukung operasi zip:

## Lihat pula
* Map (fungsi tingkat tinggi)

## Referensi