CodeSignal - 5 Complexity of Comprehension.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create Spiral Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.\n",
    "\n",
    "A spiral matrix is a square matrix of size n × n. It contains all the integers in range from 1 to n * n so that number 1 is written in the bottom right corner, and all other numbers are written in increasing order spirally in the counterclockwise direction.\n",
    "\n",
    "Given the size of the matrix n, your task is to create a spiral matrix.\n",
    "\n",
    "Example\n",
    "\n",
    "For n = 3, the output should be\n",
    "\n",
    "createSpiralMatrix(n) = [[5, 4, 3],\n",
    "                         [6, 9, 2],\n",
    "                         [7, 8, 1]]\n",
    "\n",
    "Input/Output\n",
    "\n",
    "    [execution time limit] 4 seconds (py3)\n",
    "\n",
    "    [input] integer n\n",
    "\n",
    "    Matrix size, a positive integer.\n",
    "\n",
    "    Guaranteed constraints:\n",
    "    3 ≤ n ≤ 75.\n",
    "\n",
    "    [output] array.array.integer\n",
    "\n",
    "    A spiral matrix of size n.\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def createSpiralMatrix(n):\n",
    "    dirs = [(-1, 0), (0, -1), (1, 0), (0, 1)]\n",
    "    curDir = 0\n",
    "    curPos = (n - 1, n - 1)\n",
    "    res = ...\n",
    "\n",
    "    for i in range(1, n * n + 1):\n",
    "        res[curPos[0]][curPos[1]] = i\n",
    "        nextPos = curPos[0] + dirs[curDir][0], curPos[1] + dirs[curDir][1]\n",
    "        if not (0 <= nextPos[0] < n and\n",
    "                0 <= nextPos[1] < n and\n",
    "                res[nextPos[0]][nextPos[1]] == 0):\n",
    "            curDir = (curDir + 1) % 4\n",
    "            nextPos = curPos[0] + dirs[curDir][0], curPos[1] + dirs[curDir][1]\n",
    "        curPos = nextPos\n",
    "\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0], [0, 0, 0], [0, 0, 0]]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 3\n",
    "res = [[0] * n] * n\n",
    "display(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0], [0, 0, 0], [0, 0, 0]]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=3;\n",
    "l=[[0] *n]*n;\n",
    "l[0][0] = 1;\n",
    "l\n",
    "#hence this initialization wont work, instead \n",
    "\n",
    "n = 3;\n",
    "l = [[0 for column in range(n)] for row in range(n)];\n",
    "l[0][0] = 1;\n",
    "l\n",
    "\n",
    "#we use the second technique : (understood this from the codesignal comments)\n",
    "\n",
    "#What the first technique is doing is just repeating the inner list in the outer list. Hence there are no 3 \n",
    "#lists in the first initialization. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createSpiralMatrix(n):\n",
    "    dirs = [(-1, 0), (0, -1), (1, 0), (0, 1)]\n",
    "    curDir = 0\n",
    "    curPos = (n - 1, n - 1)\n",
    "    res = [[0 for column in range(n)] for row in range(n)]\n",
    "\n",
    "    for i in range(1, n * n + 1):\n",
    "        res[curPos[0]][curPos[1]] = i\n",
    "        nextPos = curPos[0] + dirs[curDir][0], curPos[1] + dirs[curDir][1]\n",
    "        if not (0 <= nextPos[0] < n and\n",
    "                0 <= nextPos[1] < n and\n",
    "                res[nextPos[0]][nextPos[1]] == 0):\n",
    "            curDir = (curDir + 1) % 4\n",
    "            nextPos = curPos[0] + dirs[curDir][0], curPos[1] + dirs[curDir][1]\n",
    "        curPos = nextPos\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Construct Shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.\n",
    "\n",
    "A 2D list lst of size 2 * n - 1 is called a shell if it is filled with zeros and has the following configuration:\n",
    "\n",
    "    lst[0] contains one element;\n",
    "    lst[1] contains two elements;\n",
    "    ...\n",
    "    lst[n - 2] contains n - 1 elements;\n",
    "    lst[n - 1] contains n elements;\n",
    "    lst[n] contains n - 1 elements;\n",
    "    ...\n",
    "    lst[2 * n - 3] contains two elements;\n",
    "    lst[2 * n - 2] contains one element.\n",
    "\n",
    "Given an integer n, return a shell list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0], [0, 0], [0, 0, 0], [0, 0], [0]]\n"
     ]
    }
   ],
   "source": [
    "# def constructShell(n):\n",
    "#     return ...\n",
    "n = 3\n",
    "rows = (2 * n) - 1\n",
    "# arr = [[min((i+1),(2*n - 1) - (i) + 1) for i in range(rows)] for j in range(rows)] \n",
    "# print(arr)\n",
    "\n",
    "# print(list(range(rows)))\n",
    "\n",
    "#attempt 2\n",
    "\n",
    "# for i in range(2*n-1):\n",
    "#     display(min((i+1),(2*n - 1) - (i)))\n",
    "#     [0] * min((i+1),(2*n - 1) - (i))\n",
    "\n",
    "\n",
    "arr = [[0] * min((i+1),(2*n - 1) - (i)) for i in range(rows)] \n",
    "print(arr)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0], [0, 0], [0, 0, 0], [0, 0], [0]]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Solution\n",
    "def constructShell(n):\n",
    "    return  [[0] * min((i+1),(2*n - 1) - (i)) for i in range(2*n - 1)]\n",
    "\n",
    "constructShell(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Word Power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.\n",
    "\n",
    "You've heard somewhere that a word is more powerful than an action. You decided to put this statement at a test by assigning a power value to each action and each word. To begin somewhere, you defined a power of a word as the sum of powers of its characters, where power of a character is equal to its 1-based index in the plaintext alphabet.\n",
    "\n",
    "Given a word, calculate its power.\n",
    "\n",
    "Example\n",
    "\n",
    "For word = \"hello\", the output should be\n",
    "wordPower(word) = 52.\n",
    "\n",
    "Letters 'h', 'e', 'l' and 'o' have powers 8, 5, 12 and 15, respectively. Thus, the total power of the word is 8 + 5 + 12 + 12 + 15 = 52.\n",
    "\n",
    "Input/Output\n",
    "\n",
    "    [execution time limit] 4 seconds (py)\n",
    "\n",
    "    [input] string word\n",
    "\n",
    "    A string consisting of lowercase English letters.\n",
    "\n",
    "    Guaranteed constraints:\n",
    "    1 ≤ word.length ≤ 25.\n",
    "\n",
    "    [output] integer\n",
    "\n",
    "    Power of the given word.\n",
    "    \n",
    "def wordPower(word):\n",
    "    num = ...\n",
    "    return sum([num[ch] for ch in word])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def wordPower(word):\n",
    "#     num = ...\n",
    "#     return sum([num[ch] for ch in word])\n",
    "\n",
    "# word = 'hello'\n",
    "\n",
    "# # import string\n",
    "# string.ascii_lowercase.index('a')\n",
    "\n",
    "# ord('b') - 97\n",
    "\n",
    "#thus, \n",
    "def wordPower(word):\n",
    "    somefun = lambda x: (ord(x) - 97 + 1)\n",
    "    return sum([somefun(char) for char in word])\n",
    "\n",
    "wordPower(\"hello\")\n",
    "\n",
    "#works but the way the problem wants is a little different\n",
    "#it wants num to be a map of alphabets and numbers which\n",
    "#u index depending on the letter. Lets try that way\n",
    "\n",
    "import string\n",
    "dictcheck = dict(zip(string.ascii_lowercase,range(1,27)))\n",
    "dictcheck\n",
    "# https://stackoverflow.com/questions/19542820/creating-dict-where-keys-are-alphabet-letters-and-values-are-1-26-using-dict-com\n",
    "dictcheck['n']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#final solution\n",
    "def wordPower(word):\n",
    "    num = dict(zip(string.ascii_lowercase,range(1,27)))\n",
    "    return sum([num[ch] for ch in word])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#more elegant solution from the community, without requiring string.ascii_lowercase\n",
    "# def wordPower(word):\n",
    "#     num = {c: ord(c) - 96 for c in word}\n",
    "#     return (sum(num[ch] for ch in word))\n",
    "\n",
    "# wordPower(\"hello\")\n",
    "word = \"hello\"\n",
    "num = {c: ord(c) - 96 for c in word}\n",
    "num\n",
    "type(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool Pairs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.\n",
    "\n",
    "A pair of numbers is considered to be cool if their product is divisible by their sum. More formally, a pair (i, j) is cool if and only if (i * j) % (i + j) = 0.\n",
    "\n",
    "Given two lists a and b, find cool pairs with the first number in the pair from a, and the second one from b. Return the number of different sums of elements in such pairs.\n",
    "\n",
    "Example\n",
    "\n",
    "For a = [4, 5, 6, 7, 8] and b = [8, 9, 10, 11, 12],\n",
    "the output should be\n",
    "coolPairs(a, b) = 2.\n",
    "\n",
    "There are three cool pairs that can be formed from these arrays: (4, 12), (6, 12) and (8, 8). Their respective sums are 16, 18 and 16, which means that there are just 2 different sums: 16 and 18. Thus, the output should be equal to 2.\n",
    "\n",
    "Input/Output\n",
    "\n",
    "    [execution time limit] 4 seconds (py)\n",
    "\n",
    "    [input] array.integer a\n",
    "\n",
    "    Array of distinct elements.\n",
    "\n",
    "    Guaranteed constraints:\n",
    "    1 ≤ a.length ≤ 100,\n",
    "    1 ≤ a[i] ≤ 100.\n",
    "\n",
    "    [input] array.integer b\n",
    "\n",
    "    Array of distinct elements.\n",
    "\n",
    "    Guaranteed constraints:\n",
    "    1 ≤ b.length ≤ 100,\n",
    "    1 ≤ b[i] ≤ 100.\n",
    "\n",
    "    [output] integer\n",
    "\n",
    "    The number of different sums of elements in cool pairs formed by elements from a and b.\n",
    "    \n",
    "    def coolPairs(a, b):\n",
    "    uniqueSums = {}\n",
    "    return len(uniqueSums)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{16, 18}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = [4, 5, 6, 7, 8]\n",
    "b = [8, 9, 10, 11, 12]\n",
    "type(a)\n",
    "\n",
    "[[(i * j) % (i + j) for i in a] for j in b]\n",
    "\n",
    "#checking from some stackoverflow solution\n",
    "from itertools import product \n",
    "check = list(product(a,b))\n",
    "\n",
    "type(check)\n",
    "\n",
    "#now do the final thing: \n",
    "# keep only items in the product if the condition is met. \n",
    "\n",
    "type(check[1])\n",
    "\n",
    "# check[1][0]\n",
    "# [item for item in list_1 if item[2] >= 5 or item[3] >= 0.3]\n",
    "# check = [item for item in check if ]\n",
    "\n",
    "#list comprehension as pointed out from the comments section. \n",
    "# [(x, y) for x in a for y in b if (x * y) % (x + y) == 0]\n",
    "display({(x + y) for x in a for y in b if (x * y) % (x + y) == 0})\n",
    "\n",
    "#its type is set!\n",
    "display(type({(x + y) for x in a for y in b if (x * y) % (x + y) == 0}))\n",
    "\n",
    "#isnt this the way to create dictionary? \n",
    "#Yep but dictionary has key and value pairs, whereas set only has values\n",
    "# it is unordered and only contains unique values. \n",
    "\n",
    "#because I didn't know that {} could mean something other \n",
    "# than dictionary I was only lookking at generating dictionary\n",
    "#from lists based on condition.. \n",
    "\n",
    "#some momre knowhow on sets\n",
    "#generate empty set \n",
    "emptyset = {} #would take the class dict\n",
    "display(type(emptyset))\n",
    "\n",
    "emptyset = set()\n",
    "display(type(emptyset))\n",
    "\n",
    "#copying set \n",
    "\n",
    "#yep done. List comprehension!!\n",
    "# 1. https://docs.python.org/3/tutorial/datastructures.html\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#final solution\n",
    "def coolPairs(a, b):\n",
    "    uniqueSums = {(x + y) for x in a for y in b if (x * y) % (x+y) == 0}\n",
    "    return len(uniqueSums)\n",
    "\n",
    "coolPairs(a = [4, 5, 6, 7, 8],b = [8, 9, 10, 11, 12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplication Table\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the missing code, denoted by ellipses. You may not modify the pre-existing code.\n",
    "\n",
    "Looks like your little brother doesn't want to remember the multiplication table! Instead he wants to play videogames all day long. To teach him a lesson you'd like to write a virus that will pop up in the middle of the game and disappear only when the brother correctly solves several math questions.\n",
    "\n",
    "To begin with, you need to construct a multiplication table. Given an integer n, return the multiplication table of size n × n.\n",
    "\n",
    "Example\n",
    "\n",
    "For n = 5, the output should be\n",
    "\n",
    "multiplicationTable(n) = [[1, 2,  3,  4,  5 ], \n",
    "                          [2, 4,  6,  8,  10], \n",
    "                          [3, 6,  9,  12, 15], \n",
    "                          [4, 8,  12, 16, 20], \n",
    "                          [5, 10, 15, 20, 25]]\n",
    "\n",
    "def multiplicationTable(n):\n",
    "    return ...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [2, 4, 6], [3, 6, 9]]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def multiplicationTable(n):\n",
    "#     return ...\n",
    "\n",
    "n = 3\n",
    "[[(x+1)*(y+1) for x in range(n)]for y in range(n)]\n",
    "#yaay first attempt worked. Some basic python understanding is coming. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 5],\n",
       " [2, 4, 6, 8, 10],\n",
       " [3, 6, 9, 12, 15],\n",
       " [4, 8, 12, 16, 20],\n",
       " [5, 10, 15, 20, 25]]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#final solution\n",
    "def multiplicationTable(n):\n",
    "    return [[(x+1)*(y+1) for x in range(n)]for y in range(n)]\n",
    "\n",
    "multiplicationTable(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}