computing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computing\n",
    "\n",
    "Its all about algorithms and data structures. Some problems are from google tech dev guide, some from interviews and elsewere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decompress a compressed string\n",
    "\n",
    "print a codified String of the form `number[String]*`, where String can again be equal to `number[String]*`.\n",
    "\n",
    "Code snippet was for python2.X so had to change `xrange` for `range`, do some indentation and change `basestring` to `str`.\n",
    "\n",
    "Learnt `yield` reserved word and `sys.stdout.write()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python\n",
    "import sys\n",
    "def decomp(text, start=0, times=1):\n",
    "    \"\"\"\n",
    "    Iterate over and decompress the compressed string.\n",
    "    This approach makes use of nested Python iterators, which is a very clean way\n",
    "    of expressing expansion of nested iterated items.\n",
    "    Args:\n",
    "        text: The entire string to decompress.  It's unobvious, but nice\n",
    "          to have the whole string plus an index; this allows any error\n",
    "          detection code to report the absolute index of a problematic\n",
    "          character.\n",
    "        start: The starting index within 'text'.  We decompress from\n",
    "          'start' up through the matching close-brace or end-of-string.\n",
    "        times: The number of times to repeat decompression.\n",
    "    \"\"\"\n",
    "    # Repeat iteration over our sub-chunk N times.\n",
    "    for j in range(times):\n",
    "        i = start\n",
    "        # Until we hit the end of the string, or end of our chunk...\n",
    "        while i < len(text) and text[i] != ']':\n",
    "            # Emit letters as themselves.\n",
    "            if text[i].islower():\n",
    "                yield text[i]# If it's not a letter, it must be digit(s).  Convert to integer.\n",
    "            else:\n",
    "                sub_times = 0\n",
    "                while text[i].isdigit():\n",
    "                    sub_times = sub_times * 10 + int(text[i])\n",
    "                    i += 1\n",
    "                i += 1  # Skip past open-bracket\n",
    "                # Start an iterator over the sub-chunk.\n",
    "                for item in decomp(text, i, sub_times):\n",
    "                    # Iterator generates many characters, and then at the very end,\n",
    "                    # it generates an integer.  Provide characters up to our caller,\n",
    "                    # and use the integer to advance our index 'i' to end-of-chunk.\n",
    "                    if isinstance(item, str):\n",
    "                        yield item\n",
    "                    else:\n",
    "                        i = item\n",
    "                # Advance 'i' to the next letter, or skip the close-bracket, whichever.\n",
    "            i += 1\n",
    "    # Don't emit the trailing integer if we are doing the outermost call.  This\n",
    "    # test could be moved to the decompress() call instead; we would check there\n",
    "    # to see if the result item was basestring or int, just as we do above, but\n",
    "    # I suspect that check would be more expensive than a simple integer\n",
    "    # comparison here, where the type is known.\n",
    "    if start > 0:\n",
    "        yield i\n",
    "def decompress(text):\n",
    "    # We could wrap 'text' to add a leading '1[' and trailing ']' to allow a\n",
    "    # little bit of simplification in the logic in decomp(), but the\n",
    "    # simplification would lead to harder-to-read code, as well as requiring\n",
    "    # O(n) additional time, and a temporary requirement for O(n + 3) additional\n",
    "    # space during the copy operation.\n",
    "    #\n",
    "    # This is O(decompressed-length) for speed (probably), and up to\n",
    "    # O(compressed-length/4) for additional storage.  In this implementation,\n",
    "    # the storage requirement is well-disguised: It appears on the function call\n",
    "    # stack, rather than in declared variables.  E.g., consider a worst-case\n",
    "    # input of: 1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[xx]]]]]]]]]]]]]]]]]]]]\n",
    "    # which would require a stack depth of 20.\n",
    "    #\n",
    "    # The (probably) for the big-O depends on how well Python implements\n",
    "    # resumption of nested iteration.  At worst, the string above would require\n",
    "    # a full stack descent, then ascent for *each* of the two 'x' characters,\n",
    "    # for a total of O(n^2) time.  Another very well-hidden possible cost.\n",
    "    for letter in decomp(text):\n",
    "        print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "a\n",
      "b\n",
      "c\n",
      "a\n",
      "b\n",
      "c\n",
      "a\n",
      "b\n",
      "a\n",
      "b\n",
      "a\n",
      "b\n",
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "decompress('3[abc]4[ab]c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Openning JSON file\n",
    "\n",
    "Not sure if it goes in this notebook hehe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'personasdesaparecidas.json'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-7e60f8074a0a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'personasdesaparecidas.json'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'r'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'utf8'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mdatastore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'personasdesaparecidas.json'"
     ]
    }
   ],
   "source": [
    "with open('personasdesaparecidas.json','r',encoding='utf8') as f:\n",
    "    datastore=json.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Facebook interview question\n",
    "\n",
    "If I remember well it was about i times printing the product of all list items except the one on i position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prints_products(list_in):\n",
    "    mult=1\n",
    "    num_zeros=0\n",
    "    idx=0\n",
    "    \n",
    "    for i in range(len(list_in)):\n",
    "        if(list_in[i]==0 and num_zeros==0):\n",
    "            idx=i\n",
    "            num_zeros+=1\n",
    "        elif(list_in[i]==0 and num_zeros==1):\n",
    "            num_zeros+=1\n",
    "            break\n",
    "        else:\n",
    "            mult*=list_in[i]\n",
    "    if(num_zeros==1):\n",
    "        for i in range(len(list_in)):\n",
    "            if i==idx:\n",
    "                print(mult)\n",
    "            else:\n",
    "                print('0')\n",
    "    elif(num_zeros>=2):\n",
    "        for i in range(len(list_in)):\n",
    "            print('0')\n",
    "    else:   \n",
    "        for i in range(len(list_in)):\n",
    "            print(mult/list_in[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5670.0\n",
      "810.0\n",
      "1890.0\n",
      "630.0\n",
      "1134.0\n",
      "945.0\n"
     ]
    }
   ],
   "source": [
    "prints_products([1,7,3,9,5,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find longest subsequence of S from a list D.\n",
    "[link](https://techdevguide.withgoogle.com/paths/foundational/find-longest-word-in-dictionary-that-subsequence-of-given-string#!)\n",
    "\n",
    "I tried a good approach through a greedy algorithm however I could easily improve it if I could order D and try the subsequences as they become shorter, the first found is the answer.\n",
    "\n",
    "There are other answers that attempt to look for the appearances of the words and then look from there. Efficient binary search can improve them even more.\n",
    "\n",
    "I copied the snippet code provided however the indents are wrong and its running python2.X I think.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def longest_subsequence(S,D):\n",
    "    maxi=''\n",
    "    while D:\n",
    "        S2=D.pop()\n",
    "        if is_S2_a_subsequence_of_S(S,S2) and len(maxi)<len(S2):\n",
    "            maxi=S2\n",
    "    return maxi\n",
    "def is_S2_a_subsequence_of_S(S,S2):\n",
    "    j=0\n",
    "    i=0\n",
    "    while i<len(S) and j<len(S2):\n",
    "        if S[i]==S2[j]:\n",
    "            j+=1\n",
    "        i+=1\n",
    "    if j==len(S2):\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'pop from an empty set'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-111-02590e89ca2d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mis_S2_a_subsequence_of_S\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mS\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mD\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'pop from an empty set'"
     ]
    }
   ],
   "source": [
    "is_S2_a_subsequence_of_S(S,D.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = \"abppplee\"\n",
    "D = {\"able\", \"ale\", \"apple\", \"bale\", \"kangaroo\",\"abppplee\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abppplee'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "longest_subsequence(S,D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python\n",
    "import collections\n",
    "import sys\n",
    "def find_longest_word_in_string(letters, words):\n",
    "    letter_positions = collections.defaultdict(list)\n",
    "    # For each letter in 'letters', collect all the indices at which it appears.\n",
    "    # O(#letters) space and speed.\n",
    "    for index, letter in enumerate(letters):\n",
    "        letter_positions[letter].append(index)\n",
    "    # For words, in descending order by length...\n",
    "    # Bails out early on first matched word, and within word on\n",
    "    # impossible letter/position combinations, but worst case is\n",
    "    # O(#words # avg-len) * O(#letters / 26) time; constant space.\n",
    "    # With some work, could be O(#W * avg-len) * log2(#letters/26)\n",
    "    # But since binary search has more overhead\n",
    "    # than simple iteration, log2(#letters) is about as \n",
    "    # expensive as simple iterations as long as \n",
    "    # the length of the arrays for each letter is\n",
    "    # “small”.  If letters are randomly present in the\n",
    "    # search string, the log2 is about equal in speed to simple traversal\n",
    "    # up to lengths of a few hundred characters.         \n",
    "    for word in sorted(words, key=lambda w: len(w), reverse=True):\n",
    "        pos = 0\n",
    "        for letter in word:\n",
    "            if letter not in letter_positions:\n",
    "                break\n",
    "            # Find any remaining valid positions in search string where this\n",
    "            # letter appears.  It would be better to do this with binary search,\n",
    "            # but this is very Python-ic.\n",
    "            possible_positions = [p for p in letter_positions[letter] if p >= pos]\n",
    "            if not possible_positions:\n",
    "                break\n",
    "            pos = possible_positions[0] + 1\n",
    "                # We didn't break out of the loop, so all letters have valid positions  \n",
    "        else:  \n",
    "            return word\n",
    "            \n",
    "find_longest_word_in_string(S,D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = \"abppplee\"\n",
    "D = {\"able\", \"ale\", \"apple\", \"bale\", \"kangaroo\"}\n",
    "find_longest_word_in_string(S,D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sum nums\n",
    "\n",
    "Is about summing the numbers in a string that can be separated by anything that is not a number. Implemented with regex.\n",
    "\n",
    "```java\n",
    "public int sumNumbers(String str) {\n",
    "  str=str.replaceAll(\"\\\\D+\",\" \");\n",
    "  str = str.replaceAll(\"( )+\", \" \");\n",
    "  String[] arrOfStr = str.split(\" \");\n",
    "  int sum=0;\n",
    "  for (String a : arrOfStr)\n",
    "      if (a!=\"\" && !a.equals(\"\"))\n",
    "      sum+=Integer.parseInt(a);\n",
    "  return sum;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1234', '234234', '23434', '234234', '43652345', '2345', '3452345']\n",
      "47600171\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "s='1234 234234 asdfasdf 23434 234234    43652345,2345,3452345'\n",
    "l=re.split('\\D+',s)\n",
    "print(l)\n",
    "nums=[]\n",
    "[nums.append(int(num)) for num in l if num != '']\n",
    "print(sum(nums))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Design an explosion mining game.\n",
    "\n",
    "Given $n$, design $n*n$ matrix `terrain`, with $m$ **mines**, $terrain[i,j]$ is the value of adjacent mines of position `[i,j]`.\n",
    "\n",
    "* A **mine** is a list of the form $[i,j]$ where $0 \\geq i,j \\leq n$, `mines` is a list of $m$ **mines** objects.\n",
    "* `terrain[i,j]` is the sum of all mines over a $3*3$ subkernel of terrain centered in $0\\geq$ `[i,j]` $\\leq 9$.\n",
    "* $m \\leq n*n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3600"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60*60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2d3143b31fac49ab8565fcbb72c2723d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3600), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N=60\n",
    "terrain=np.zeros((N+20,N+20))\n",
    "remaining_mines = 1000\n",
    "remaining_cells = N*N\n",
    "mines=[]\n",
    "frames=[]\n",
    "fig,ax=plt.subplots(figsize=(5,5))\n",
    "for k in tqdm(range(0, N*N)):\n",
    "    chance = float(remaining_mines) / remaining_cells\n",
    "    if random.uniform(0., 1.) < chance: \n",
    "        i,j=np.unravel_index(k,(N,N))\n",
    "        mine=[i+10,j+10]\n",
    "        mines.append(mine)\n",
    "        terrain[mine[0]-1:mine[0]+2,mine[1]-1:mine[1]+2]=terrain[mine[0]-1:mine[0]+2,mine[1]-1:mine[1]+2]+1\n",
    "        remaining_mines -= 1 \n",
    "        if (len(mines)%10==0):\n",
    "                ax.imshow(terrain.T,cmap='magma',aspect='auto')\n",
    "                ax.axis('off')\n",
    "                fig.canvas.draw()       # draw the canvas, cache the renderer\n",
    "                image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n",
    "                image  = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n",
    "                frames.append(image)\n",
    "                plt.close()\n",
    "\n",
    "    remaining_cells -= 1\n",
    "imageio.mimsave('minas.gif', frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d8aef507cd724f25a45f4e22515a4497",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=2000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n=100\n",
    "m=2000\n",
    "mines=[]\n",
    "terrain=np.zeros((n+20,n+20))\n",
    "frames=[]\n",
    "\n",
    "fig,ax=plt.subplots(figsize=(5,5))\n",
    "pbar = tqdm(total=m)\n",
    "while (len(mines)<m):\n",
    "    mine=random.sample(range(10, n+10),2)\n",
    "    if mine not in mines:\n",
    "        terrain[mine[0]-5:mine[0]+6,mine[1]-5:mine[1]+6]=terrain[mine[0]-5:mine[0]+6,mine[1]-5:mine[1]+6]+1\n",
    "        mines.append(mine)\n",
    "        if (len(mines)%10==0):\n",
    "            ax.imshow(terrain.T,cmap='magma')\n",
    "            ax.axis('off')\n",
    "            fig.tight_layout()\n",
    "            fig.canvas.draw()       # draw the canvas, cache the renderer\n",
    "            image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n",
    "            image  = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n",
    "            frames.append(image)\n",
    "            plt.close()\n",
    "            pbar.update(10)\n",
    "imageio.mimsave('minas.gif', frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAALICAYAAACJnL11AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3bFrH2e6L/A3dxf3zrLGYFLZqkS4hSuBYNnG4Oqyf4Exp9l2i1+xnToX6rYKFw4h+weclAI3hwMCVeJyuAguOKqCIEjY6Q1LbrHVkjzzPMn7aDxyPp925Jn5zbwz/jLF9/nkhx9+GAAAwI/9jw99AgAAsFXCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAg8NsPfQJ8eI8//dMPs/s4vPc/F7efvv/v2UOMy3dffzK7j+y3Zr9jjDEOfr+8/ewmP4/seqzxWysq12Mr93YrOq77Gu7KM1vR8VxnKtcj+71rPZOZ7B02Ru09tuQurR/I+LIMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAoSQfuUoJ/iol9zfzx9hKof/hg3fJX3ya72SF67F7lB8j/y3Z9jHGxfxwi49pME52HpWBEPl9WXZ6XViD2T6upndxZwa0jNHzDnvx8OjWh6NU1k+msr7ObpbX0Brv/LvkrgzG4ZfxZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAnmU249fU25n91rX6se+Kym/NrunBmL9eWY/uGGPs9uc6kscYY+/p94vb35zfX9w+29M8xhhnG3neKt2ya3RbZ73D1ePMnsdWdPTNZ/uoPG+Zjm7ijvdxZW2c3eR/w4fhyzIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAAKGkmxYpQg9UxnmUCltT21kgEEm+61ZOf0YlfvybXoeu0fL16tjCEeH0+t8sMA613Qb1rjmY+RDR7L70jHYojJcpbI+pjW8W46vKu+4+aESL59fLm7/8uRx4TyWdVzz2vVYfo8dXM/fl+y3tDxvK/3flJ1r7Zlcvh6nV/XzoZcvywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAT0LNPirnQ1Z/3FLx4epX2/WUfy2c3PO6dfKjtO5Z4cp72deWd01qO8Vody1h2b3beKSldqRw/u7L09KzxLWY/y3tPv033sjeW/aekVLqzjSi95Jrvmlc7frB+7Q0eHdv7c5zrecz3dxMvOblboAi+ovBeya1rprOd2+LIMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAoSTwAXQMFMkGMXQM4VhrwEqmY+hNz2+ZHyxQGW6R6bi3mY4BGx3XvGPgSIeXzy/nd3Ke/0k2vKJnME4+bGj2ulfWeb4+1hkokg1OqgwD+eLzfKBVpuPdwO3wZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAnmX4SK3VkZx1lFb6Wjt6lLPjrNVhmh2n0pM72y9bu/fLx6jsI/utHfe1Irv3lTWY/ZaO3um8/7ine7jj2c/uXUf/dXbN13qHZb8le8dV9tHhz7d+BCK+LAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAIGAoyYZ1FOlXBiAcXC8fp2M4Qcc+jq/mBxxcvvv6k6XtlfL506vl7R337WDcfsH9GNUBGYmL2z/XyjXd7c//lmxoRMugjobBFOn6WWkAS8fQiOyZfPHwKH0mO35vy7OQqFyvbBhI9v7psns091xXrufxxfKzsMawIqjwZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAnuUNq3SHvnx+ubj93rMn6T72Xn+z/Acnj9N9ZJ2aZzfz3bJZHyv/qtaBm9+XNWRdqJVnYe/p94vb35zfz8+jYR1nOrp2x818d+xaXcyzSl27DddjjWeh8ls63nOVvviPRUd3fmatruaOXmluhy/LAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAIGEqyYZXhBYfJoIW9kQwcKcgGNYyRD4Q4uJ4v/O8ol+8o/O8YoFG5prMOH8zv47Rw3zqK9HePlq9p5XqlA3jO3/6cU/pJHQMyDB74V9lz3TEQouO+rTXEZY0hGh1rMP//af6dn70XxhjjxcOjW/9/oXJPKueaahmuw23wZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAnuUNK3VhXiS9jBfzXZelftHz5c2Vntys07fSt5pds44O08zxVX7fzhr6NLP7skaXc0Wl2zrrSj27ydfx7tVyj3KlM/rl88vlY1zn9y297tkzO/J7W+lgz2T76Ojirdz77JncynkcjPlntqWLt8Hp1Yc+g3/qeYctP9dr/daOZ1IH+3b5sgwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAz/KGdXSDVlT6i++K2d9S6pTONHQod9h7+n36N/eePVncvl84zuGrzxa3f/H5cofyGD29wsdJp3jHvV2ruzo/znx/ekcvbPa8Vd5Pa7x/1uhX75Ld+47nevzl9q95ZX1lz2SlGz1/VvLfmvW8d6i8f7Iu78o6ruQGfj5flgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEDCU5CNXKfzvGNaQDYTo0DIwJFEZOlEpys989d3RdHF8WlB/kt/7l+Obxe3pcIORD0nYG/kQhS9PHi9ur9z7bAjCWgNFsvVx+v6/030cXC/fu47fcnazfJ6V4QbZMIfdo3UG9KT3vvAezJ7JjsEVu/38vmXPU+WZvCuy+1Z5Vs42MgQqPdeNnCe/jC/LAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABPQsk3a2rtUrnPYGF3oqsz7erNdzjPy35vvIZb+10gubddh2dPH+449/SP/m3vRRxhgn0xW2qdI6Pp/fR8f6yGRdvG/O79/+SYz8eetYg5Vr3tHBnr5/OlwU3mHJ78260SsOH+TrY7Y7v9KRnKl0fXe8SyHjyzIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAAKGkmzYKiX5Iy+f7yj8f/HwKP0tWXn8bn9+wMHhg+ldjGxwyRpDKSrHObspDBVI7v3u/D/SXWRDIyqDKbJzrd37+fPoGMCT6RiSkA0dqfyOjqERHbIBK6cnt39PxsiH/FR0PPvZPg43MnCm47dWho6ssY81/q/dyvPGL+PLMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAE9yx+5lm7Hm/n+0Yr0XC/mz6OjM7qjXzTr2q2c5xp9zpW+3pa+5ztyHpW+554u749D5b7tjeWe5YpKh3Z6Hknfc8nJ48XNx1fz7+OD6/w9+PL55fRxxvny5o7nKbPWrIFMpRt9jf9bdDV/OL4sAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgYCgJ4/Ld158sbe8oht89KgwUSYafdJS+t5T1J4MHKvIBGvk+soL6SpF+pjJEoWP9dJzrKkMBCkM2OqwxcKZDdp5rPbNvzu9PHyfbR8vQkpXce/Zkeh/7z5a37169XdxeGZ6ylaEja6gNzkneLysNCOPHfFkGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgoGf5juvop91K12VHJ2vmy4aO5Kx7uNIpvduvdG4uq/SYZrLuz8oxvvj8aHH9dKzRSu9wx/pZYw3elQ7liqzru9ILe7iRfuOsQ/v0JO/Yzt4NWSf5GGO8eLj8PHV4//qb9G9mu5orvcJnDb3BHX3z2T7WeC+MUeh5z543bo0vywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACBhKsmGVMvWO4RbjYr4YPlMpqM+GAtwVlaEThw/mj1O5ppl04MN5vo+O+9ZStp8MOOgYLNAxUKTyW7Nnf43hBJXhGB0DZ7L1szfmh5JU1mjHvc2uR2UAVLaP0vvl1dvkL5YHwYwxxt7IBpfk+5hVWefZoJeOddzx/1dluM5Btk4bhrjwy/iyDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEDP8oZVemEr3Y2pi9vvN+7oOa1cj6wPMzuPjq7Vte7bm/P5ntOOfWQq1+NgzPecjtHQOZ7o6Mdepde8of+4ct+y56XSk5vd+4r9v/5ucfve66wzeIzDhmche790/NbKO+o4eaeXur6TdZrto7IG1+gL7+hXz9bXGPkau/fsSX6gk+VK6DWuFz/Nl2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAQMJeGjMjt0pKP0vTTY5OTx4ubaEI5llcEn2VCSyjCZ46v5a5YPMJgfnLPWwJns3lX2kV3Ty3dff7K0/fGnf1qebjB6Bpds4RhjjPG+MHQk0zLg6Xx5c8dwpso7KlsfH5Nsre8eza/ByvrKho78449/SPdx+OA/FrcfX6W74Jb4sgwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAz/KGVXphD5Oe3F+brOP28MHyv9+Nz9JjVLpSM9m9zc6zIuv9HGOMcf42OY9K3/M6XbqZ2XvfZbbre4z5HuVKv3HW91w5z6zzt6NnOesCHyO/5i+fX06fR8Xxxfy7oeOavnh4lPZsz57Hx9Tl3NFrn3Uxv3m1/K4dI18/l+/+9tFc87vGl2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAQMJdmwrBR+jHyIxt7T7wv7SM6jYQhHrfS9odA/OdeO8vnM8VV+3zIH1/nggXzQwu/SfWTrozIQIlMZbtHj9ofFVFSe29tWOoeb+YEhu0fL+6g8b9kzW3n/pEN+NjK8qXJfZgfSjNFzX7L/W7LBJx2/tUPtmU7W4Mk675YtvDv4ab4sAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAENCzvGGVDsqs6zLrUF5LR1dqxcHvl7dXeqczeyPZx8l8f22lB/XesyfTx8l6lNe6b3fFVrpjD+/Nr7HsWWnpnLZ+frasR7ly77P3R8d7MP2/5SI/z0pn9BrW6Fdf473A7fFlGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAUNJ7risCP3gen54wa9paEA2pKOicr2ygRCVYQ57r79Z3F75Ldlxjq/WGcKRDSfYPZpfxxWVoSOZjkEL2eCJbP1UZOu0dC1u5u9LxzXP1kfHEI6Od0NFx8CZTOW3ZNcs235QeIdl66eyNjqul4EiZHxZBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAIKBnecM6+lo77PbfpX+T9fVupav5y5PH0/s4fLB8PSrXq0PWlVrpas7uS6XD9MXDo8V1WulKzXpM1+gu3pKsRzlbgxVnN8vro9Itu8Y7quM8Ds8/S4/T0cXc0debPU+l82h4H2c9yR1r8K6orHN9zx83X5YBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAwlOSO6yhC7yiXz/aRDUCoqAy3OBjL16Pjt7YU/idDJzp0nEfH9Tq4ztdoVvq/e5TvI/u9lWt+epX/zazKMzt73SsDaSrPU2aNQS89AyHy65kNLKo8T5fv/jY9NKLjvoyb5etROkayjzHm3+nZM9nxPK61zrNhVJWhN1+eLB+n8iwYXHI7fFkGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgoGd5wyrdjllP5cvnl01nM+eg0PuadstezHe6Hl/Md4PeFZVe4Wx9/ObVv6X7+M1//tfyH7x6m+7jOOlTrXTcZn2qa3QoV5R6XxvW+qxKp2ul/3pWS9du4f3TIbtmW+nAXaM3+M35/fQY2X1Zo8d7jPy+vHh4lD4L2fW49+xJeh6H58vvyuw9ye3xZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFDSTasMrzgYCyXtleK4dPz6Bgo0nScWdmgjsrwizV0nEdlKElWlP+PwnHev/4m+Yt8DWbDLSrr6+B6eR8d17Q0UKTB7HEqwxyyv6msn+y+ZIMaxsjfUWc388OZ1pJd08qglw5rXI+O/1uyoUiHDYNNtjKM6B9//EP6N3uv/31x++EGhhX9WvmyDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEDP8oZVulI7HF909BvffkdyhzV6lHf7eSdwR6f0V98dfbK0/YvPj1bpdM36Vtfq6c5UuouzvudR6PzNZPetw4uH8/e+ck+yHuWsx3uMMcb528XNpc7phvuSP7fzz+xWOn87dLzDTk+W91FZg9nfHD74LN1H9rx09Fb/5j//K/2b/5e9S1fqeefHfFkGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEDAUJIN6yjjP7vJi+Nbis4bhgJk59ExpKUyMGRWNqhhjLyM/9emcs3SfYzlfZz9fZ0hP9kAg8rAkNlnsuNZKQ2dOF/evDe+KRzn8eL2w3vzz0plqET2eysDMrJ9pENvxhjHV/Pv4559LG+/fPe3xeE6jz/9U7rOK9djVmUdZ+ujY2jS+9fzz8IY306fB7+ML8sAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAE9CzfcR0dyZfvvl7sy6yodGpmOrphM2t0qWbds2OMcXaT/82syjFeJt2f9wrHyTqSK53Sb87vL++j0JXa0YW6hkrnb9Zbnu2jcu9L5zEpu69j9DwL6XuwoQd+jHW60bP3YOWdn73TO97X2T4q/6/k55Hft+y573gvVHrg7z17srj94tXbdB/Zs9DxfzW/jC/LAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABPQsb9hanYodnZtrqPTCzne2rtOl2tFx23HfvjxZ7jF9OZZ7mLtkPcqlzujny12oBy1dzev0PZ/d3P46zM6z0m3dcd+y3uA1+tcr53FQ6PzNVNbGGvf+rqisn+x6VXqpszW2y09j7CXvytPrx+k+OuYmcDt8WQYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQMBQElKVoQAdQzYyHQMOUjcdAxC2MVSgMtQmHWySDC0ZY4yXzy+nto8xxpvz+4vbK4MavjzJS/9nVYZKVIZ5pPvI1nGyTivPwW58trj9rgxXWcv8wKPa9cjuXcdzvcagl7WGXWX/91SGyWT3tvJM743loUiV92D2vq1c07WGmf3a+LIMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBA4JMfflilCpENe/HwaHER7PbzvtW9p8sdkxVZ126l63K2C7XSF50dY43O6THGOL6a7JQeed9q5d5nOtZGRcf6yZS6UhPZeY4xxv/6P98ubu/oUs2e+w7TveejpxO447nu0HEeHde0Yo0u5g4d79uP6d7rWb4dviwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACDw2w99Anx4WdH5wXWhnP684TySoRFrFMd3qJxnds07BgLsHq0zVCAd9tGwNiqOL+aHjmQOCwNFsiEslSEtu+SZywaKVIYXZGtsreEXmY6hE4cP8uE6ZzfL66fletzcjUEfY6wzXKnjnZ7d28rzlj3Xa7xbxsiv+enVKqfBT/BlGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICeZVK1Lsz5Hsq8C3X+GMdXSVdqoQd1jY7kuyRfH/P37eXzy/RvDhp6ujs6x/dG3us6K+3AbejzvXz39Sez+3j86Z8W+6DH6HlesndH2gVeULkeld+7ho57l3V5d/QwZ/soPbPJvT09WacjOe3hvkMd2/yYL8sAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgYSrJhHYX+leL4bB9p2foY4/QqP07mLCltr5zHGjquVzY0YK3hBmsMFMmHzeSDBb48eZzuIx0406A0oKdwrrPH6RgIsYaWQR6lYQ63P5CmomMYSKbybuh4f6wxXCm7L6V7spFhHx3/F9cGgPEh+LIMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQM/yHZd1N1Y6brOO0kqHckcn524/OdeL+WN0dKlm1/xg5Of54uHRrfcor9XZmV2Pvaffp/s4PWnoc16hF7aipTs2k3TLdnS6Vrp6O/rCd4+2cd+y9dNxPTpU1nlHD/fs+6Pyf8/hg+QPCu/8jucpu6bp/00j74qv2MosAX7Ml2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAQMJbnjsuL3ykCIcb68+bgwlCQrU+8YGNExaKHjGC+fX84dZIwxTh4vbq4MgunQM9Rm2Zvz++nfrDLIoyBbpx3nURlckQ3ASM8jGVpSUXlmK4M6Mtm973juO/axlaE3HTqGVWUqQzo6nvuOwTgdg5XS/0cv8uuxxlAbfhlflgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAjoWd6wSufii4dHyx2ShW7HvIP023Qfu0fzHaRpl2XSY/lPy793jf7ie8+e5H90Ml1PuxlZn2ql+/qr746mu1K30oObnUf6zI78eZrtE6+odBNnfc6VfWSdv/t//V2+j1dv8wMlzm7meoW7ZGu9ss47+tE79pH78O/rLtn/XweF3uns3uth/nB8WQYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQMBQko9cZSjAy+eXy39wsk4JfjbMY/9ZYSfpcILbH1xxURqQMD8AoWMIxxrDCyrDHipDR9Zw+v6/F7dXhgJ0DJWYlf2OioPCs1IaXJI4TgYn7QrPUzYYp6Ljmq2hdJ4X82us495msuE6lWel43lLz+P8froPPm6+LAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABDQs3zHZZ2bla7UTEcXb8X7199M7+P0+vHUv8/6NscYY5wsH6O0j43o6KfN1kelrzVbp5VruttfPo/Sb725/Q7kivyZS35L4Xd89d3RYmf0F58fTXdfV94dWQ935b5l66OjQ7nS15tds9I6fjS/BrPu/C+Td1iHtL9/5P3FlXt/elU+pXgfyfrYjc/Sfew9/X55+1jePsYYZ3/fxvuHH/NlGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAUNJNuzxp39KhwJkRfmVoQBvGorhs7L9ymCKcV74mw3oGDqSXo+VhmN0DJzJyvhPT/L1Mz2Eo3AetfW1fJzKM3n57uvFYR+VfWRDELKBD9mwh8p5VIZwZLKBI2PkAyE6hk5k92SM/HpU3mEd9yVTeR9n7/TKO2x6kMtJvn6y57421Gb5OB1Dkfb/mi6f8f51PnRkVsf7h1/Gl2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACepbvuLQL8yLvusz7NL9N99HRLXuc9Kl29L52yK5X5TyPryY7TEd+zV88PEqvedbZ2tHTXdHRkXzv2ZNkH2/rJ3SLaut4rv+60sVbea5/TTo66zvWYPYs7I28zzc7j4O/pK+GtN96jfdxbR0v6+jFP3xVeXfMvwfZLl+WAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQMJRkwzpK3w9+n/9NVj6/FZXfsoqb5ftSOs+GfXzx+fLQkd3+3GCLMdYbCnCYDDYpnUdpcMCcyjOZDeDZPcr3kQ5poV02bOjgunDfXn+zvP3pzzqln1QZAnR6sjx0pDIUaXrQVPKO+6f598saKu+fjuEn+YAwPhRflgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAjoWd6wjs7Fg5F3XXb0OWedmx3HuCsqfZvpvS10lK7Ro1z5LVkndMd5Vs7j7Ga+s7WjyzvrUT58MH89vjx5vLi9o/O1ci2y46zVOZ6dR9oJXFC6psl92YqOvvBsH5X7lj0LlX7j7Dgd7+Ov/u9y5/QYY/w52d6xBvlwfFkGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEDAUJI7LiuGrw1AmB/mkA0WqAymqBTQb0HHsJiOQv+9p98vbs8GV2xJx73/6rujxcEBpaEADQMysmcuu28V2TEOH+T7OLieHxTUMVyHf5UN0eh4/1SsMUiqYyhSh2yQ0IuHR+l4OKxcAAAKZElEQVS7Y637wofhyzIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABPcsbdvnu68Xe2DHy7tiOLtWtqHRuVnpwZ1XuSya7b6dX+T7O/r58byu9nx19z5lKr/DpyXLfasd5tDxPY53naQsd2ZXnLbumlW7rrOO2oyu+8jxlSj26Sa90RxdvxzquWONd2iE7z7W6mvm4+bIMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAoSS0yMr2d+Oz6WNUSvKzAvpsH5UBCC8eHi0PFFlpGEh6rhf5AI01Bg9UBmx0DA748/wuUrUBGcvenN9P/+b4ankNZeunQ2UdZ8MvOs7z+GJ54EiX7Fw7BoqspWNYTLbWs2FDpXWe3NuOQTBb0THMig/Hl2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACepY3rNSFmXSDVnphT6+Xuy47OnCzY1RUziPr5TwY852cu/35fuMOWc/pbpWzyFXufXbfKn29ledlVuW3dHQxz3b+dnS6Vq7n7tH8+yfX0LNc6OLtuKZr9E5nPe9j9DxPp9fL2/fG8vunIut5P72aPkSpqzk7Tse973g/6Wr+cHxZBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAIKBnmUIXaqHnNOkxrXQkZ52b2fbKeXT0vu7/9XeL2w/+ktdpdpzHvWdPFrfvjW+mj9HiPP+Ts0IP7ho6esuz9VGxe/V2+Q8aurw7OoGz65F1gY8xxpvz++nfZDq64DtkPbgdXbtZt/UYI30PVt6l2TU9TO5bpZN8jftW6pQudDHz6+bLMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAoaSbFilTD0rl19rKECmVPreUKQ/ez06rkVlcEXHebx/vTx0ZI37+rFJ12lhGMj/Tu5LNkxmjMJze7E88KEy/CIbbvHy+WW2ixaV4RVb0DFQZCsDMirDQL767mhywMq3P+eUfrGO65UNkwFflgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAjoWd6wSn/k6dXy9sPzz6bPo9IbfHw136mZdSRXel/X6BbO+o1Prx+n+9gbyz26lX7sDmt03FbWT3bvj6/yZ6GjK/XFw6PF7tjdfv5bfvPq3xa3/6NyIska65Ddl0ofdCZ7VioqncDZu7LSb5z9TaXnvXKuszqOcVe6iSvd1h33LXvuK9dLV/PHzZdlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEDCX5yK0xdGKMMQ7v3f5xKgNH0t97PvnvxxinJ8t/UxoacLI8uKQyyCNT+S3ZuVbK+POBD+uswcoAg8zu0fJvqVzTvb/+++xppGs9HbRwkw/hGGN5jXUMFFljSNAYtaEjmeya1p7J+XdDx2/JbGWgSIf0HVV6FpZV7knH7zXYZLt8WQYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACCgZ3nDOjoXK92PWYdk2uk6xtjtz/cC7z39fnofWY9yptKDWrkemTV6lCu/pdKjnMmux8vnl9PHOPt73nPa8Vsylft279mT+QOdv53fx6RKR3L2zFZ6qbNrenYz39NdWhtJH+/hg+nTaHl3VJS63hOzvcGVbuKOZ7bj/69sDZbmFSTrZ433E7fHl2UAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAQMJbnjZovjKyoF91lhf6nUfXKgSEV2Hh3DCzrOY62BIpnKYIGs0L8ypOP9628Wt5eGOTTcl+y6VwZk7F7NDxTpWB9rHOOgYR8dwz4ylQFPLx4eLb5LOwaslN6Dia28G+6K2rNy+88bd5svywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAAT0LN9xlR7cWaXOzovl86j05O49/X5xe0df7+nJcp9m5XqWOn8TWR9r1vs5xkh7hSv3Lfu9Hb/1otQ7fH/6ONm5rtVPe3B9+33PX313tNgbXOpfb+ilvisq12ONd2n+3Dd1wSe2cj067Pbzazrr+Orb6X1Uur7ZLl+WAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQMJSEdJjD6VW+j6wov7KPcbJcgn94Pj/cojKYInN8NT8U4CwZCFEZBpL9zcGYHyrQMUSh45pXrsdWBr10/N5MNlRirQEIpeEnmWSgUccQjoqOATyZ7FmpWGtYSHbdO85j92h5H7VnaX4oSX5f8qEkho583HxZBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAIPDJDz/M12Ty4WQ9p5UuzKxftNJ12dGFmp3rGj2oFdn1qFyLrF+00m+c6eh0rVirR3lW5Tw7noUtqKzBjp7c7DiV7tkXD49u/T+hX9szeVfONTvPta5Xh453Q8f/o/qeb4cvywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACPz2Q58Ac7IC8mxoyRhjjJv54QSZtYrSO4a0ZNYZxHB3Bopk16NyzbdS6L/Gs8C/arlvia08k2sN8OkY5rHOAJ7l8zQQi63wZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAnmVaeirX6lHOtPROryC75qdXK53IHVFZox1rcCvrg/Wla6yhg7vjXVt5N3T0yafnsdJvyazy3Otf/9XzZRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAIFPfvhBBz8AAPwUX5YBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAgLAMAAABYRkAAALCMgAABIRlAAAICMsAABAQlgEAICAsAwBAQFgGAICAsAwAAAFhGQAAAsIyAAAEhGUAAAgIywAAEBCWAQAgICwDAEBAWAYAgICwDAAAAWEZAAACwjIAAASEZQAACAjLAAAQEJYBACAgLAMAQEBYBgCAwP8HWpgqpHLHBVQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cmap = plt.get_cmap('magma')\n",
    "rgba_img = (cmap(terrain / np.max(terrain)) * 255).astype(np.uint8)\n",
    "\n",
    "# Set alpha channel to 0 for all 0 values in terrain\n",
    "rgba_img[:, :, 3] = (terrain > 0) * 255\n",
    "\n",
    "# Output with transparency\n",
    "plt.figure(0, figsize=(10, 10))\n",
    "plt.imshow(rgba_img)\n",
    "plt.axis('off')\n",
    "plt.tight_layout()\n",
    "plt.savefig('output.png', transparent=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print the span of the longest inclusive array that has the same values at its borders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maxSpan(arr):\n",
    "    maxi=0\n",
    "    for i,num1 in enumerate(arr ):\n",
    "         for j,num2 in enumerate(arr[i:]):\n",
    "                if num1==num2 and j+1>maxi:\n",
    "                    maxi=j+1\n",
    "    return maxi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr=[1, 2, 1, 1, 3]\n",
    "maxi=0\n",
    "for i,num1 in enumerate(arr):\n",
    "     for j,num2 in enumerate(arr[i:]):\n",
    "            if num1==num2 and j>=maxi:\n",
    "                maxi=j+1\n",
    "print (maxi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map a values to b and erase c\n",
    "\n",
    "``` p\n",
    "mapShare({\"a\": \"aaa\", \"b\": \"bbb\", \"c\": \"ccc\"}) → {\"a\": \"aaa\", \"b\": \"aaa\"}\n",
    "\n",
    "mapShare({\"b\": \"xyz\", \"c\": \"ccc\"}) → {\"b\": \"xyz\"}\n",
    "\n",
    "mapShare({\"a\": \"aaa\", \"c\": \"meh\", \"d\": \"hi\"}) → {\"a\": \"aaa\", \"b\": \"aaa\", \"d\": \"hi\"}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mapShare(dic):\n",
    "    if dic.get(\"a\"):\n",
    "        dic[\"b\"]=dic.get(\"a\")\n",
    "    dic.pop(\"c\")\n",
    "    return dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'aaa', 'b': 'aaa'}"
      ]
     },
     "execution_count": 422,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mapShare({\"a\": \"aaa\", \"b\": \"bbb\", \"c\": \"ccc\"}) "
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}