python_zip.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python `zip()` function\n",
    "The `zip()` function returns a zip object, which is an iterator of tuples where the first item in each passed iterator is paired together, and then the second item in each passed iterator are paired together etc.\n",
    "```\n",
    "zip(iterator1, iterator2, iterator3 ...)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: zip on tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x21157c15f08>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food = (\"Kung Pao Chicken\", \"Pho\", \"Fish and Chips\", 'Sushi')\n",
    "country = (\"China\", \"Vietnam\", \"Britain\", \"Japan\")\n",
    "tmp = zip(food, country)\n",
    "tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Kung Pao Chicken', 'China'),\n",
       " ('Pho', 'Vietnam'),\n",
       " ('Fish and Chips', 'Britain'),\n",
       " ('Sushi', 'Japan')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: zip on lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "letters = ['a', 'b', 'c', 'd', 'e']\n",
    "list(zip(numbers, letters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3: zip on sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('apple', 'yellow'), ('banana', 'red')]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit_set = {'apple', 'banana'}\n",
    "color_set = {'red', 'yellow'}\n",
    "list(zip(fruit_set, color_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** in this example, `fruit_set` and `color_set` are set objects, which don’t keep their elements in any particular order. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 4: zip on multiple operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C'), (4, 'd', 'D'), (5, 'e', 'E')]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "lower_cases = ['a', 'b', 'c', 'd', 'e']\n",
    "upper_cases = ['A', 'B', 'C', 'D', 'E']\n",
    "list(zip(numbers, lower_cases, upper_cases))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 5: zip on iterators of different lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a'), (2, 'b'), (3, 'c')]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "lower_cases = ['a', 'b', 'c']\n",
    "list(zip(numbers, lower_cases))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'a', 'A'), (2, 'b', 'B')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "lower_cases = ['a', 'b', 'c']\n",
    "upper_cases = ['A', 'B', ]\n",
    "list(zip(numbers, lower_cases, upper_cases))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 6: zip on the same iterator\n",
    "\n",
    "`zip()` function can take just one argument as well. The result will be an iterator that yields a series of 1-item tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1,), (2,), (3,), (4,), (5,)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "list(zip(numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An interesting usecase: compare the `i-th` item with the `(i+1)-th` item from the same list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (2, 3), (3, 4), (4, 5)]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "pairs = list(zip(numbers, numbers[1:]))\n",
    "print(pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True, True, True]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[a < b for a, b in pairs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 7: Leetcode problem [Verifying an Alien Dictionary](https://leetcode.com/problems/verifying-an-alien-dictionary/)\n",
    "\n",
    "In an alien language, surprisingly they also use english lowercase letters, but possibly in a different order. The order of the alphabet is some permutation of lowercase letters. Given a sequence of `words` written in the alien language, and the `order` of the alphabet, return `true` if and only if the given words are sorted lexicographicaly in this alien language.\n",
    "\n",
    "**Example** \n",
    "\n",
    "> **Input**: `words` = [\"hello\",\"leetcode\"], `order` = \"hlabcdefgijkmnopqrstuvwxyz\"<br>\n",
    "> **Expected Output**: `True` <br>\n",
    "> **Explanation**: As 'h' comes before 'l' in this language, then the sequence is sorted.\n",
    "\n",
    "**Example** \n",
    "\n",
    "> **Input**: `words` = [\"word\",\"world\",\"row\"], `order` = \"worldabcefghijkmnpqstuvxyz\" <br>\n",
    "> **Output**: `False` <br>\n",
    "> **Explanation**: As 'd' comes after 'l' in this language, then words[0] > words[1], hence the sequence is unsorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isAlienSorted(words, order):\n",
    "    word_index = {char: index for index, char in enumerate(order)}\n",
    "    for word_a, word_b in zip(words, words[1:]):\n",
    "        if len(word_a) > len(word_b) and word_a[:len(word_b)] == word_b:\n",
    "            return False\n",
    "        for char1, char2 in zip(word_a, word_b):\n",
    "            if word_index[char1] < word_index[char2]:\n",
    "                break\n",
    "            elif word_index[char1] > word_index[char2]:\n",
    "                return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words = [\"hello\",\"leetcode\"]\n",
    "order =  \"hlabcdefgijkmnopqrstuvwxyz\"\n",
    "isAlienSorted(words, order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words =  [\"word\",\"world\",\"row\"]\n",
    "order =  \"worldabcefghijkmnpqstuvxyz\"\n",
    "isAlienSorted(words, order)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}