Codewars-trial-notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extract the domain name from a URL\n",
    "\n",
    "https://www.codewars.com/kata/514a024011ea4fb54200004b/train/python\n",
    "\n",
    "Write a function that when given a URL as a string, parses out just the domain name and returns it as a string. For example:\n",
    "\n",
    "domain_name(\"http://github.com/carbonfive/raygun\") == \"github\"\n",
    "\n",
    "domain_name(\"http://www.zombie-bites.com\") == \"zombie-bites\"\n",
    "\n",
    "domain_name(\"https://www.cnet.com\") == \"cnet\"\n",
    "\n",
    "Test.assert_equals(domain_name(\"http://google.com\"), \"google\")\n",
    "\n",
    "Test.assert_equals(domain_name(\"http://google.co.jp\"), \"google\")\n",
    "\n",
    "Test.assert_equals(domain_name(\"www.xakep.ru\"), \"xakep\")\n",
    "\n",
    "Test.assert_equals(domain_name(\"https://youtube.com\"), \"youtube\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def domain_name(url):\n",
    "    for a in ['https', 'http', ':', '//', 'www.']: url = url.replace(a,'')\n",
    "    return url.split('.')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'github'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "domain_name(\"http://github.com/carbonfive/raygun\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Complete The Pattern #3 (Horizontal Image of #2)\n",
    "\n",
    "https://www.codewars.com/kata/557341907fbf439911000022/train/python\n",
    "    \n",
    "## Task:\n",
    "\n",
    "You have to write a function pattern which creates the following pattern upto n number of rows. If the Argument is 0 or a Negative Integer then it should return \"\" i.e. empty string.\n",
    "\n",
    "## Pattern:\n",
    "\n",
    "(n)\n",
    "(n)(n-1)\n",
    "(n)(n-1)(n-2)\n",
    "................\n",
    ".................\n",
    "(n)(n-1)(n-2)....4\n",
    "(n)(n-1)(n-2)....43\n",
    "(n)(n-1)(n-2)....432\n",
    "(n)(n-1)(n-2)....4321\n",
    "\n",
    "## Examples:\n",
    "\n",
    "pattern(4):\n",
    "\n",
    "4\n",
    "43\n",
    "432\n",
    "4321\n",
    "pattern(6):\n",
    "\n",
    "6\n",
    "65\n",
    "654\n",
    "6543\n",
    "65432\n",
    "654321\n",
    "Note: There are no blank spaces\n",
    "\n",
    "Hint: Use \\n in string to jump to next line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pattern(n):\n",
    "    return '\\n'.join([''.join([str(i) for i in range(n,j,-1)]) for j in range(n-1,-1,-1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "65\n",
      "654\n",
      "6543\n",
      "65432\n",
      "654321\n"
     ]
    }
   ],
   "source": [
    "print(pattern(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Complete The Pattern #2\n",
    "\n",
    "https://www.codewars.com/kata/55733d3ef7c43f8b0700007c/train/python\n",
    "\n",
    "Task:\n",
    "You have to write a function pattern which returns the following Pattern (See Pattern & Examples) upto n number of rows.\n",
    "\n",
    "Note: Returning the pattern is not the same as Printing the pattern.\n",
    "Rules/Note:\n",
    "If n < 1 then it should return \"\" i.e. empty string.\n",
    "There are no whitespaces in the pattern.\n",
    "Pattern:\n",
    "```\n",
    "(n)(n-1)(n-2)...4321\n",
    "(n)(n-1)(n-2)...432\n",
    "(n)(n-1)(n-2)...43\n",
    "(n)(n-1)(n-2)...4\n",
    "...............\n",
    "..............\n",
    "(n)(n-1)(n-2)\n",
    "(n)(n-1)\n",
    "(n)\n",
    "Examples:\n",
    "pattern(4):\n",
    "\n",
    "4321\n",
    "432\n",
    "43\n",
    "4\n",
    "pattern(11):\n",
    "\n",
    "1110987654321\n",
    "111098765432\n",
    "11109876543\n",
    "1110987654\n",
    "111098765\n",
    "11109876\n",
    "1110987\n",
    "111098\n",
    "11109\n",
    "1110\n",
    "11\n",
    "```\n",
    "Hint: Use \\n in string to jump to next line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pattern(n):\n",
    "    return '\\n'.join([''.join([str(i) for i in range(n,j,-1)]) for j in range(0,n)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "321\n",
      "32\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(pattern(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1110987654321\n",
      "111098765432\n",
      "11109876543\n",
      "1110987654\n",
      "111098765\n",
      "11109876\n",
      "1110987\n",
      "111098\n",
      "11109\n",
      "1110\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "print(pattern(11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bouncing Ball\n",
    "\n",
    "https://www.codewars.com/kata/5544c7a5cb454edb3c000047\n",
    "\n",
    "A child is playing with a ball on the nth floor of a tall building. The height of this floor, h, is known.\n",
    "\n",
    "He drops the ball out of the window. The ball bounces (for example), to two-thirds of its height (a bounce of 0.66).\n",
    "\n",
    "His mother looks out of a window 1.5 meters from the ground.\n",
    "\n",
    "How many times will the mother see the ball pass in front of her window (including when it's falling and bouncing?\n",
    "\n",
    "Three conditions must be met for a valid experiment:\n",
    "Float parameter \"h\" in meters must be greater than 0\n",
    "Float parameter \"bounce\" must be greater than 0 and less than 1\n",
    "Float parameter \"window\" must be less than h.\n",
    "If all three conditions above are fulfilled, return a positive integer, otherwise return -1.\n",
    "\n",
    "Note:\n",
    "The ball can only be seen if the height of the rebounding ball is strictly greater than the window parameter.\n",
    "\n",
    "Example:\n",
    "- h = 3, bounce = 0.66, window = 1.5, result is 3\n",
    "\n",
    "- h = 3, bounce = 1, window = 1.5, result is -1 \n",
    "\n",
    "(Condition 2) not fulfilled)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bouncingBall(h, bounce, window, n=0):\n",
    "    if n == 0 and not (h > 0 and bounce > 0 and bounce < 1 and window < h): \n",
    "        return -1\n",
    "    else: \n",
    "        return bouncingBall(h*bounce, bounce, window, n+2) if h > window else n-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bouncingBall(30, 0.66, 1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# WORK IN PROGRESS\n",
    "# Differentiate a polynomial\n",
    "https://www.codewars.com/kata/566584e3309db1b17d000027/train/python\n",
    "\n",
    "Create a function that differentiates a polynomial for a given value of x.\n",
    "\n",
    "Your function will receive 2 arguments: a polynomial as a string, and a point to evaluate the equation as an integer.\n",
    "\n",
    "Assumptions:\n",
    "\n",
    "There will be a coefficient near each x, unless the coefficient equals 1 or -1.\n",
    "There will be an exponent near each x, unless the exponent equals 0 or 1.\n",
    "All exponents will be greater or equal to zero\n",
    "\n",
    "Examples:\n",
    "\n",
    "differentiate(\"12x+2\", 3)      ==>   returns 12\n",
    "\n",
    "differentiate(\"x^2+3x+2\", 3)   ==>   returns 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def differentiate(equation, x):\n",
    "    pattern = \"([+-]?) *([\\d]*)([a-zA-Z]?)(?:\\^(\\d+))?\"\n",
    "    result = re.match(pattern, equation)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = differentiate(\"12x+2\", 3) # == 12\n",
    "b = differentiate(\"x^2-x\", 3) # == 5\n",
    "c = differentiate(\"-5x^2+10x+4\", 3) ## == -20\n",
    "#print(differentiate(\"-8x^4+8x^3+x^2-467873x-7\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method groups of _sre.SRE_Match object at 0x10b1f2618>\n"
     ]
    }
   ],
   "source": [
    "print(a.groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def differentiate(equation, x):\n",
    "    calc = []\n",
    "    for c in equation:\n",
    "        if c in "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45, 87]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([1, 5, 87, 45, 8, 8])[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kata: mean square error\n",
    "https://www.codewars.com/kata/51edd51599a189fe7f000015/train/python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete the function that\n",
    "\n",
    "* accepts two integer arrays of equal length\n",
    "* compares the value each member in one array to the corresponding member in the other\n",
    "* squares the absolute value difference between those two values\n",
    "* and returns the average of those squared absolute value difference between each member pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(a, b):\n",
    "    return sum((x - y)**2 for x, y in zip(a, b)) / len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hamming Numbers\n",
    "https://www.codewars.com/kata/526d84b98f428f14a60008da\n",
    "\n",
    "A *Hamming number* is a positive integer of the form 2i3j5k, for some non-negative integers i, j, and k.\n",
    "\n",
    "Write a function that computes the nth smallest Hamming number.\n",
    "\n",
    "Specifically:\n",
    "\n",
    "* The first smallest Hamming number is 1 = 203050\n",
    "* The second smallest Hamming number is 2 = 213050\n",
    "* The third smallest Hamming number is 3 = 203150\n",
    "* The fourth smallest Hamming number is 4 = 223050\n",
    "* The fifth smallest Hamming number is 5 = 203051\n",
    "* The 20 smallest Hamming numbers are given in example test fixture.\n",
    "\n",
    "Your code should be able to compute all of the smallest 5,000 (Clojure: 2000) Hamming numbers without timing out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamming(n):\n",
    "    h=[]       \n",
    "    h.append(1)\n",
    "    n -= 1\n",
    "    while n:\n",
    "        i=j=k=0\n",
    "        while h[i]*2<=h[-1]:\n",
    "            i+=1\n",
    "        while h[j]*3<=h[-1]:\n",
    "            j+=1\n",
    "        while h[k]*5<=h[-1]:\n",
    "            k+=1\n",
    "        h.append(min(h[i]*2,h[j]*3,h[k]*5))\n",
    "        n-=1\n",
    "    return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = hamming(5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Chain adding function\n",
    "\n",
    "https://www.codewars.com/kata/539a0e4d85e3425cb0000a88"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0\n",
    "def func(b = None):\n",
    "    global a\n",
    "    if b == None:\n",
    "        return a\n",
    "    else:\n",
    "        a += b\n",
    "        def func2(c):\n",
    "            return func(c)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'NoneType' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-4f1a18e85728>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not callable"
     ]
    }
   ],
   "source": [
    "func(1)(2)(3)(4)(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# WORK IN PROGRESS\n",
    "# Conway's Game of Life - Unlimited Edition\n",
    "https://www.codewars.com/kata/52423db9add6f6fc39000354/train/python\n",
    "\n",
    "Given a 2D array and a number of generations, compute n timesteps of Conway's Game of Life.\n",
    "\n",
    "The rules of the game are:\n",
    "\n",
    "1. Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.\n",
    "2. Any live cell with more than three live neighbours dies, as if by overcrowding.\n",
    "3. Any live cell with two or three live neighbours lives on to the next generation.\n",
    "4. Any dead cell with exactly three live neighbours becomes a live cell.\n",
    "Each cell's neighborhood is the 8 cells immediately around it (i.e. Moore Neighborhood). The universe is infinite in both the x and y dimensions and all cells are initially dead - except for those specified in the arguments. The return value should be a 2d array cropped around all of the living cells. (If there are no living cells, then return [[]].)\n",
    "\n",
    "For illustration purposes, 0 and 1 will be represented as ░░ and ▓▓ blocks respectively (PHP, C: plain black and white squares). You can take advantage of the htmlize function to get a text representation of the universe, e.g.:\n",
    "\n",
    "```python\n",
    "print(htmlize(cells))```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_generation(cells, generations):\n",
    "    return cells #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'test' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-2b38064d951a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m          [1,1,1]]\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0mtest\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdescribe\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Glider<:LF:>'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mhtmlize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mstart\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     17\u001b[0m \u001b[0mtest\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Glider 1'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'test' is not defined"
     ]
    }
   ],
   "source": [
    "def htmlize(array):\n",
    "    s = []\n",
    "    for row in array:\n",
    "        for cell in row:\n",
    "            s.append('▓▓' if cell else '░░')\n",
    "        s.append('<:LF:>')\n",
    "    return ''.join(s)\n",
    "\n",
    "start = [[1,0,0],\n",
    "         [0,1,1],\n",
    "         [1,1,0]]\n",
    "end   = [[0,1,0],\n",
    "         [0,0,1],\n",
    "         [1,1,1]]\n",
    "         \n",
    "test.describe('Glider<:LF:>' + htmlize(start))\n",
    "test.it('Glider 1')\n",
    "\n",
    "resp = get_generation(start, 1)\n",
    "test.expect(resp == end, 'Got<:LF:>' + htmlize(resp) + '<:LF:>instead of<:LF:>' + htmlize(end))"
   ]
  },
  {
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}