packegessolutions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.codewars.com/kata/52bc74d4ac05d0945d00054e/solutions\n",
    "Test.describe('Basic Tests')\n",
    "Test.it('should handle simple tests')\n",
    "Test.assert_equals(first_non_repeating_letter('a'), 'a')\n",
    "Test.assert_equals(first_non_repeating_letter('stress'), 't')\n",
    "Test.assert_equals(first_non_repeating_letter('moonmen'), 'e')\n",
    "\n",
    "Test.it('should handle empty strings')\n",
    "Test.assert_equals(first_non_repeating_letter(''), '')\n",
    "\n",
    "Test.it('should handle all repeating strings') \n",
    "Test.assert_equals(first_non_repeating_letter('abba'), '')\n",
    "Test.assert_equals(first_non_repeating_letter('aa'), '')\n",
    "\n",
    "Test.it('should handle odd characters')\n",
    "Test.assert_equals(first_non_repeating_letter('~><#~><'), '#')\n",
    "Test.assert_equals(first_non_repeating_letter('hello world, eh?'), 'w')\n",
    "\n",
    "Test.it('should handle letter cases')\n",
    "Test.assert_equals(first_non_repeating_letter('sTreSS'), 'T')\n",
    "Test.assert_equals(first_non_repeating_letter('Go hang a salami, I\\'m a lasagna hog!'), ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from collections import Counter\n",
    "def first_non_repeating_letter(string):\n",
    "    cnt = Counter(string.lower())\n",
    "    for letter in string:\n",
    "        if cnt[letter.lower()] == 1:\n",
    "            return letter\n",
    "    return ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_non_repeating_letter(string):\n",
    "    singles = [i for i in string if string.lower().count(i.lower()) == 1]\n",
    "    return singles[0] if singles else ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_non_repeating_letter(string):\n",
    "    \n",
    "    s = string.lower()\n",
    "    \n",
    "    for i in string:\n",
    "        if s.count(i.lower()) == 1:\n",
    "            return i\n",
    "    return ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "https://www.codewars.com/kata/577e277c9fb2a5511c00001d/train/python\n",
    "Test.describe(\"Basic tests\")\n",
    "Test.it(\"None or empty\")\n",
    "Test.assert_equals(vowel_shift(None, 0), None)\n",
    "Test.assert_equals(vowel_shift(\"\", 0), \"\")\n",
    "Test.it(\"Proper tests\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", 0), \"This is a test!\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", 1), \"Thes is i tast!\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", 3), \"This as e tist!\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", 4), \"This is a test!\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", -1), \"This as e tist!\")\n",
    "Test.assert_equals(vowel_shift(\"This is a test!\", -5), \"This as e tist!\")\n",
    "Test.assert_equals(vowel_shift(\"Brrrr\",99),\"Brrrr\")\n",
    "Test.assert_equals(vowel_shift(\"AEIOUaeiou\",1),\"uAEIOUaeio\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "vowel = set(\"aeiouAEIOU\").__contains__\n",
    "\n",
    "def vowel_shift(text, n):\n",
    "    if not (text and n): return text\n",
    "    L = list(filter(vowel, text))\n",
    "    if not L: return text\n",
    "    n %= len(L)\n",
    "    it = chain(L[-n:], L[:-n])\n",
    "    return ''.join(next(it) if vowel(c) else c for c in text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from collections import deque\n",
    "\n",
    "def vowel_shift(text,n):\n",
    "    try:\n",
    "        tokens = re.split(r'([aeiouAEIOU])', text)\n",
    "        if len(tokens) > 1:\n",
    "            vowels = deque(tokens[1::2])\n",
    "            vowels.rotate(n)\n",
    "            tokens[1::2] = vowels\n",
    "        return ''.join(tokens)\n",
    "    except TypeError:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Team</th>\n",
       "      <th>League</th>\n",
       "      <th>Year</th>\n",
       "      <th>RS</th>\n",
       "      <th>RA</th>\n",
       "      <th>W</th>\n",
       "      <th>OBP</th>\n",
       "      <th>SLG</th>\n",
       "      <th>BA</th>\n",
       "      <th>Playoffs</th>\n",
       "      <th>RankSeason</th>\n",
       "      <th>RankPlayoffs</th>\n",
       "      <th>G</th>\n",
       "      <th>OOBP</th>\n",
       "      <th>OSLG</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ARI</td>\n",
       "      <td>NL</td>\n",
       "      <td>2012</td>\n",
       "      <td>734</td>\n",
       "      <td>688</td>\n",
       "      <td>81</td>\n",
       "      <td>0.328</td>\n",
       "      <td>0.418</td>\n",
       "      <td>0.259</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>162</td>\n",
       "      <td>0.317</td>\n",
       "      <td>0.415</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ATL</td>\n",
       "      <td>NL</td>\n",
       "      <td>2012</td>\n",
       "      <td>700</td>\n",
       "      <td>600</td>\n",
       "      <td>94</td>\n",
       "      <td>0.320</td>\n",
       "      <td>0.389</td>\n",
       "      <td>0.247</td>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>162</td>\n",
       "      <td>0.306</td>\n",
       "      <td>0.378</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>BAL</td>\n",
       "      <td>AL</td>\n",
       "      <td>2012</td>\n",
       "      <td>712</td>\n",
       "      <td>705</td>\n",
       "      <td>93</td>\n",
       "      <td>0.311</td>\n",
       "      <td>0.417</td>\n",
       "      <td>0.247</td>\n",
       "      <td>1</td>\n",
       "      <td>5.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>162</td>\n",
       "      <td>0.315</td>\n",
       "      <td>0.403</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>BOS</td>\n",
       "      <td>AL</td>\n",
       "      <td>2012</td>\n",
       "      <td>734</td>\n",
       "      <td>806</td>\n",
       "      <td>69</td>\n",
       "      <td>0.315</td>\n",
       "      <td>0.415</td>\n",
       "      <td>0.260</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>162</td>\n",
       "      <td>0.331</td>\n",
       "      <td>0.428</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CHC</td>\n",
       "      <td>NL</td>\n",
       "      <td>2012</td>\n",
       "      <td>613</td>\n",
       "      <td>759</td>\n",
       "      <td>61</td>\n",
       "      <td>0.302</td>\n",
       "      <td>0.378</td>\n",
       "      <td>0.240</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>162</td>\n",
       "      <td>0.335</td>\n",
       "      <td>0.424</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1227</th>\n",
       "      <td>PHI</td>\n",
       "      <td>NL</td>\n",
       "      <td>1962</td>\n",
       "      <td>705</td>\n",
       "      <td>759</td>\n",
       "      <td>81</td>\n",
       "      <td>0.330</td>\n",
       "      <td>0.390</td>\n",
       "      <td>0.260</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>161</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1228</th>\n",
       "      <td>PIT</td>\n",
       "      <td>NL</td>\n",
       "      <td>1962</td>\n",
       "      <td>706</td>\n",
       "      <td>626</td>\n",
       "      <td>93</td>\n",
       "      <td>0.321</td>\n",
       "      <td>0.394</td>\n",
       "      <td>0.268</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>161</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1229</th>\n",
       "      <td>SFG</td>\n",
       "      <td>NL</td>\n",
       "      <td>1962</td>\n",
       "      <td>878</td>\n",
       "      <td>690</td>\n",
       "      <td>103</td>\n",
       "      <td>0.341</td>\n",
       "      <td>0.441</td>\n",
       "      <td>0.278</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>165</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1230</th>\n",
       "      <td>STL</td>\n",
       "      <td>NL</td>\n",
       "      <td>1962</td>\n",
       "      <td>774</td>\n",
       "      <td>664</td>\n",
       "      <td>84</td>\n",
       "      <td>0.335</td>\n",
       "      <td>0.394</td>\n",
       "      <td>0.271</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>163</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1231</th>\n",
       "      <td>WSA</td>\n",
       "      <td>AL</td>\n",
       "      <td>1962</td>\n",
       "      <td>599</td>\n",
       "      <td>716</td>\n",
       "      <td>60</td>\n",
       "      <td>0.308</td>\n",
       "      <td>0.373</td>\n",
       "      <td>0.250</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>162</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1232 rows × 15 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Team League  Year   RS   RA    W    OBP    SLG     BA  Playoffs  \\\n",
       "0     ARI     NL  2012  734  688   81  0.328  0.418  0.259         0   \n",
       "1     ATL     NL  2012  700  600   94  0.320  0.389  0.247         1   \n",
       "2     BAL     AL  2012  712  705   93  0.311  0.417  0.247         1   \n",
       "3     BOS     AL  2012  734  806   69  0.315  0.415  0.260         0   \n",
       "4     CHC     NL  2012  613  759   61  0.302  0.378  0.240         0   \n",
       "...   ...    ...   ...  ...  ...  ...    ...    ...    ...       ...   \n",
       "1227  PHI     NL  1962  705  759   81  0.330  0.390  0.260         0   \n",
       "1228  PIT     NL  1962  706  626   93  0.321  0.394  0.268         0   \n",
       "1229  SFG     NL  1962  878  690  103  0.341  0.441  0.278         1   \n",
       "1230  STL     NL  1962  774  664   84  0.335  0.394  0.271         0   \n",
       "1231  WSA     AL  1962  599  716   60  0.308  0.373  0.250         0   \n",
       "\n",
       "      RankSeason  RankPlayoffs    G   OOBP   OSLG  \n",
       "0            NaN           NaN  162  0.317  0.415  \n",
       "1            4.0           5.0  162  0.306  0.378  \n",
       "2            5.0           4.0  162  0.315  0.403  \n",
       "3            NaN           NaN  162  0.331  0.428  \n",
       "4            NaN           NaN  162  0.335  0.424  \n",
       "...          ...           ...  ...    ...    ...  \n",
       "1227         NaN           NaN  161    NaN    NaN  \n",
       "1228         NaN           NaN  161    NaN    NaN  \n",
       "1229         1.0           2.0  165    NaN    NaN  \n",
       "1230         NaN           NaN  163    NaN    NaN  \n",
       "1231         NaN           NaN  162    NaN    NaN  \n",
       "\n",
       "[1232 rows x 15 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "x=pd.read_csv('baseballstats.csv')\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Team              ARI\n",
      "League             NL\n",
      "Year             2012\n",
      "RS                734\n",
      "RA                688\n",
      "W                  81\n",
      "OBP             0.328\n",
      "SLG             0.418\n",
      "BA              0.259\n",
      "Playoffs            0\n",
      "RankSeason        NaN\n",
      "RankPlayoffs      NaN\n",
      "G                 162\n",
      "OOBP            0.317\n",
      "OSLG            0.415\n",
      "Name: 0, dtype: object\n"
     ]
    }
   ],
   "source": [
    "# Iterate over pit_df and print each row\n",
    "for i,row in x[0:1].iterrows():\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, Team              ARI\n",
      "League             NL\n",
      "Year             2012\n",
      "RS                734\n",
      "RA                688\n",
      "W                  81\n",
      "OBP             0.328\n",
      "SLG             0.418\n",
      "BA              0.259\n",
      "Playoffs            0\n",
      "RankSeason        NaN\n",
      "RankPlayoffs      NaN\n",
      "G                 162\n",
      "OOBP            0.317\n",
      "OSLG            0.415\n",
      "Name: 0, dtype: object)\n"
     ]
    }
   ],
   "source": [
    "# Iterate over pit_df and print each row\n",
    "for row_tuple in x[0:1].iterrows():\n",
    "    print(row_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "179"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(nltk.corpus.stopwords.words('english'))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def high_and_low(numbers):\n",
    "  n = map(int, numbers.split(' '))\n",
    "  return str(max(n)) + ' ' + str(min(n))\n",
    "# https://www.codewars.com/kata/554b4ac871d6813a03000035/solutions/python\n",
    "def high_and_low(numbers):\n",
    "    n = map(int, numbers.split(' '))\n",
    "    return \"{} {}\".format(max(n), min(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def getCount(str):\n",
    "    return len(re.findall('[aeiou]', str, re.IGNORECASE))\n",
    "# https://www.codewars.com/kata/54ff3102c1bad923760001f3/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def duplicate_elements(m, n):\n",
    "    return any(x in n for x in m)\n",
    "def duplicate_elements(m, n):\n",
    "    return not set(m).isdisjoint(n)\n",
    "def duplicate_elements(m, n):\n",
    "    if not m or not n:\n",
    "        return False\n",
    "    return len([x for x in m if x in n]) > 0  \n",
    "# https://www.codewars.com/kata/583ebb9328a0c034490001ba/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import izip_longest\n",
    "\n",
    "def poly_subtract(p1, p2):\n",
    "    return [x - y for x, y in izip_longest(p1, p2, fillvalue=0)]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5714041e8807940ff3001140/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def song_decoder(song):\n",
    "    import re\n",
    "    return re.sub('(WUB)+', ' ', song).strip()\n",
    "\n",
    "# https://www.codewars.com/kata/551dc350bf4e526099000ae5/solutions/python\n",
    "import re\n",
    "\n",
    "def song_decoder(song):\n",
    "    return re.sub(r'(WUB)+', ' ', song).strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter as c\n",
    "def comp(a1, a2):\n",
    "    return a1 != None and a2 != None and c(a2) == c( elt**2 for elt in a1 )\n",
    "# https://www.codewars.com/kata/550498447451fbbd7600041c/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divisors(n):\n",
    "    return  len([l_div for l_div in range(1, n + 1) if n % l_div == 0]);\n",
    "\n",
    "def divisors(n):\n",
    "    return sum(1 for i in xrange(1, n + 1) if n % i == 0)\n",
    "\n",
    "def divisors(n):\n",
    "    count=0\n",
    "    for i in xrange(1,n/2+1):\n",
    "        if n%i==0: count+=1\n",
    "    return count+1\n",
    "\n",
    "# https://www.codewars.com/kata/542c0f198e077084c0000c2e/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "search = re.compile(r\"((?=\\w+$)\\w+|\\w)\\w*\").findall\n",
    "\n",
    "def initials(name):\n",
    "    return '.'.join(search(name)).title()\n",
    "\n",
    "def initials(name):\n",
    "    names = name.split()\n",
    "    return '.'.join(x[0].upper() for x in names) + names[-1][1:]\n",
    "# https://www.codewars.com/kata/55968ab32cf633c3f8000008/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_url_anchor(url):\n",
    "  import re\n",
    "  return re.sub('#.*$','',url)\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/51f2b4448cadf20ed0000386/solutions/python\n",
    "\n",
    "def remove_url_anchor(url):\n",
    "  return url.partition('#')[0]\n",
    "def remove_url_anchor(url):\n",
    "    index = url.find('#')\n",
    "    return url[:index] if index >= 0 else url"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def is_vowel(s): \n",
    "    regex = r'^[aeiou]{1}$'\n",
    "    return bool(re.match(regex, re.escape(s), re.IGNORECASE))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def is_vowel(stg): \n",
    "    return bool(re.fullmatch(r\"[aeiou]\", stg, re.I))\n",
    "\n",
    "\n",
    "def is_vowel(s): \n",
    "    return True if s.lower() in ['a', 'e', 'i', 'u', 'o'] else False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def is_letter(stg):\n",
    "    return bool(re.match(r\"[a-z]\\Z\", stg, re.I))\n",
    "\n",
    "import re\n",
    "def is_letter(s):\n",
    "    return bool(re.fullmatch(\"[A-Za-z]\",s))\n",
    "import re\n",
    "def is_letter(s):\n",
    "    return bool(re.fullmatch(r'^[a-z]$', s, flags = re.I))\n",
    "\n",
    "import re\n",
    "def is_letter(s):\n",
    "    return re.match(r'(?i)[a-z]\\Z', s) is not None\n",
    "\n",
    "# https://www.codewars.com/kata/567de72e8b3621b3c300000b/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_acronym(i):\n",
    "    return''.join(w[0]for w in i.split()).upper()\n",
    "\n",
    "import re\n",
    "\n",
    "def to_acronym(s):\n",
    "    return ''.join(re.findall(r'\\b(\\w)', s)).upper()\n",
    "\n",
    "\n",
    "import string\n",
    "def to_acronym(input):\n",
    "    return \"\".join([x[0].upper() for x in input.split(\" \")])\n",
    "\n",
    "# https://www.codewars.com/kata/57a60bad72292d3e93000a5a/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "\n",
    "def to_cents(amount):\n",
    "    m = re.match(r'\\$(\\d+)\\.(\\d\\d)\\Z', amount)\n",
    "    return int(m.expand(r'\\1\\2')) if m else None\n",
    "\n",
    "from re import compile, match\n",
    "\n",
    "REGEX = compile(r'\\$(?P<integer>\\d+)\\.(?P<frac>\\d{0,2})$')\n",
    "\n",
    "\n",
    "def to_cents(amount):\n",
    "    m = match(REGEX, amount)\n",
    "    if m and m.group(0) == amount:\n",
    "        return int(m.group('integer')) * 100 + int(m.group('frac'))\n",
    " \n",
    "def to_cents(amount):\n",
    "    if amount and amount[0] == '$':\n",
    "        try:\n",
    "            return int(amount[1:-3] + amount[-2:])\n",
    "        except:\n",
    "            return None\n",
    "    return None\n",
    " \n",
    "import re\n",
    "\n",
    "def to_cents(amount):\n",
    "    matched = re.search(r'\\A\\$(\\d+).(\\d{2})\\Z', amount)\n",
    "    if matched:\n",
    "        return int('{}{}'.format(*matched.groups()))\n",
    " \n",
    "import re\n",
    "def to_cents(s):\n",
    "    c = re.match(r'^[$](\\d+).(\\d{2})\\Z',s)\n",
    "    return int(''.join(c.group(1,2))) if c else c\n",
    "https://www.codewars.com/kata/56833b76371e86f8b6000015/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comfortable_word(word):\n",
    "    uncomfortable = re.compile(\"([qwerasdfgzxcvb]{2}|[yuiophjklnm]{2})+\")\n",
    "    return False if uncomfortable.search(word) else True\n",
    "\n",
    "# https://www.codewars.com/kata/56684677dc75e3de2500002b/solutions\n",
    "import re\n",
    "def comfortable_word(w):\n",
    "    return True if not re.findall(r'[qwertasdfgzxcvb]{2,}|[yuiophjklnm]{2,}',w) else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate(s):\n",
    "    x=[int(i) for i in s.split() if i.isdigit()]\n",
    "    return sum(x) if 'gains' in s.split() else x[0]-x[1]\n",
    "\n",
    "import re\n",
    "def calculate(string):\n",
    "    x,y=re.findall('\\d+',string)\n",
    "    if re.search('loses', string): s= int(x)-int(y)\n",
    "    if re.search('gains', string): s= int(x)+int(y)\n",
    "    return s\n",
    "\n",
    "import re\n",
    "\n",
    "def calculate(string):\n",
    "    a, b = map(int, re.findall(r'\\d+', string))\n",
    "    if 'lose' in string:\n",
    "        return a - b\n",
    "    else:\n",
    "        return a + b\n",
    "\n",
    "import re\n",
    "import operator\n",
    "\n",
    "\n",
    "def calculate(s):\n",
    "    match_res = re.match(r'.+\\s(\\d+)\\s.+\\s(loses|gains)\\s(\\d+)\\Z', s.strip())\n",
    "    try:\n",
    "        return {\n",
    "        'loses': operator.sub,\n",
    "        'gains': operator.add,\n",
    "        }[match_res.group(2)](int(match_res.group(1)), int(match_res.group(3)))\n",
    "    except AttributeError:\n",
    "        raise ValueError('string do not obey sepcific')\n",
    "\n",
    "import re\n",
    "def calculate(string):\n",
    "    return eval(re.sub(\"[^\\d+-]\", \"\", string.replace(\"loses\", \"-\").replace(\"gains\", \"+\")) )\n",
    "\n",
    "# https://www.codewars.com/kata/57b9fc5b8f5813384a000aa3/solutions/python\n",
    "from re import findall\n",
    "\n",
    "def calculate(s):\n",
    "    op1, op2 = map(int, findall('(\\d+)', s))\n",
    "    return op1 + op2 if 'gains' in s else op1 - op2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def autocorrect(input):\n",
    "    return re.sub(r'(?i)\\b(u|you+)\\b', \"your sister\", input)\n",
    "11 similar code variations are grouped with this oneShow Variations\n",
    "\n",
    "#  https://www.codewars.com/kata/538ae2eb7a4ba8c99b000439/solutions/python\n",
    "from re import sub, I\n",
    "\n",
    "def autocorrect(input):\n",
    "    return sub(r'\\b(you+|u)\\b', 'your sister', input, flags=I)\n",
    " \n",
    "import re\n",
    "def autocorrect(input):\n",
    "    return re.sub(r'(?i)\\b(you+|u)\\b', 'your sister', input)\n",
    "7 similar code variations are grouped with this oneShow Variations\n",
    "\n",
    " \n",
    "import re\n",
    "def autocorrect(input):\n",
    "    return re.sub(r\"\\b(yo[u]+|[u])(?!'\\w)\\b\",'your sister',input,flags=re.IGNORECASE)\n",
    "    \n",
    "            \n",
    "            \n",
    "    \n",
    " \n",
    "import re\n",
    "\n",
    "def autocorrect(phrase):\n",
    "    PATTERN = r'\\bu\\b|\\byou\\b|\\byo(u)\\1{1,}\\b'\n",
    "    return re.sub(PATTERN,'your sister', phrase, flags=re.IGNORECASE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def solution(s):\n",
    "    return re.findall(\".{2}\", s + \"_\")\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/515de9ae9dcfc28eb6000001/solutions/python\n",
    "\n",
    "def solution(s):\n",
    "    return [s[x:x+2] if x < len(s) - 1 else s[-1] + \"_\" for x in range(0, len(s), 2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def search(titles, term):\n",
    "    return list(filter(lambda x: re.compile(term).findall(x.lower()), titles))\n",
    "\n",
    "def search(titles: list, term: str):\n",
    "    import re\n",
    "    return [title for title in titles if bool(re.search(term, title, re.IGNORECASE))]\n",
    "\n",
    "# https://www.codewars.com/kata/52cd53948d673a6e66000576/solutions/python\n",
    "import re\n",
    "\n",
    "def search(titles, term):\n",
    "    result = []\n",
    "    for i in titles:\n",
    "        if re.compile(term).findall(i.lower()):\n",
    "            if i not in result:\n",
    "                result.append(i)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode(s, t=str.maketrans(\"aeiou\", \"12345\")):\n",
    "    return s.translate(t)\n",
    "    \n",
    "def decode(s, t=str.maketrans(\"12345\", \"aeiou\")):\n",
    "    return s.translate(t)\n",
    "\n",
    "CIPHER = (\"aeiou\", \"12345\")\n",
    "\n",
    "def encode(st):\n",
    "    return st.translate(str.maketrans(CIPHER[0], CIPHER[1]))\n",
    "    \n",
    "def decode(st):\n",
    "    return  st.translate(str.maketrans(CIPHER[1], CIPHER[0]))\n",
    "\n",
    "\n",
    "def encode(st):\n",
    "    for i, v in enumerate(\"aeiou\", start=1):\n",
    "        st = st.replace(v,str(i))\n",
    "    return st\n",
    "    \n",
    "def decode(st):\n",
    "    for i, v in enumerate(\"aeiou\", start=1):\n",
    "        st = st.replace(str(i),v)\n",
    "    return st\n",
    "\n",
    "\n",
    "tbl1 = str.maketrans(\"aeiou\", \"12345\")\n",
    "tbl2 = str.maketrans(\"12345\", \"aeiou\")\n",
    "\n",
    "\n",
    "def encode(st):\n",
    "    return st.translate(tbl1)\n",
    "\n",
    "\n",
    "def decode(st):\n",
    "    return st.translate(tbl2)\n",
    "\n",
    "# https://www.codewars.com/kata/53697be005f803751e0015aa/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from re import findall\n",
    "\n",
    "def get_order(order):\n",
    "    menu = ['Burger','Fries','Chicken','Pizza','Sandwich','Onionrings','Milkshake','Coke']\n",
    "    return ' '.join(filter(None, (' '.join(findall(item.lower(), order)).title() for item in menu)))\n",
    "\n",
    "import re\n",
    "\n",
    "MENU = ['burger', 'fries', 'chicken', 'pizza', 'sandwich', 'onionrings', 'milkshake', 'coke']\n",
    "\n",
    "def get_order(order):\n",
    "    res = []\n",
    "    for item in MENU:\n",
    "        res.extend(re.findall(item, order))\n",
    "    return ' '.join([item.capitalize() for item in res])\n",
    "\n",
    "import re\n",
    "\n",
    "MENU    = {v:i for i,v in enumerate(\"Burger Fries Chicken Pizza Sandwich Onionrings Milkshake Coke\".split())}\n",
    "REG_CMD = re.compile('|'.join(MENU), flags=re.I)\n",
    "\n",
    "def get_order(order):\n",
    "    return ' '.join(sorted( map(str.title, REG_CMD.findall(order)),\n",
    "                            key=MENU.get ))\n",
    "# https://www.codewars.com/kata/5d23d89906f92a00267bb83d/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_subpattern(string):\n",
    "    return (string * 2).find(string, 1) != len(string)\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def has_subpattern(string):\n",
    "    return bool(re.match(r'(.+)\\1+$', string))\n",
    "\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def has_subpattern(s):\n",
    "    return bool(re.search(r'^(.+)\\1+$', s))\n",
    "\n",
    "\n",
    "import re\n",
    "def has_subpattern(s):\n",
    "    return re.search(r'^(.+?)\\1{1,}$', s) != None\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5a49f074b3bfa89b4c00002b/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "pattern = re.compile('^[0-9a-zA-Z]+$')\n",
    "\n",
    "def alphanumeric(string):\n",
    "  return pattern.match(string) is not None\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def alphanumeric(string):\n",
    "    return bool(re.search(r'^[0-9a-zA-Z]+$', string))\n",
    "\n",
    "\n",
    "https://www.codewars.com/kata/526dbd6c8c0eb53254000110/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict \n",
    "def remove_duplicate_ids(obj):\n",
    "    obj =  OrderedDict(sorted(obj.items(), key = lambda x:int(x[0])))\n",
    "    for k,v in obj.items():\n",
    "        obj[k] = sorted(list(set(v) - set([x for e in obj.values() for x in e if e is not v ])), key = v.index)\n",
    "    return obj\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def remove_duplicate_ids(obj):\n",
    "    out, seen = {}, {}\n",
    "    for i in sorted(obj.keys(), key=int, reverse=True):\n",
    "        uniques = []\n",
    "        for v in obj[i]:\n",
    "            if v not in seen:\n",
    "                uniques.append(v)\n",
    "                seen[v] = 1\n",
    "        out[i] = uniques\n",
    "    return out\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5e8dd197c122f6001a8637ca/solutions/python\n",
    "def remove_duplicate_ids(d):\n",
    "    s = set()\n",
    "    return {x: [s.add(y) or y for y in d[x] if y not in s] for x in sorted(d, key=int, reverse=True)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from calendar import weekday\n",
    "week = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']\n",
    "\n",
    "def most_frequent_days(year):\n",
    "    beg = weekday(year, 1, 1)\n",
    "    end = weekday(year, 12, 31)\n",
    "    if beg == end:\n",
    "        return [week[beg]]\n",
    "    else:\n",
    "        if beg < end:\n",
    "            return [week[beg], week[end]]\n",
    "        else:\n",
    "            return [week[end], week[beg]]\n",
    "\n",
    "        \n",
    "from calendar import weekday, day_name\n",
    "\n",
    "def most_frequent_days(year):\n",
    "    return [ day_name[day] for day in sorted( {weekday(year, 1, 1), weekday(year, 12, 31)} ) ]\n",
    "\n",
    "\n",
    "from datetime import datetime \n",
    "from calendar import day_name\n",
    "\n",
    "# https://www.codewars.com/kata/56eb16655250549e4b0013f4/solutions/python\n",
    "def most_frequent_days(year):\n",
    "    first = set(range(datetime(year, 1, 1).weekday(), 7))\n",
    "    last = set(range(datetime(year, 12, 31).isoweekday()))\n",
    "    return [day_name[day] for day in sorted((first & last) or (first | last))]\n",
    "\n",
    "from calendar import weekday, day_name\n",
    "\n",
    "def most_frequent_days(year):\n",
    "    days = [weekday(year, 1, 1), weekday(year, 12, 31)]\n",
    "    return [day_name[i] for i in sorted(list(set(days)))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "def getWinner(ballots):\n",
    "    winner, n_votes = Counter(ballots).most_common(1)[0]\n",
    "    return winner if n_votes > len(ballots)/2 else None\n",
    "\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "\n",
    "def getWinner(listOfBallots):\n",
    "    candidate, votes = Counter(listOfBallots).most_common(1)[0]\n",
    "    return candidate if votes > len(listOfBallots) / 2 else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "SPLITTER = re.compile(r\"[\\s-]\")\n",
    "\n",
    "def birdify(lst):\n",
    "    return ''.join(x[:4//len(lst)] for x in lst) + ('' if len(lst)!=3 else lst[-1][1])\n",
    "\n",
    "def bird_code(arr):\n",
    "    return [birdify(SPLITTER.split(name)).upper() for name in arr]\n",
    "\n",
    "\n",
    "\n",
    "REGEX = __import__(\"re\").compile(r\"[ -]\").split\n",
    "letters = ((4,), (2,2), (1,1,2), (1,1,1,1))\n",
    "\n",
    "def code(L):\n",
    "    return ''.join(L[i][:j] for i,j in enumerate(letters[len(L)-1])).upper()\n",
    "\n",
    "def bird_code(arr):\n",
    "    return [code(REGEX(name)) for name in arr]\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5a580064e6be38fd34000147/solutions/python\n",
    "import re\n",
    "def bird_code(s):\n",
    "    li = []\n",
    "    for i in s:\n",
    "        i = re.sub(r\" *-\", \" \", i).upper().split()\n",
    "        if len(i) == 1 : li.append(i[0][:4])\n",
    "        if len(i) == 2 : li.append(i[0][:2] + i[1][:2])\n",
    "        if len(i) == 3 : li.append(i[0][0] + i[1][0] + i[2][:2])\n",
    "        if len(i) == 4 : li.append(\"\".join([k[0] for k in i]))\n",
    "    return li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def rad_ladies(name):\n",
    "    return \"\".join(re.findall(\"[A-Z\\s!]+\", name.upper()))\n",
    "\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/56d31aaefd3a52902a000d66/solutions/python\n",
    "from string import ascii_uppercase\n",
    "\n",
    "VALID = set(ascii_uppercase + ' !')\n",
    "\n",
    "\n",
    "def rad_ladies(name):\n",
    "    return ''.join(a for a in name.upper() if a in VALID)\n",
    "\n",
    "import re\n",
    "def rad_ladies(name):\n",
    "    return re.sub(\"[\\d%$&/£?@]\", \"\", name).upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def word_mesh(arr):\n",
    "    common = re.findall(r'(.+) (?=\\1)',' '.join(arr))\n",
    "    return ''.join(common) if len(common) + 1 == len(arr) else 'failed to mesh'\n",
    "\n",
    "# https://www.codewars.com/kata/5c1ae703ba76f438530000a2/solutions/python\n",
    "\n",
    "def word_mesh(arr):\n",
    "    result = \"\"\n",
    "    \n",
    "    for a, b in zip(arr, arr[1:]):\n",
    "        while not a.endswith(b):\n",
    "            b = b[:-1]\n",
    "        if not b:\n",
    "            return \"failed to mesh\"\n",
    "        result += b\n",
    "      \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_format(n):\n",
    "    return f'{n:,}'\n",
    "\n",
    "# https://www.codewars.com/kata/565c4e1303a0a006d7000127/solutions/python\n",
    "\n",
    "\n",
    "\n",
    "def number_format(n):\n",
    "    return format(n, ',')\n",
    "\n",
    "\n",
    "number_format='{:,}'.format\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def number_format(n):\n",
    "    return str('{:,.3f}'.format(n)).rstrip('0').rstrip('.')\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def number_format(n):\n",
    "    return re.sub(r'\\B(?=(\\d{3})+(?!\\d))', r',', str(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def increment_string(input):\n",
    "    match = re.search(\"(\\d*)$\", input)\n",
    "    if match:\n",
    "        number = match.group(0)\n",
    "        if number is not \"\":\n",
    "            return input[:-len(number)] + str(int(number) + 1).zfill(len(number))\n",
    "    return input + \"1\"\n",
    "\n",
    "# https://www.codewars.com/kata/54a91a4883a7de5d7800009c/solutions/python\n",
    "def increment_string(s):\n",
    "    if s and s[-1].isdigit():\n",
    "        return increment_string(s[:-1]) + \"0\" if s[-1] == \"9\" else s[:-1] + `int(s[-1]) + 1`\n",
    "    return s + \"1\"\n",
    "\n",
    "import re\n",
    "def increment_string(strng):\n",
    "    m = re.match('^(.*?)(\\d+)$', strng)\n",
    "    name, num = (m.group(1), m.group(2)) if m else (strng, '0')\n",
    "    return '{0}{1:0{2}}'.format(name, int(num)+1, len(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def string_expansion(s):\n",
    "    return ''.join(''.join(int(n or '1')*c for c in cc) for n,cc in re.findall(r'(\\d?)(\\D+)', s))\n",
    "    \n",
    "\n",
    "# https://www.codewars.com/kata/5ae326342f8cbc72220000d2/solutions/python    \n",
    "def string_expansion(s):\n",
    "    def f():\n",
    "        repeat = 1\n",
    "        for c in s:\n",
    "            if c.isdigit():\n",
    "                repeat = int(c)\n",
    "            else:\n",
    "                yield c * repeat\n",
    "    return ''.join(f())\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def string_expansion(s):\n",
    "    return re.sub('(\\d)+([a-zA-Z]*)', lambda m: ''.join(ch * int(m.group(1)) for ch in m.group(2)), s)\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def string_expansion(s):\n",
    "    return re.sub('\\d*?(\\d?)(\\D*)', lambda m: ''.join(int(m.group(1) or 1) * c for c in m.group(2)), s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def sum_of_a_beach(beach):\n",
    "    return len(re.findall('Sand|Water|Fish|Sun', beach, re.IGNORECASE))\n",
    "\n",
    "\n",
    "def sum_of_a_beach(beach):\n",
    "    return sum(beach.lower().count(fun) for fun in [\"sand\", \"water\", \"fish\", \"sun\"])\n",
    "\n",
    "\n",
    "import re\n",
    "def sum_of_a_beach(beach):\n",
    "    return len(re.findall(\"sand|water|fish|sun\", beach, flags=re.I))\n",
    "\n",
    "https://www.codewars.com/kata/5b37a50642b27ebf2e000010/solutions/python\n",
    "import re\n",
    "\n",
    "def sum_of_a_beach(beach):\n",
    "    return sum(1 for _ in re.finditer(r'sand|water|fish|sun',beach.lower()))\n",
    "\n",
    "\n",
    "def sum_of_a_beach(beach):\n",
    "    b = beach.lower(); l = [\"sand\", \"water\", \"fish\", \"sun\"]; c = 0\n",
    "    for w in l:\n",
    "        if w in b:c += b.count(w)\n",
    "    return c\n",
    "    \n",
    "\n",
    "    \n",
    "import re\n",
    "def sum_of_a_beach(beach):\n",
    "    return len(re.findall(r'sand|fish|water|sun', beach, flags = re.I))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def dashatize(num):\n",
    "    try:\n",
    "        return ''.join(['-'+i+'-' if int(i)%2 else i for i in str(abs(num))]).replace('--','-').strip('-')\n",
    "    except:\n",
    "        return 'None'\n",
    "\n",
    "# https://www.codewars.com/kata/58223370aef9fc03fd000071/solutions/python    \n",
    "def dashatize(num):\n",
    "    num_str = str(num)\n",
    "    for i in ['1','3','5','7','9']:\n",
    "        num_str = num_str.replace(i,'-' + i + '-')\n",
    "    return num_str.strip('-').replace('--','-')\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def dashatize(num):\n",
    "  return 'None' if num is None else '-'.join(w for w in re.split(r'([13579])', str(abs(num))) if len(w)>0)\n",
    "\n",
    "\n",
    "from re import findall\n",
    "\n",
    "def dashatize(num):\n",
    "    return '-'.join(findall('([13579]|[02468]+)', str(num))) or 'None'\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def dashatize(num):\n",
    "    lst = re.findall(r'[13579]|[02468]+', str(num))\n",
    "    return '-'.join(lst) if lst else 'None'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def search_substr(full_text, search_text, allow_overlap=True):\n",
    "    if not full_text or not search_text: return 0\n",
    "    return len(re.findall(f'(?=({search_text}))' if allow_overlap else search_text, full_text))\n",
    "\n",
    "# https://www.codewars.com/kata/52190daefe9c702a460003dd/solutions/python\n",
    "import re\n",
    "\n",
    "def search_substr(origin, target, overlap=True):\n",
    "    if not target: return 0\n",
    "    \n",
    "    start, end = map(re.escape, (target[0], target[1:]))                     # To match correctly '|' or other special regexp chars\n",
    "    patternStr = r'{}{}'.format(start, f'(?={end})' if overlap else end)\n",
    "    \n",
    "    return sum(1 for _ in re.finditer(patternStr, origin))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def search_substr(full_text, search_text, allow_overlap=True):\n",
    "    if not full_text or not search_text: return 0\n",
    "    return len(re.findall(r'(?=({}))'.format(search_text) if allow_overlap else r'{}'.format(search_text), full_text))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def search_substr(full_text, search_text, allow_overlap=True):\n",
    "    if not all((full_text, search_text)):\n",
    "        return 0\n",
    "    elif allow_overlap:\n",
    "        counts = 0\n",
    "        width = len(search_text)\n",
    "        for pos in range( 1 + len(full_text) - width):\n",
    "            substring =  full_text[pos:pos + width]\n",
    "            print(substring)\n",
    "            if substring == search_text:\n",
    "                counts +=1\n",
    "        return counts\n",
    "    else:\n",
    "        return len(re.findall(search_text, full_text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "\n",
    "def sentence(lst):\n",
    "    return ' '.join(w for _,w in sorted(chain(*map(dict.items, lst)), key=lambda it: int(it[0])))\n",
    "\n",
    "# https://www.codewars.com/kata/5b047875de4c7f9af800011b/solutions/python\n",
    "\n",
    "\n",
    "def sentence(List):\n",
    "    List = { v:int(k)  for e in List for k,v in e.items() }\n",
    "    return ' '.join(sorted(List.keys(), key = lambda x: List[x]))\n",
    "\n",
    "def sentence(lista):\n",
    "    res = [ (int(list(e.keys())[0]), list(e.values())[0] ) for e in lista ]\n",
    "    return ' '.join(e[1] for e in sorted(res, key=lambda x: x[0])) \n",
    "\n",
    "from functools import reduce\n",
    "def sentence(List):\n",
    "    return ' '.join(v for k, v in sorted(reduce(lambda a, b: (a.update(b), a)[1], List, {}).items(), key=lambda v: int(v[0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "\n",
    "def sentence(lst):\n",
    "    return ' '.join(w for _,w in sorted(chain(*map(dict.items, lst)), key=lambda it: int(it[0])))\n",
    "\n",
    "def sentence(ds):\n",
    "    return ' '.join(v for _, v in sorted((int(k), v) for d in ds for k, v in d.items()))\n",
    "def sentence(List):\n",
    "    List = { v:int(k)  for e in List for k,v in e.items() }\n",
    "    return ' '.join(sorted(List.keys(), key = lambda x: List[x]))\n",
    "\n",
    "# https://www.codewars.com/kata/5b047875de4c7f9af800011b/solutions/python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " from functools import reduce\n",
    "from itertools import combinations\n",
    "from operator import mul\n",
    "\n",
    "def find_min_max_product(arr, k):\n",
    "    if k <= len(arr):\n",
    "        prods = [ reduce(mul, nums) for nums in combinations(arr, k) ]\n",
    "        return min(prods), max(prods)\n",
    "    \n",
    "    \n",
    "# https://www.codewars.com/kata/5afd81d0de4c7f45f4000239/solutions/python    \n",
    "    \n",
    "    \n",
    "import functools as ft\n",
    "import itertools as it\n",
    "import operator as op\n",
    "\n",
    "def find_min_max_product(arr, k):\n",
    "    if k > len(arr):\n",
    "        return None\n",
    "    else:\n",
    "        combinations = it.combinations(arr, k)\n",
    "        minimum, maximum = it.tee(ft.reduce(op.mul, combination) for combination in combinations)\n",
    "        return min(minimum), max(maximum)\n",
    "    \n",
    "    \n",
    "from functools import reduce\n",
    "from itertools import tee, combinations\n",
    "from operator import mul\n",
    "\n",
    "\n",
    "def find_min_max_product(arr, k):\n",
    "    if k > len(arr):\n",
    "        return None\n",
    "    mi, mx = tee(map(lambda c: reduce(mul, c), combinations(arr, k)))\n",
    "    return min(mi), max(mx)\n",
    "\n",
    "\n",
    "import itertools\n",
    "import numpy as np\n",
    "\n",
    "def find_min_max_product(arr, k):\n",
    "    if k<=len(arr):\n",
    "        comb = set([np.prod(i) for i in list(itertools.combinations(arr, k))])\n",
    "        return min(comb),max(comb)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import repeat\n",
    "def populate_dict(keys, default):\n",
    "    return {k: v for k, v in zip(keys, repeat(default))}\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/51c38e14ea1c97ffaf000003/solutions/python\n",
    "def populate_dict(keys, default):\n",
    "    return {key: default for key in keys}\n",
    "from collections import defaultdict\n",
    "def populate_dict(keys, default):\n",
    "    return defaultdict.fromkeys(keys, default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "def find_zero_sum_groups(arr, n):\n",
    "    combos = sorted(sorted(c) for c in combinations(set(arr), n) if sum(c) == 0)\n",
    "    return combos if len(combos) > 1 else combos[0] if combos else \"No combinations\" if arr else \"No elements to combine\"\n",
    "\n",
    "\n",
    "from itertools import combinations as comb\n",
    "\n",
    "def find_zero_sum_groups(arr, n):\n",
    "    if not arr: return \"No elements to combine\"\n",
    "    \n",
    "    arr = list(set(arr))\n",
    "    result = sorted(sorted(x) for x in set(comb(arr, n)) if sum(x) == 0)\n",
    "    result = sorted(list(x) for x in set(map(tuple, result)))\n",
    "    \n",
    "    if not result: return \"No combinations\"\n",
    "    \n",
    "    return result[0] if len(result) == 1 else result\n",
    "\n",
    "from itertools import combinations\n",
    "\n",
    "def find_zero_sum_groups(lst, n):\n",
    "    if not lst:\n",
    "        return \"No elements to combine\"\n",
    "    result = [list(c) for c in combinations(sorted(set(lst)), n) if sum(c) == 0]\n",
    "    return (result[0] if len(result) == 1 else result) or \"No combinations\"\n",
    "\n",
    "\n",
    "from itertools import combinations\n",
    "def find_zero_sum_groups(a, n):\n",
    "    li = sorted(map(sorted,filter(lambda x:sum(x)==0,combinations(set(a),n))))\n",
    "    return li if len(li)>1 else li[0] if li else \"No combinations\" if a else \"No elements to combine\"\n",
    "\n",
    "\n",
    "from itertools import combinations as c\n",
    "def find_zero_sum_groups(a,n):\n",
    "    if not len(a):return 'No elements to combine'\n",
    "    r=[sorted(x) for x in c(sorted(set(a)),n) if sum(x)==0]\n",
    "    return sorted(r) if len(r)>1 else r[0] if len(r) else 'No combinations'\n",
    "\n",
    "# https://www.codewars.com/kata/5711fc7c159cde6ac70003e2/solutions/python\n",
    "from itertools import combinations\n",
    "\n",
    "def find_zero_sum_groups(arr, n):\n",
    "    if not arr: return \"No elements to combine\"\n",
    "    res = [list(c) for c in combinations(sorted(set(arr)), n) if not sum(c)]\n",
    "    if not res: return \"No combinations\"\n",
    "    if not res[1:]: return res[0]\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "def solve(a, n):\n",
    "    return any(sum(c) % n == 0 for i in range(len(a)) for c in combinations(a, i+1))\n",
    "\n",
    "def solve(xs, n):\n",
    "    rs = set()\n",
    "    for x in xs:\n",
    "        for r in list(rs):\n",
    "            rs.add((r + x) % n)\n",
    "        rs.add(x % n)\n",
    "    return 0 in rs\n",
    " \n",
    "from itertools import combinations\n",
    "\n",
    "def solve(arr, n):\n",
    "    return any(sum(xs) % n == 0\n",
    "               for i in range(len(arr))\n",
    "               for xs in combinations(arr, i+1))\n",
    "\n",
    "from itertools import combinations\n",
    "\n",
    "def solve(x, n):\n",
    "    return any(sum(cb) % n == 0 for k in range(len(x)) for cb in combinations(x, k + 1))\n",
    "# https://www.codewars.com/kata/59eb64cba954273cd4000099/solutions/python\n",
    "from itertools import combinations\n",
    "def solve(x, n):\n",
    "    def combs(x):\n",
    "        return [c for i in range(1, len(x)+1) for c in combinations(x, i)]\n",
    "    return any(map(lambda x: sum(x) % n == 0, combs(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delete_nth(order,max_e):\n",
    "    ans = []\n",
    "    for o in order:\n",
    "        if ans.count(o) < max_e: ans.append(o)\n",
    "    return ans\n",
    "    \n",
    "from collections import defaultdict\n",
    "\n",
    "def delete_nth(order,max_e):\n",
    "    c = defaultdict(int)\n",
    "    def count(x):\n",
    "        c[x] += 1\n",
    "        return c[x] <= max_e\n",
    "    return filter(count, order)\n",
    "\n",
    "def delete_nth(order, max_e):\n",
    "    d = {}\n",
    "    res = []\n",
    "    for item in order:\n",
    "      n = d.get(item, 0)\n",
    "      if n < max_e:\n",
    "        res.append(item)\n",
    "        d[item] = n+1\n",
    "    return res\n",
    "\n",
    "def delete_nth(order,max_e):\n",
    "    answer = []\n",
    "    for x in order:\n",
    "        if answer.count(x) < max_e:\n",
    "            answer.append(x)\n",
    "            \n",
    "    return answer\n",
    "\n",
    "def delete_nth(order,max_e):\n",
    "    return [o for i,o in enumerate(order) if order[:i].count(o)<max_e ] # yes!\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def delete_nth(order,max_e):\n",
    "    dct = defaultdict(int)\n",
    "    res = []\n",
    "    for i in order:\n",
    "        dct[i] += 1\n",
    "        if dct[i] <= max_e:\n",
    "            res.append(i)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimum_steps(arr, n):\n",
    "    arr = sorted(arr)\n",
    "    s = 0\n",
    "    for i,v in enumerate(arr): \n",
    "        s += v\n",
    "        if s >= n: return i\n",
    "from itertools import accumulate\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5a91a7c5fd8c061367000002/solutions/python\n",
    "def minimum_steps(numbers, value):\n",
    "    return next(i for i, s in enumerate(accumulate(sorted(numbers))) if s >= value)\n",
    "\n",
    "\n",
    "from itertools import accumulate\n",
    "\n",
    "def minimum_steps(numbers, value):\n",
    "    return next(i for i, x in enumerate(accumulate(sorted(numbers))) if x >= value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import mul\n",
    "from functools import reduce\n",
    "\n",
    "def product_array(numbers):\n",
    "    tot = reduce(mul,numbers)\n",
    "    return [tot//n for n in numbers]\n",
    "\n",
    "from numpy import prod\n",
    "\n",
    "def product_array(numbers):\n",
    "    p = prod(numbers)\n",
    "    return [p // i for i in numbers]\n",
    "\n",
    "def product_array(numbers):\n",
    "    prod = eval(\"*\".join(map(str, numbers)))\n",
    "    return [ prod / x for x in numbers ]\n",
    "\n",
    "from functools import reduce\n",
    "def product_array(l):\n",
    "    return [reduce(lambda p, n: p * n, l, 1) / n for n in l]\n",
    "\n",
    "def product_array(n):\n",
    "    prod = eval(\"*\".join(map(str,n)))\n",
    "    return [prod//i for i in n]\n",
    "# https://www.codewars.com/kata/5a905c2157c562994900009d/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def product_sans_n(nums):\n",
    "    z = nums.count(0)\n",
    "    if z > 1: return [0] * len(nums)\n",
    "    \n",
    "    p = reduce(int.__mul__, (v for v in nums if v))\n",
    "    return [not v and p for v in nums] if z else [p//v for v in nums]\n",
    "\n",
    "from functools import reduce\n",
    "prod = lambda L: reduce(lambda a, b:a*b, L)\n",
    "\n",
    "def product_sans_n(N):\n",
    "    l, z = len(N), N.count(0)\n",
    "    if z > 1:                  return l*[0]\n",
    "    if z == 1: i = N.index(0); return [0]*(i)+[prod(N[:i])*prod(N[i+1:])]+[0]*(l-i-1)\n",
    "    p = prod(N);               return [p//i for i in N]\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "\n",
    "def product_sans_n(nums):\n",
    "    z, p = nums.count(0), reduce(int.__mul__, (n for n in nums if n))\n",
    "    return [0 for _ in nums] if z > 1 else [0 if n else p for n in nums] if z else [p // n for n in nums]\n",
    "# https://www.codewars.com/kata/5b3e609cd58499284100007a/solutions/python\n",
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "def mulsum(xs):\n",
    "    return reduce(mul, xs, 1)\n",
    "\n",
    "def product_sans_n(nums):\n",
    "    nz = nums.count(0)\n",
    "    if nz > 1:\n",
    "        return [0] * len(nums)\n",
    "    elif nz:\n",
    "        return [0 if x else mulsum(filter(None, nums)) for x in nums]\n",
    "    xs = mulsum(nums)\n",
    "    return [xs // x for x in nums]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adjacent_element_product(array):\n",
    "    return max( a*b for a, b in zip(array, array[1:]) )\n",
    "\n",
    "\n",
    "def adjacent_element_product(array):\n",
    "    return max(array[i]*array[i+1] for i in range(len(array)-1))\n",
    "\n",
    "from operator import mul\n",
    "def adjacent_element_product(array):\n",
    "    return max(map(mul, array, array[1:]))\n",
    "\n",
    "\n",
    "def adjacent_element_product(array):\n",
    "    return max(x * y for x, y in zip(array, array[1:]))\n",
    "\n",
    "\n",
    "from itertools import islice\n",
    "\n",
    "def adjacent_element_product(xs):\n",
    "    return max(x * y for x, y in zip(xs, islice(xs, 1, None)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def special_number(number):\n",
    "    return \"Special!!\" if re.match(r'^[0-5]+$', str(number)) else \"NOT!!\" \n",
    "\n",
    "def special_number(n):\n",
    "    return'Special!!' if  set(str(n))<=set('012345')else'NOT!!'\n",
    "\n",
    "https://www.codewars.com/kata/5a55f04be6be383a50000187/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from heapq import nlargest\n",
    "\n",
    "def two_oldest_ages(ages):\n",
    "    return sorted(nlargest(2,ages))\n",
    "\n",
    "# https://www.codewars.com/kata/511f11d355fe575d2c000001/solutions/python\n",
    "two_oldest_ages = lambda a: sorted(a)[-2:]\n",
    "\n",
    "def two_oldest_ages(ages):\n",
    "    import heapq\n",
    "    return sorted(heapq.nlargest(2,ages))\n",
    "    #your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "def dominator(arr):\n",
    "    if not arr:\n",
    "        return -1\n",
    "    k, v = Counter(arr).most_common(1)[0]\n",
    "    return k if v > len(arr) / 2 else -1\n",
    "\n",
    "# https://www.codewars.com/kata/559e10e2e162b69f750000b4/solutions/python\n",
    "def dominator(arr):\n",
    "    return next((x for x in set(arr) if arr.count(x) > len(arr)/2),-1)\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "def dominator(arr):\n",
    "    n = Counter(arr).most_common(1)\n",
    "    return n[0][0] if n and n[0][1] > len(arr)//2 else -1\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "def dominator(arr):\n",
    "    xs = Counter(arr).most_common(1)\n",
    "    if xs and (xs[0][1] > len(arr) // 2):\n",
    "        return xs[0][0]\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def longest_repetition(chars):\n",
    "    max_char, max_count = '', 0\n",
    "    char, count = '', 0\n",
    "    for c in chars:\n",
    "        if c != char:\n",
    "            count, char = 0, c\n",
    "        count += 1\n",
    "        if count > max_count:\n",
    "            max_char, max_count = char, count\n",
    "    return max_char, max_count\n",
    "\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    from itertools import groupby\n",
    "    return max(((char, len(list(group))) for char, group in groupby(chars)),\n",
    "               key=lambda char_group: char_group[1], default=(\"\", 0))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    if not chars: return (\"\", 0)\n",
    "    \n",
    "    longest = max(re.findall(r\"((.)\\2*)\", chars), key=lambda x: len(x[0]))\n",
    "    return (longest[1], len(longest[0]))\n",
    "\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    return max([(x, len(list(gp))) for x, gp in groupby(chars)], key = lambda x: x[1], default = ('', 0))\n",
    "\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    \n",
    "    if len(chars) == 0:\n",
    "        return '', 0\n",
    "        \n",
    "    the_char = chars[0]\n",
    "    the_count = 1\n",
    "    \n",
    "    count = 1\n",
    "    for i in range(1,len(chars)):\n",
    "        \n",
    "        if chars[i-1] == chars[i]:\n",
    "            count += 1\n",
    "        \n",
    "            if the_count < count:\n",
    "                the_char = chars[i]\n",
    "                the_count = count\n",
    "        else:\n",
    "            count = 1\n",
    "    \n",
    "    return the_char, the_count\n",
    "\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    last = ''\n",
    "    count = 0\n",
    "    max = (last, count)\n",
    "    for c in chars:\n",
    "        if c == last:\n",
    "            count += 1\n",
    "        else:\n",
    "            last = c\n",
    "            count = 1\n",
    "        if max[1] < count: max = (last, count)\n",
    "    return max\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    matches = [(len(m.group()), -i, m.group()) for i, m in enumerate(re.finditer(r'(.)\\1*', chars))]\n",
    "    x = max(matches, default=(0, 0, ''))\n",
    "    return x[-1][:1], x[0]\n",
    "\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    \"\"\" Returns a tuple with the longest consecutive character\n",
    "    and its length. If multiple, returns the first example \"\"\"\n",
    "    \n",
    "    longest = current = ''\n",
    "    longest_rep = current_rep = 0\n",
    "    \n",
    "    for c in chars:\n",
    "        if current == c:\n",
    "            current_rep += 1\n",
    "        else:\n",
    "            current = c\n",
    "            current_rep = 1\n",
    "        if current_rep > longest_rep:\n",
    "            longest_rep = current_rep\n",
    "            longest = current\n",
    "    return (longest, longest_rep)\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def longest_repetition(chars):\n",
    "    return max(((c, len(list(g))) for c, g in groupby(chars)), key = lambda t: t[1], default=('', 0)) \n",
    "\n",
    "# https://www.codewars.com/kata/586d6cefbcc21eed7a001155/solutions/python\n",
    "def longest_repetition(chars):\n",
    "    output = ('', 0)\n",
    "    l = len(chars)\n",
    "    x = 0\n",
    "    while x < l:\n",
    "        c = chars[x]\n",
    "        n = 1\n",
    "        while x < l-1 and chars[x+1] == c:\n",
    "            n += 1\n",
    "            x += 1\n",
    "        if n > output[1]:\n",
    "            output = (c, n)\n",
    "        x += 1    \n",
    "    return output  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parts_sums(ls):\n",
    "    result = [sum(ls)]\n",
    "    for item in ls:\n",
    "        result.append(result[-1]-item)\n",
    "    return result\n",
    "\n",
    "# https://www.codewars.com/kata/5ce399e0047a45001c853c2b/solutions/python\n",
    "def parts_sums(ls):\n",
    "    L=[sum(ls)]\n",
    "    for i in range(len(ls)):\n",
    "        L.append(L[i]-ls[i])\n",
    "    return L\n",
    "\n",
    "from itertools import accumulate\n",
    "\n",
    "def parts_sums(ls):\n",
    "    return [0, *accumulate(reversed(ls))][::-1]\n",
    "\n",
    "\n",
    "from itertools import accumulate\n",
    "\n",
    "def parts_sums(ls):\n",
    "    return list(accumulate(ls[::-1]))[::-1]+[0]\n",
    "\n",
    "\n",
    "def parts_sums(ls):\n",
    "    result = [sum(ls)]   \n",
    "    for value in ls:\n",
    "        result.append(result[-1] - value)\n",
    "    return result\n",
    "\n",
    "\n",
    "def parts_sums(ls):\n",
    "    sums = []\n",
    "    n = sum(ls)\n",
    "    sums.append(n)\n",
    "    for i in ls:\n",
    "        n = n - i\n",
    "        sums.append(n)\n",
    "    return sums\n",
    "\n",
    "\n",
    "from itertools import accumulate\n",
    "\n",
    "def parts_sums(lst):\n",
    "    s = sum(lst)\n",
    "    return [s, *(s-v for v in accumulate(lst))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_inversions(array):\n",
    "    inv_count = 0\n",
    "    for i in range(len(array)):\n",
    "        for j in range(i, len(array)):\n",
    "            if array[i] > array[j]:\n",
    "                inv_count += 1\n",
    "    return inv_count\n",
    "\n",
    "def count_inversions(array):\n",
    "    return sum(x > y for i,x in enumerate(array) for y in array[i+1:])\n",
    "\n",
    "count_inversions=lambda arr:sum(sum(k>j for k in arr[:i]) for i,j in enumerate(arr))\n",
    "\n",
    "def count_inversions(array):\n",
    "    n = len(array)\n",
    "    return sum([1 for i in range(n) for j in range(n) if (i < j and array[i] > array[j])])\n",
    "\n",
    "def count_inversions(lst):\n",
    "    return sum(1 for i, m in enumerate(lst, 1) for n in lst[i:] if n < m)\n",
    "\n",
    "from itertools import islice\n",
    "\n",
    "def count_inversions(array):\n",
    "    return sum(\n",
    "        sum(x > y for y in islice(array, i+1, None))\n",
    "        for i, x in enumerate(array)\n",
    "    )\n",
    "\n",
    "# https://www.codewars.com/kata/537529f42993de0e0b00181f/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pendulum(a):\n",
    "    a = sorted(a)\n",
    "    return a[::2][::-1] + a[1::2]\n",
    "# https://www.codewars.com/kata/5bd776533a7e2720c40000e5/solutions/python\n",
    "from collections import deque\n",
    "def pendulum(values):\n",
    "    x = deque()\n",
    "    v = sorted(values)\n",
    "    for i, n in enumerate(v):\n",
    "        x.append(n) if i%2 else x.appendleft(n)\n",
    "    return list(x)\n",
    "\n",
    "def pendulum(values):\n",
    "    return sorted(values)[::2][::-1]+ sorted(values)[1::2]\n",
    "\n",
    "def pendulum(values):\n",
    "    left = []\n",
    "    right = []\n",
    "    values.sort()\n",
    "    for i, k in enumerate(values):\n",
    "        if i % 2 ==0:\n",
    "            left.append(k)\n",
    "        else:\n",
    "            right.append(k)\n",
    "    left.reverse()\n",
    "    res = left + right\n",
    "    return res\n",
    "\n",
    "def pendulum(values):\n",
    "    tmp = sorted(values)\n",
    "    return tmp[::2][::-1] + tmp[1::2]\n",
    "\n",
    "def pendulum(values):\n",
    "    s = sorted(values)\n",
    "    return s[::2][::-1] + s[1::2]\n",
    "\n",
    "def pendulum(values):\n",
    "    note = sorted(values)\n",
    "    return note[::2][::-1] + note[1::2]\n",
    "\n",
    "def pendulum(arr):\n",
    "    arr = sorted(arr)\n",
    "    return arr[0::2][::-1] + arr[1::2]\n",
    " \n",
    "def pendulum(values):\n",
    "    sorted_v = sorted(values, reverse=True)\n",
    "    if len(sorted_v) % 2 == 0: return sorted_v[1::2] + sorted(sorted_v[::2])\n",
    "    else: return sorted_v[::2] + sorted(sorted_v[1::2])\n",
    "from itertools import count, cycle\n",
    "\n",
    "def pendulum(values):\n",
    "    xs = sorted(values)\n",
    "    result = [0] * len(xs)\n",
    "    r = (len(xs) + 1) // 2\n",
    "    l = r - 1\n",
    "    for x, it in zip(xs, cycle([count(l, -1), count(r)])):\n",
    "        result[next(it)] = x\n",
    "    return result\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    values.sort()\n",
    "    return list(reversed(values[0::2])) + values[1::2]\n",
    "\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "def pendulum(arr):    \n",
    "    out, cnt = deque(), 0\n",
    "\n",
    "    for i in deque(sorted(arr)):\n",
    "        if cnt%2==0:\n",
    "            out.appendleft(i)\n",
    "        else:\n",
    "            out.append(i)\n",
    "        cnt += 1\n",
    "    return list(out)\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    \"\"\"Sort numbers into a pendulum order\"\"\"\n",
    "    values.sort()\n",
    "    # 1 = right 0 = left\n",
    "    rightOrLeft = 1\n",
    "    minValue = min(values)\n",
    "\n",
    "    leftList = []\n",
    "    rightList = [minValue]\n",
    "\n",
    "    for number in values[1:]:\n",
    "        if rightOrLeft == 1:\n",
    "            rightList.append(number)\n",
    "            rightOrLeft = 0\n",
    "        else:\n",
    "            leftList.append(number)\n",
    "            rightOrLeft = 1\n",
    "    return leftList[::-1] + rightList\n",
    "\n",
    "\n",
    "def pendulum(a):\n",
    "    a.sort()\n",
    "    return [a[-i - 1] for i in range(0 if len(a) & 1 else 1, len(a), 2)] + [a[i] for i in range(1, len(a), 2)]\n",
    "\n",
    "\n",
    "from collections import deque\n",
    "from itertools import cycle\n",
    "def pendulum(values):\n",
    "    values.sort(reverse=True)\n",
    "    arr=deque()\n",
    "    lr=cycle([0,1])\n",
    "    while values:[arr.appendleft,arr.append][next(lr)](values.pop())     \n",
    "    return list(arr)\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    if len(values) % 2 != 0:\n",
    "        minval = [min(values)]\n",
    "        values.remove(min(values))\n",
    "        values = sorted(values, reverse=True)\n",
    "        return values[::2] + minval + values[-1::-2]\n",
    "    else:\n",
    "        minval = [min(values)]\n",
    "        values = sorted(values)\n",
    "        return values[-2:0:-2] + minval + values[1::2]\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    '''Returns values sorted, with smallest value at centre of the list and the \n",
    "    remaining sorted incrmentally left then right'''\n",
    "    sorted_values = sorted(values)\n",
    "    mid = [sorted_values [0]]\n",
    "    right = sorted_values[1::2]\n",
    "    left = sorted_values[2::2]\n",
    "    return left[::-1] + mid + right\n",
    "\n",
    "def pendulum(values):    \n",
    "    result=values.copy()\n",
    "    values.sort()\n",
    "    index = (len(values) - 1) // 2\n",
    "    step = 1\n",
    "    for i in range(len(values)):\n",
    "        if i== 0: result[index] = values[i]\n",
    "        elif i%2 == 1: result[index + step] = values[i]\n",
    "        else:\n",
    "            result[index - step]=values[i]\n",
    "            step += 1\n",
    "    return result\n",
    "\n",
    "def pendulum(values):\n",
    "    values.sort()\n",
    "    n=[]\n",
    "    i=0\n",
    "    m=1\n",
    "    while i <= (len(values)-1):\n",
    "        n.insert(0,values[i])\n",
    "        i+=2\n",
    "    while m <= (len(values)-1):\n",
    "        n.append(values[m])\n",
    "        m+=2\n",
    "    return(n)\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    values.sort()\n",
    "    res=[]\n",
    "    x, y=[], []\n",
    "    for i in range(len(values)):\n",
    "        if i%2==0:\n",
    "            x.append(values[i])\n",
    "            #res.insert(0, values[i])\n",
    "        else:\n",
    "            #res.append(values[i])\n",
    "            y.append(values[i])\n",
    "    return x[::-1]+y\n",
    "\n",
    "def pendulum(values):\n",
    "    values.sort()\n",
    "    return list(reversed(values[0::2])) + values[1::2]\n",
    "\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "def pendulum(arr):    \n",
    "    out, cnt = deque(), 0\n",
    "\n",
    "    for i in deque(sorted(arr)):\n",
    "        if cnt%2==0:\n",
    "            out.appendleft(i)\n",
    "        else:\n",
    "            out.append(i)\n",
    "        cnt += 1\n",
    "    return list(out)\n",
    "\n",
    "\n",
    "def pendulum(values):\n",
    "    \"\"\"Sort numbers into a pendulum order\"\"\"\n",
    "    values.sort()\n",
    "    # 1 = right 0 = left\n",
    "    rightOrLeft = 1\n",
    "    minValue = min(values)\n",
    "\n",
    "    leftList = []\n",
    "    rightList = [minValue]\n",
    "\n",
    "    for number in values[1:]:\n",
    "        if rightOrLeft == 1:\n",
    "            rightList.append(number)\n",
    "            rightOrLeft = 0\n",
    "        else:\n",
    "            leftList.append(number)\n",
    "            rightOrLeft = 1\n",
    "    return leftList[::-1] + rightList\n",
    "\n",
    "\n",
    "def pendulum(a):\n",
    "    a.sort()\n",
    "    return [a[-i - 1] for i in range(0 if len(a) & 1 else 1, len(a), 2)] + [a[i] for i in range(1, len(a), 2)]\n",
    "\n",
    "\n",
    "from collections import deque\n",
    "from itertools import cycle\n",
    "def pendulum(values):\n",
    "    values.sort(reverse=True)\n",
    "    arr=deque()\n",
    "    lr=cycle([0,1])\n",
    "    while values:[arr.appendleft,arr.append][next(lr)](values.pop())     \n",
    "    return list(arr)\n",
    "        \n",
    "    \n",
    "def pendulum(values):\n",
    "    if len(values) % 2 != 0:\n",
    "        minval = [min(values)]\n",
    "        values.remove(min(values))\n",
    "        values = sorted(values, reverse=True)\n",
    "        return values[::2] + minval + values[-1::-2]\n",
    "    else:\n",
    "        minval = [min(values)]\n",
    "        values = sorted(values)\n",
    "        return values[-2:0:-2] + minval + values[1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def is_pangram(s):\n",
    "    return set(string.lowercase) <= set(s.lower())\n",
    "\n",
    "import string\n",
    "\n",
    "def is_pangram(s):\n",
    "    s = s.lower()\n",
    "    for char in 'abcdefghijklmnopqrstuvwxyz':\n",
    "        if char not in s:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "import string\n",
    "# https://www.codewars.com/kata/545cedaa9943f7fe7b000048/solutions/python\n",
    "def is_pangram(s):\n",
    "    s = s.lower()\n",
    "    return all(letter in s for letter in string.lowercase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def solve(s):\n",
    "    return max(sum(ord(c)-96 for c in subs) for subs in re.split('[aeiou]+', s))\n",
    "\n",
    "# https://www.youtube.com/watch?v=w_lz1Nc-AOY\n",
    "def solve(s):\n",
    "    max_ord = 0\n",
    "    curr_ord = 0\n",
    "    for char in s:\n",
    "        if char not in 'aeiou':\n",
    "            curr_ord += ord(char)-ord('a')+1\n",
    "        else:\n",
    "            if curr_ord > max_ord:\n",
    "                max_ord = curr_ord\n",
    "            curr_ord = 0\n",
    "    return max_ord\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    count = 0\n",
    "    max = 0\n",
    "    vowels = [\"a\", \"e\", \"i\", \"o\", \"u\"]\n",
    "    for letter in s:\n",
    "        if letter in vowels:\n",
    "            if count > max:\n",
    "                max = count\n",
    "            count = 0\n",
    "        else:\n",
    "            count+=int(ord(letter)) - 96\n",
    "    return max\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def solve(s):\n",
    "    return max(sum(ord(x)-96 for x in c) for c in re.split('[aeiou]',s))\n",
    "\n",
    "\n",
    "import string\n",
    "def solve(s):\n",
    "    string_list=(list(s))\n",
    "    alphabets=(list(string.ascii_lowercase))\n",
    "    test=[]\n",
    "    for i in range(1,len(alphabets)+1):\n",
    "        test.append(i)\n",
    "    my_dictionary=dict(zip(alphabets,test))\n",
    "    vowels=\"aeiou\"\n",
    "    vowels_list=list(vowels)\n",
    "    compare_list1=[]\n",
    "    for i in range(len(string_list)):\n",
    "        if string_list[i] in my_dictionary and string_list[i] not in vowels:\n",
    "            l=(my_dictionary[string_list[i]])\n",
    "            compare_list1.append(l)\n",
    "        else:\n",
    "            compare_list1.append(\"vowels\")\n",
    "            \n",
    "    z=(compare_list1)\n",
    "    x = []\n",
    "    l = len(z)\n",
    "    previous_element = 0\n",
    "    count = 0\n",
    "    if( isinstance(z[0] , int)  == True ):\n",
    "            count = z[0]    \n",
    "    elif( z[0] == 'vowels' ):\n",
    "            previous_element = z[0]           \n",
    "    for i in range(1,l):\n",
    "        if( previous_element == 'vowels' ):\n",
    "                if(count > 0):\n",
    "                    x.append(count)\n",
    "                count = 0       \n",
    "        elif( isinstance( previous_element , int)  == True ):\n",
    "                count = count + previous_element\n",
    "        previous_element = z[i]       \n",
    "    if( isinstance(z[l-1] , int)  == True ):\n",
    "            count = count + previous_element\n",
    "            x.append(count)    \n",
    "    elif( z[l-1] == 'vowels' ):\n",
    "            x.append(count)       \n",
    "    print(x) \n",
    "    y=max(x)\n",
    "    return y\n",
    "        \n",
    "solve(\"zodiacs\")\n",
    "\n",
    "def solve(s):\n",
    "    s = s.replace('a',' ').replace('e',' ').replace('i',' ').replace('u',' ').replace('o',' ')\n",
    "    return max((sum(ord(i)-96 for i in j) for j in s.split()))\n",
    "\n",
    "import re\n",
    "import string\n",
    "\n",
    "scores = {c: i for i, c in enumerate(string.ascii_lowercase, 1)}\n",
    "\n",
    "def solve(s):\n",
    "    return max(sum(map(scores.get, x)) for x in re.findall('[^aeiou]+', s))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "CONS_PAT = re.compile(r\"[^aeiuo]+\")\n",
    "\n",
    "def solve(s):\n",
    "    return max(sum(map(lambda c: ord(c)-96, conss)) for conss in CONS_PAT.findall(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    return ''.join(' ' + c if c.isupper() else c for c in s)\n",
    "# https://www.codewars.com/kata/5208f99aee097e6552000148/solutions/python\n",
    "import re\n",
    "def solution(s):\n",
    "    return re.sub('([A-Z])', r' \\1', s)\n",
    "\n",
    "def solution(s):\n",
    "    final_string = \"\"\n",
    "    for i in range(len(s)):\n",
    "        char = s[i]\n",
    "        if char.isupper():\n",
    "            final_string += \" \" + char\n",
    "        else:\n",
    "            final_string += char\n",
    "    return final_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "\n",
    "def directions(goal):\n",
    "    c = Counter(goal)\n",
    "    c[\"N\"], c[\"W\"] = c[\"N\"] - c[\"S\"], c[\"W\"] - c[\"E\"]\n",
    "    c[\"S\"], c[\"E\"] = -c[\"N\"], -c[\"W\"]\n",
    "    return sorted(c.elements(), key=\"NSEW\".index)\n",
    "\n",
    "# https://www.codewars.com/kata/56a14f18005af7002f00003f/solutions/python\n",
    "from collections import Counter\n",
    "\n",
    "def directions(goal):\n",
    "    c = Counter(goal)\n",
    "    for a, b in ['NS', 'EW']:\n",
    "        m = min(c[a], c[b])\n",
    "        c[a] -= m\n",
    "        c[b] -= m\n",
    "    return sorted(c.elements(), key='NSEW'.find)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "def solve(a, b):\n",
    "    primes = set([2] + [n for n in range(3, b, 2) if all(n % r for r in range(3, int(n**0.5)+1, 2))])\n",
    "    return sum( sum(map(int, str(x*y))) in primes for x, y in itertools.combinations_with_replacement([p for p in primes if a <= p < b], 2) )\n",
    "\n",
    "from bisect import bisect_left\n",
    "\n",
    "def sieve(n):\n",
    "    sieve, primes = [0]*(n+1), []\n",
    "    for i in range(2, n+1):\n",
    "        if not sieve[i]:\n",
    "            primes.append(i)\n",
    "            for j in range(i**2, n+1, i): sieve[j] = 1\n",
    "    return primes\n",
    "\n",
    "PRIMES = sieve(10000)\n",
    "SET_PRIMES = set(PRIMES)\n",
    "\n",
    "def solve(a,b):\n",
    "    p1, p2 = bisect_left(PRIMES, a), bisect_left(PRIMES, b)\n",
    "    return sum( sum(map(int, str(p*q))) in SET_PRIMES for i,p in enumerate(PRIMES[p1:p2],p1) for q in PRIMES[i:p2])\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Build prime sieve\n",
    "limit = 1_000_000\n",
    "prime_sieve = np.ones(limit + 1)\n",
    "prime_sieve[:2] = 0\n",
    "prime_sieve[4::2] = 0\n",
    "for i in range(3, len(prime_sieve), 2):\n",
    "    if prime_sieve[i]:\n",
    "        prime_sieve[i * i::i] = 0\n",
    "\n",
    "# Get list of primes\n",
    "primes = [i for i, p in enumerate(prime_sieve) if p]\n",
    "\n",
    "def solve(a, b):\n",
    "    result = 0\n",
    "    targets = [p for p in primes if a <= p < b]\n",
    "    for i, p1 in enumerate(targets):\n",
    "        for p2 in targets[i:]:\n",
    "            prod = p1 * p2\n",
    "            digit_sum = sum(int(d) for d in str(prod))\n",
    "            if prime_sieve[digit_sum]:\n",
    "                result += 1\n",
    "    return result\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as replacements\n",
    "\n",
    "\n",
    "primes = {2}\n",
    "sieve = [True] * 5000\n",
    "for i in range(3, 102, 2):\n",
    "    if sieve[i // 2]:\n",
    "        sieve[i * i // 2 :: i] = [False] * ((10001 - i * i - 1) // (2 * i) + 1)\n",
    "primes.update((2 * i + 1) for i in range(1, 5000) if sieve[i])\n",
    "\n",
    "\n",
    "def solve(a, b):\n",
    "    pairs = replacements(set(range(a, b)) & primes, 2)\n",
    "    return sum(1 for p, q in pairs if sum(int(d) for d in str(p * q)) in primes)\n",
    "\n",
    "from itertools import compress, combinations_with_replacement\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "s = np.ones(10001)\n",
    "s[:2] = s[4::2] = 0\n",
    "for i in range(3, int(len(s)**0.5)+1, 2):\n",
    "    if s[i]:\n",
    "        s[i*i::i] = 0\n",
    "PRIMES = list(compress(range(len(s)), s))\n",
    "\n",
    "def solve(a, b):\n",
    "    i, j = np.searchsorted(PRIMES, a), np.searchsorted(PRIMES, b)\n",
    "    return sum(s[sum(map(int, str(x * y)))] for x, y in combinations_with_replacement(PRIMES[i:j], 2))\n",
    "\n",
    "from itertools import combinations_with_replacement\n",
    "\n",
    "primes = [2,3,5]\n",
    "\n",
    "\n",
    "def is_prime(n):\n",
    "    i = 1\n",
    "    while primes[i]*primes[i]<=n:\n",
    "        if n % primes[i] == 0:\n",
    "            return False\n",
    "        i += 1\n",
    "    return True\n",
    "    \n",
    "    \n",
    "def find_primes(a, b):\n",
    "    global primes\n",
    "    i = primes[-1] + 2\n",
    "    while i < b:\n",
    "        if is_prime(i):\n",
    "            primes.append(i)\n",
    "        i += 2\n",
    "    i = 0\n",
    "    j = len(primes)\n",
    "    while primes[i] < a:\n",
    "        i += 1\n",
    "    while primes[j-1] >= b:\n",
    "        j -= 1\n",
    "    return primes[i:j]\n",
    "    \n",
    "    \n",
    "def check_digits(p1, p2):\n",
    "    return sum([int(i) for i in str(p1*p2)]) in primes\n",
    "    \n",
    "\n",
    "def solve(a,b):\n",
    "    return sum([1 if check_digits(*pair) else 0 for pair in combinations_with_replacement(find_primes(a,b), 2) ])\n",
    "\n",
    "primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129,2131,2137,2141,2143,2153,2161,2179,2203,2207,2213,2221,2237,2239,2243,2251,2267,2269,2273,2281,2287,2293,2297,2309,2311,2333,2339,2341,2347,2351,2357,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423,2437,2441,2447,2459,2467,2473,2477,2503,2521,2531,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617,2621,2633,2647,2657,2659,2663,2671,2677,2683,2687,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741,2749,2753,2767,2777,2789,2791,2797,2801,2803,2819,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903,2909,2917,2927,2939,2953,2957,2963,2969,2971,2999,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079,3083,3089,3109,3119,3121,3137,3163,3167,3169,3181,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257,3259,3271,3299,3301,3307,3313,3319,3323,3329,3331,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413,3433,3449,3457,3461,3463,3467,3469,3491,3499,3511,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571,3581,3583,3593,3607,3613,3617,3623,3631,3637,3643,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727,3733,3739,3761,3767,3769,3779,3793,3797,3803,3821,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907,3911,3917,3919,3923,3929,3931,3943,3947,3967,3989,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057,4073,4079,4091,4093,4099,4111,4127,4129,4133,4139,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231,4241,4243,4253,4259,4261,4271,4273,4283,4289,4297,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409,4421,4423,4441,4447,4451,4457,4463,4481,4483,4493,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583,4591,4597,4603,4621,4637,4639,4643,4649,4651,4657,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751,4759,4783,4787,4789,4793,4799,4801,4813,4817,4831,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937,4943,4951,4957,4967,4969,4973,4987,4993,4999,5003,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087,5099,5101,5107,5113,5119,5147,5153,5167,5171,5179,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279,5281,5297,5303,5309,5323,5333,5347,5351,5381,5387,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443,5449,5471,5477,5479,5483,5501,5503,5507,5519,5521,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639,5641,5647,5651,5653,5657,5659,5669,5683,5689,5693,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791,5801,5807,5813,5821,5827,5839,5843,5849,5851,5857,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939,5953,5981,5987,6007,6011,6029,6037,6043,6047,6053,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133,6143,6151,6163,6173,6197,6199,6203,6211,6217,6221,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301,6311,6317,6323,6329,6337,6343,6353,6359,6361,6367,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473,6481,6491,6521,6529,6547,6551,6553,6563,6569,6571,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673,6679,6689,6691,6701,6703,6709,6719,6733,6737,6761,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833,6841,6857,6863,6869,6871,6883,6899,6907,6911,6917,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997,7001,7013,7019,7027,7039,7043,7057,7069,7079,7103,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207,7211,7213,7219,7229,7237,7243,7247,7253,7283,7297,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411,7417,7433,7451,7457,7459,7477,7481,7487,7489,7499,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561,7573,7577,7583,7589,7591,7603,7607,7621,7639,7643,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723,7727,7741,7753,7757,7759,7789,7793,7817,7823,7829,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919]\n",
    "    \n",
    "\n",
    "def solve(a,b):\n",
    "    global primes\n",
    "    count = 0\n",
    "    p = list(filter(lambda n: a <= n < b, primes))\n",
    "    for i in range(len(p)):\n",
    "        for j in range(i, len(p)):\n",
    "            if sum(int(c) for c in str(p[i] * p[j])) in primes: count += 1\n",
    "    return count\n",
    "\n",
    "from itertools import combinations_with_replacement\n",
    "find_prime=lambda n:all(n % i for i in range(2, int(n ** .5) + 1)) and n > 1\n",
    "solve=lambda s,e:len([1for i in combinations_with_replacement([i for i in range(s,e)if find_prime(i)],2)if find_prime(sum(map(int,str(i[0]*i[1]))))])\n",
    "\n",
    "from gmpy2 import is_prime, next_prime\n",
    "from itertools import combinations_with_replacement as comb\n",
    "\n",
    "def solve(a,b):\n",
    "    L=[next_prime(a-1)]\n",
    "    while next_prime(L[-1])<b:\n",
    "        L.append(next_prime(L[-1]))\n",
    "    return sum(is_prime(sum(map(int, str(i*j)))) for i, j in comb(L, 2))\n",
    "# https://www.codewars.com/kata/59b46276afcda204ed000094/solutions/python\n",
    "from gmpy2 import is_prime, next_prime\n",
    "from itertools import combinations_with_replacement as comb\n",
    "\n",
    "def solve(a,b):\n",
    "    L=[2]\n",
    "    while next_prime(L[-1])<b:\n",
    "        L.append(next_prime(L[-1]))\n",
    "    primes=filter(lambda n: a<=n<b, L)\n",
    "    return sum(is_prime(sum(map(int, str(i*j)))) for i, j in comb(primes, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "def solve(n, k):\n",
    "    return ''.join(min(combinations(str(n), len(str(n))-k)))\n",
    "\n",
    "from itertools import combinations\n",
    "\n",
    "def solve(n,k):\n",
    "    return min((''.join(c) for c in combinations(str(n), len(str(n))-k)), key=int)\n",
    "\n",
    "from itertools import combinations as c\n",
    "def solve(n,k):\n",
    "    b=len(str(n))-k\n",
    "    l=[''.join(i) for i in c(str(n),b)]\n",
    "    return min(l)\n",
    "\n",
    "\n",
    "from itertools import combinations\n",
    "# https://www.codewars.com/kata/59fd6d2332b8b9955200005f/solutions/python\n",
    "def solve(n, k):\n",
    "    s = str(n)\n",
    "    return ''.join(min(xs for xs in combinations(s, len(s)-k)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "REGEX = re.compile(r'''\n",
    "    ((?P<kebab>[a-z]+(-[a-z]+)+)|\n",
    "     (?P<snake>[a-z]+(_[a-z]+)+)|\n",
    "     (?P<camel>[a-z]+([A-Z][a-z]+)+))$''', re.VERBOSE)\n",
    "\n",
    "\n",
    "def case_id(s):\n",
    "    m = REGEX.match(s)\n",
    "    if not m:\n",
    "        return 'none'\n",
    "    return next(k for k, v in m.groupdict().iteritems() if v is not None)\n",
    "\n",
    "import re\n",
    "\n",
    "CASES = [\n",
    "    ('snake', re.compile(r'\\A[a-z]+(_[a-z]+)+\\Z')),\n",
    "    ('kebab', re.compile(r'\\A[a-z]+(-[a-z]+)+\\Z')),\n",
    "    ('camel', re.compile(r'\\A[a-z]+([A-Z][a-z]*)+\\Z')),\n",
    "    ('none', re.compile(r'')),\n",
    "]\n",
    "\n",
    "def case_id(c_str):\n",
    "    for case, pattern in CASES:\n",
    "        if pattern.match(c_str): return case\n",
    "# https://www.codewars.com/kata/5819a6fdc929bae4f5000a33/solutions/python\n",
    "        \n",
    "import re\n",
    "\n",
    "def case_id(c_str):\n",
    "    if re.match(r'^([a-z]+\\-)+[a-z]+$', c_str):\n",
    "        return 'kebab'\n",
    "    if re.match(r'^([a-z]+\\_)+[a-z]+$', c_str):\n",
    "        return 'snake'\n",
    "    if re.match(r'^([a-z]+[A-Z])+[a-z]+$', c_str):\n",
    "        return 'camel'\n",
    "    return 'none'\n",
    "\n",
    "def case_id(stg):\n",
    "    print(stg)\n",
    "    if \"-\" in stg and \"_\" not in stg and all(w.islower() for w in stg.split(\"-\")):\n",
    "        return \"kebab\"\n",
    "    if \"_\" in stg and \"-\" not in stg and all(w.islower() for w in stg.split(\"_\")):\n",
    "        return \"snake\"\n",
    "    if stg.isalpha() and any(c.isupper() for c in stg):\n",
    "        return \"camel\"\n",
    "    return \"none\"\n",
    "\n",
    "import re\n",
    "def case_id(c_str):\n",
    "    if re.match(r'[a-z]+(-[a-z]+)+$', c_str):\n",
    "        return \"kebab\" \n",
    "    if re.match(r'[a-z]+(_[a-z]+)+$', c_str):\n",
    "        return \"snake\"\n",
    "    if re.match(r'[a-z]+([A-Z][a-z]+)+$', c_str): \n",
    "        return \"camel\"\n",
    "    return 'none'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isomorph(a, b):\n",
    "    return len(a) == len(b) and len(set(a)) == len(set(b)) == len(set(zip(a, b)))\n",
    "\n",
    "# https://www.codewars.com/kata/59dbab4d7997cb350000007f/solutions/python\n",
    "def isomorph(a, b):\n",
    "    normalize = lambda s: [s.index(c) for c in s]\n",
    "    return normalize(a) == normalize(b)\n",
    "\n",
    "def isomorph(a, b):\n",
    "    return len(a) == len(b) and a.translate(str.maketrans(a, b)) == b and b.translate(str.maketrans(b, a)) == a\n",
    "\n",
    "def isomorph(a, b):\n",
    "    return [a.index(h) for h in a]==[b.index(g) for g in b]\n",
    "  # Happy coding!\n",
    "from collections import defaultdict\n",
    "\n",
    "def isomorph(a, b):\n",
    "    print(a, b)\n",
    "    da,db = defaultdict(list), defaultdict(list)\n",
    "    for i in range(len(a)==len(b) and len(a)):\n",
    "        if da[a[i]] != db[b[i]]: return False\n",
    "        da[a[i]].append(i)\n",
    "        db[b[i]].append(i)\n",
    "    return bool(da)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def reverse_words(str):\n",
    "  return re.sub(r'\\S+', lambda w: w.group(0)[::-1], str)\n",
    "\n",
    "def reverse_words(str):\n",
    "  return ' '.join(w[::-1] for w in str.split(' '))\n",
    "\n",
    "def reverse_words(str):\n",
    "  return \" \".join(map(lambda word: word[::-1], str.split(' ')))\n",
    "\n",
    "def reverse_words(str):\n",
    "  #go for it\n",
    "  newStr = []\n",
    "  for i in str.split(' '):\n",
    "      newStr.append(i[::-1])\n",
    "  return ' '.join(newStr)\n",
    "\n",
    "import re\n",
    "\n",
    "def reverse_words(str):\n",
    "  return ''.join(word[::-1] for word in re.split(r'(\\s+)', str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter, defaultdict\n",
    "# https://www.codewars.com/kata/5e98712b7de14f0026ef1cc1/solutions/python\n",
    "def group_cities(seq):\n",
    "    bases = defaultdict(lambda: defaultdict(list))\n",
    "    for W in set(seq):\n",
    "        w = W.lower()\n",
    "        d = bases[ frozenset(Counter(w).items()) ]\n",
    "        k = next( (w2 for w2 in d if w in w2), w*2)\n",
    "        d[k].append(W)\n",
    "        \n",
    "    return sorted( [sorted(lst) for d in bases.values() for lst in d.values()],\n",
    "                   key=lambda g: (-len(g),g[0]) )\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def group_cities(seq): \n",
    "    key = lambda s: min(s[i:]+s[:i] for i in range(len(s)))\n",
    "    d = defaultdict(set)\n",
    "    for e in seq: d[key(e.lower())].add(e)\n",
    "    return sorted((sorted(v) for v in d.values()), key=lambda x: (-len(x),x))\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "def group_cities(seq):\n",
    "    result = []\n",
    "    \n",
    "    # Remove duplicates\n",
    "    seq = sorted(set(seq))\n",
    "\n",
    "    # Convert to lower case for comparisons\n",
    "    simples = [c.lower() for c in seq]\n",
    "    \n",
    "    # Indices that have already been added to a set\n",
    "    skip = set()\n",
    "    \n",
    "    # Look for matches\n",
    "    for i, c1 in enumerate(simples):\n",
    "        if i in skip:\n",
    "            # Already matched\n",
    "            continue\n",
    "        city_match = [i]\n",
    "        skip.add(i)\n",
    "        \n",
    "        # Create all the rolled versionos of this city name\n",
    "        rolls = []\n",
    "        roller = deque(c1)\n",
    "        roller.rotate(1)\n",
    "        while ''.join(roller) != c1:\n",
    "            rolls.append(''.join(roller))\n",
    "            roller.rotate(1)\n",
    "        \n",
    "        # See if a rolled name is present in any names later in the list\n",
    "        for roll in rolls:\n",
    "            for j, c2 in enumerate(simples[i + 1:], i + 1):\n",
    "                if j in skip:\n",
    "                    # Already matched\n",
    "                    continue\n",
    "                if c2 == roll:\n",
    "                    # Found a matching name, add this index to the matches and skip set\n",
    "                    skip.add(j)\n",
    "                    city_match.append(j)\n",
    "        \n",
    "        # Convert matched indices back to original name\n",
    "        result.append(sorted([seq[k] for k in city_match]))\n",
    "    \n",
    "    # Sort by decreasing length and then alphabetically\n",
    "    result.sort(key=lambda a: (-len(a), a[0]))\n",
    "    return result\n",
    "\n",
    "def group_cities(seq):\n",
    "    res = {}\n",
    "    for w in seq:\n",
    "        temp = [str(w[i:] + w[:i]).title() for i in range(1, len(w)) \n",
    "                if str(w[i:] + w[:i]).title() in seq]\n",
    "        temp.append(w)\n",
    "        res[frozenset(temp)] = sorted(set(temp))\n",
    "    return sorted(res.values(), key=lambda x: (-len(x), x[0]))\n",
    "\n",
    "def is_palindrome(a,b):\n",
    "    if len(a)!=len(b):\n",
    "        return False\n",
    "    else:\n",
    "        for i in range(1,len(a)):\n",
    "            if a.lower()[i:] + a.lower()[:i] == b.lower():\n",
    "                return True\n",
    "        return False\n",
    "def group_cities(seq): \n",
    "    ans=[]\n",
    "    already_chosen=[]\n",
    "    for term in seq:\n",
    "        if term not in already_chosen:\n",
    "            temp=[term]\n",
    "            already_chosen.append(term)\n",
    "            for thing in seq:\n",
    "                if thing not in already_chosen and thing!=term and is_palindrome(thing,term):\n",
    "                    temp.append(thing)\n",
    "                    already_chosen.append(thing)\n",
    "            ans.append(temp)\n",
    "    for thing in ans:\n",
    "        thing.sort()\n",
    "    ans.sort(key=lambda x:x[0])\n",
    "    ans.sort(key=len,reverse=True)\n",
    "    return ans\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def key(s):\n",
    "    s = s.lower().replace(' ', '')\n",
    "    return min(s[i:] + s[:i] for i in range(len(s)))\n",
    "\n",
    "def group_cities(seq): \n",
    "    result = defaultdict(list)\n",
    "    for city in set(seq):\n",
    "        result[key(city)].append(city)\n",
    "    for cities in result.values():\n",
    "        cities.sort()\n",
    "    return sorted(result.values(), key=lambda cities: (-len(cities), cities[0]))\n",
    "\n",
    "def group_cities(seq): \n",
    "    result = []\n",
    "    for element in sorted(list(dict.fromkeys(seq)), key=str.lower):\n",
    "        for group in result:\n",
    "            if element.lower() in [group[0].lower()[r:] + group[0].lower()[:r] for r in range(len(group[0].lower()))]:\n",
    "                group.append(element)\n",
    "                break\n",
    "        else:\n",
    "            result.append([element])\n",
    "\n",
    "    return sorted(result, key=len, reverse=True)\n",
    "\n",
    "from collections import deque\n",
    "from operator import itemgetter\n",
    "\n",
    "\n",
    "def group_cities(seq):\n",
    "    seq_by_length = {}\n",
    "    for s in seq:\n",
    "        l = len(s)\n",
    "        if l in seq_by_length:\n",
    "            seq_by_length[l].append(s)\n",
    "        else:\n",
    "            seq_by_length[l] = [s]\n",
    "\n",
    "    groups = []\n",
    "    for elems in seq_by_length.values():\n",
    "        to_check = deque(set(elems))\n",
    "\n",
    "        while to_check:\n",
    "            cur_check = to_check.pop()\n",
    "            group, check = [cur_check], cur_check.lower() * 2\n",
    "\n",
    "            for c in to_check.copy():\n",
    "                if c.lower() in check:\n",
    "                    group.append(c)\n",
    "                    to_check.remove(c)\n",
    "\n",
    "            groups.append(sorted(group))\n",
    "\n",
    "    return sorted(sorted(groups, key=itemgetter(0)), key=len, reverse=True)\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def group_cities(l):\n",
    "    def make_key(s):\n",
    "        return min(s[-i:] + s[:-i] for i in range(len(s)))\n",
    "    d = defaultdict(list)\n",
    "    for item in sorted(set(l)):\n",
    "        d[make_key(item.lower())].append(item)\n",
    "    return sorted(d.values(), key=len, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "def solve(a, b):\n",
    "    primes = set([2] + [n for n in range(3, b, 2) if all(n % r for r in range(3, int(n**0.5)+1, 2))])\n",
    "    return sum( sum(map(int, str(x*y))) in primes for x, y in itertools.combinations_with_replacement([p for p in primes if a <= p < b], 2) )\n",
    "\n",
    "from bisect import bisect_left\n",
    "\n",
    "def sieve(n):\n",
    "    sieve, primes = [0]*(n+1), []\n",
    "    for i in range(2, n+1):\n",
    "        if not sieve[i]:\n",
    "            primes.append(i)\n",
    "            for j in range(i**2, n+1, i): sieve[j] = 1\n",
    "    return primes\n",
    "\n",
    "PRIMES = sieve(10000)\n",
    "SET_PRIMES = set(PRIMES)\n",
    "\n",
    "def solve(a,b):\n",
    "    p1, p2 = bisect_left(PRIMES, a), bisect_left(PRIMES, b)\n",
    "    return sum( sum(map(int, str(p*q))) in SET_PRIMES for i,p in enumerate(PRIMES[p1:p2],p1) for q in PRIMES[i:p2])\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Build prime sieve\n",
    "limit = 1_000_000\n",
    "prime_sieve = np.ones(limit + 1)\n",
    "prime_sieve[:2] = 0\n",
    "prime_sieve[4::2] = 0\n",
    "for i in range(3, len(prime_sieve), 2):\n",
    "    if prime_sieve[i]:\n",
    "        prime_sieve[i * i::i] = 0\n",
    "# https://www.codewars.com/kata/59b46276afcda204ed000094/solutions/python\n",
    "# Get list of primes\n",
    "primes = [i for i, p in enumerate(prime_sieve) if p]\n",
    "\n",
    "def solve(a, b):\n",
    "    result = 0\n",
    "    targets = [p for p in primes if a <= p < b]\n",
    "    for i, p1 in enumerate(targets):\n",
    "        for p2 in targets[i:]:\n",
    "            prod = p1 * p2\n",
    "            digit_sum = sum(int(d) for d in str(prod))\n",
    "            if prime_sieve[digit_sum]:\n",
    "                result += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_zero(arr):\n",
    "    m, im, i, lst = 0, -1, -1, ''.join(map(str,arr)).split('0')\n",
    "    for a,b in zip(lst,lst[1:]):\n",
    "        i += len(a) + 1 \n",
    "        candidate = len(a)+len(b)+1\n",
    "        if m <= candidate:\n",
    "            im, m = i, candidate\n",
    "    return im\n",
    "# https://www.codewars.com/kata/5a00a8b5ffe75f8888000080/solutions/python\n",
    "def replace_zero(arr):\n",
    "    ret = [0,0]\n",
    "    arr = [None] + arr + [None]\n",
    "    for i,e in enumerate(arr):\n",
    "        if type(arr[i])==int and not e and any((arr[i+1],arr[i-1])):\n",
    "            mx = (sm(arr[:i]) + sm(arr[i+1:][::-1]))\n",
    "            ret = [ret,[mx, i-1]][mx>=ret[0]]\n",
    "    return ret[-1]\n",
    "    \n",
    "def sm(arr, c=0):\n",
    "    i = len(arr)-1\n",
    "    while arr[i]:\n",
    "        i -=1\n",
    "        c +=1\n",
    "    return c\n",
    "\n",
    "def replace_zero(lst):\n",
    "    z = [-1] + [i for i, n in enumerate(lst) if not n] + [len(lst)]\n",
    "    return max((z[i+1]-z[i-1], z[i]) for i in range(1, len(z)-1))[1]\n",
    "\n",
    "\n",
    "import itertools\n",
    "\n",
    "def replace_zero(arr):\n",
    "    xs = list(itertools.chain.from_iterable([length if key else 0] * length\n",
    "        for key, grp in itertools.groupby(arr)\n",
    "        for _, length in [(key, sum(1 for _ in grp))]\n",
    "    ))\n",
    "    return max(\n",
    "        (0, i) if x else (1 + (xs[i-1] if i > 0 else 0) + (xs[i+1] if i < len(xs)-1 else 0), i)\n",
    "        for i, x in enumerate(xs)\n",
    "    )[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibs_fizz_buzz(n):\n",
    "    a, b, out = 0, 1, []\n",
    "\n",
    "    for i in range(n):\n",
    "        s = \"Fizz\"*(b % 3 == 0) + \"Buzz\"*(b % 5 == 0)\n",
    "        out.append(s if s else b)\n",
    "        a, b = b, a+b\n",
    "        \n",
    "    return out\n",
    "\n",
    "# https://www.codewars.com/kata/57bf599f102a39bb1e000ae5/solutions/python\n",
    "def fibs_fizz_buzz(n):\n",
    "    a, b, f = 1, 1, []\n",
    "    for _ in range(n):\n",
    "        s = \"\"\n",
    "        if not a % 3: s += \"Fizz\"\n",
    "        if not a % 5: s += \"Buzz\"\n",
    "        f.append(s or a)\n",
    "        a, b = b, a + b\n",
    "    return f\n",
    "\n",
    "from itertools import islice\n",
    "\n",
    "def fib():\n",
    "    a, b = 0, 1\n",
    "    while True:\n",
    "        a, b = b, a + b\n",
    "        yield a\n",
    "\n",
    "def fibs_fizz_buzz(n):\n",
    "    return ['Fizz' * (not i % 3) + 'Buzz' * (not i % 5) or i for i in islice(fib(), n)]\n",
    "\n",
    "\n",
    "def fibs_fizz_buzz(n):\n",
    "    fib = [1, 1]\n",
    "    while len(fib) < n:\n",
    "        fib.append(sum(fib[-2:]))\n",
    "    fib = fib[:n]\n",
    "    fib[3::4] = ['Fizz'] * (n // 4)\n",
    "    fib[4::5] = ['Buzz'] * (n // 5)\n",
    "    fib[19::20] = ['FizzBuzz'] * (n // 20)\n",
    "    return fib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "def compare_powers(n1, n2):\n",
    "    return cmp(log(n2[0])*n2[1], log(n1[0])*n1[1]) \n",
    "\n",
    "# https://www.codewars.com/kata/55b2549a781b5336c0000103/solutions/python\n",
    "def compare_powers(n1,n2):\n",
    "  from math import log\n",
    "  return -cmp(n1[1]*log(n1[0]), n2[1]*log(n2[0]))\n",
    "\n",
    "\n",
    "from math import log\n",
    "\n",
    "def compare_powers(*numbers):\n",
    "    a,b = map(lambda n: n[1]*log(n[0]), numbers)\n",
    "    return (a<b) - (a>b)\n",
    "\n",
    "\n",
    "from math import log\n",
    "\n",
    "def compare_powers((x, a), (y, b)):\n",
    "    return cmp(b*log(y), a*log(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def look_and_say_sequence(first, n):    \n",
    "    result = first\n",
    "    \n",
    "    for _ in range(n-1):\n",
    "    \n",
    "        sequence = result\n",
    "        result = ''\n",
    "        index = 0\n",
    "        \n",
    "        while index < len(sequence):\n",
    "        \n",
    "            pending = sequence[index]\n",
    "            count = 0\n",
    "            \n",
    "            while index < len(sequence) and pending == sequence[index]:\n",
    "                count += 1\n",
    "                index += 1\n",
    "            \n",
    "            result += \"{}{}\".format(count, pending)\n",
    "            \n",
    "    return result\n",
    "\n",
    "# https://www.codewars.com/kata/592421cb7312c23a990000cf/solutions/python\n",
    "from re import sub\n",
    "\n",
    "def look_and_say_sequence(s, n):\n",
    "    for _ in range(1, n):\n",
    "        s = sub(r'(.)\\1*', lambda m: str(len(m.group(0))) + m.group(1), s)\n",
    "    return s\n",
    "\n",
    "\n",
    "from itertools import groupby\n",
    "from functools import reduce\n",
    "def look_and_say_sequence(first_element, n):\n",
    "    return reduce(lambda s, _: ''.join('%d%s' % (len(list(g)), n) for n, g in groupby(s)), range(n - 1), first_element)\n",
    "\n",
    "look_and_say_sequence=l=lambda s,n:n>1and l(''.join(str(len(list(g)))+k for k,g in __import__('itertools').groupby(s)),n-1)or s\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def look_and_say_sequence(e, n):\n",
    "    for i in range(n-1):\n",
    "        e = ''.join(f'{len(list(grp))}{key}' for key, grp in groupby(e))\n",
    "    return e\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def count_me(d):\n",
    "    if any(c not in '0123456789' for c in d ): return ''\n",
    "    return ''.join(str(len(e)) + str(e[0]) for e in [list(g) for k, g in groupby(d)])\n",
    "\n",
    "def look_and_say_sequence(e, n):\n",
    "    if n==1: return e\n",
    "    return look_and_say_sequence(count_me(e), n-1)\n",
    "\n",
    "import re\n",
    "def look_and_say_sequence(element, n):\n",
    "    return element if n == 1 else look_and_say_sequence(''.join(f'{len(e.group())}{e.group(1)}' for e in re.finditer(r'(\\d)\\1*',element)), n-1)\n",
    "\n",
    "import re\n",
    "def look_and_say_sequence(data, n):\n",
    "    return data if n == 1 else look_and_say_sequence(''.join(f'{len(e.group(0))}{e.group(1)}' for e in re.finditer(r\"(\\d)\\1*\", data)), n-1)\n",
    "\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def look_and_say_sequence(seq, n):\n",
    "    if seq == \"22\":\n",
    "        return \"22\"\n",
    "    for _ in range(1, n):\n",
    "        seq = \"\".join(f\"{len(list(b))}{a}\" for a, b in groupby(seq))\n",
    "    return seq\n",
    "\n",
    "from itertools import groupby\n",
    "\n",
    "def look_and_say_sequence(first_element, n):\n",
    "    if first_element == \"22\": return \"22\"\n",
    "    for _ in range(n-1):\n",
    "        first_element = ''.join(f\"{len(list(l))}{c}\" for c,l in groupby(first_element))\n",
    "    return first_element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tiy_fizz_buzz(string):\n",
    "  r = lambda i: {i in 'euioa': \"Yard\",\n",
    "    i in 'EUIOA': \"Iron Yard\",\n",
    "    i in 'QWRTYPSDFGHJKLZXCVBNM': 'Iron',\n",
    "    not i in 'euioaEUIOAQWRTYPSDFGHJKLZXCVBNM': i}[True]\n",
    "  return ''.join([r(i) for i in string])\n",
    "\n",
    "# https://www.codewars.com/kata/5889177bf148eddd150002cc/solutions/python\n",
    "import re\n",
    "\n",
    "def ironyarder(m):\n",
    "    lst = []\n",
    "    if m[0].isupper():          lst.append('Iron')\n",
    "    if m[0].lower() in 'aeiou': lst.append('Yard')\n",
    "    return ' '.join(lst)\n",
    "\n",
    "def tiy_fizz_buzz(s):\n",
    "    return re.sub(r'[A-Zaeiou]', ironyarder, s)\n",
    "\n",
    "\n",
    "from string import ascii_uppercase as ASCII\n",
    "\n",
    "LOOKUP = {}\n",
    "for cs, val in [('aeiou', 'Yard'), ('AEIOU', 'Iron Yard'), (ASCII, 'Iron')]:\n",
    "    for c in cs:\n",
    "        LOOKUP.setdefault(c, val)\n",
    "\n",
    "\n",
    "def tiy_fizz_buzz(string):\n",
    "    return ''.join(LOOKUP.get(c, c) for c in string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fractions import gcd\n",
    "\n",
    "def sum_differences_between_products_and_LCMs(pairs):\n",
    "    return sum(a*b - a*b//gcd(a,b) for a, b in pairs if a and b)\n",
    "# https://www.codewars.com/kata/56e56756404bb1c950000992/solutions/python\n",
    "from fractions import gcd\n",
    "\n",
    "def lcm(x, y):\n",
    "    return x * y / gcd(x, y) if gcd(x, y) else 0\n",
    "    \n",
    "def sum_differences_between_products_and_LCMs(pairs):\n",
    "    return sum(x*y - lcm(x, y) for x, y in pairs)\n",
    "\n",
    "\n",
    "from fractions import gcd\n",
    "def sum_differences_between_products_and_LCMs(pairs):\n",
    "    return sum(i * j - (i * j // gcd(i, j)) for i, j in pairs if i and j)\n",
    "\n",
    "\n",
    "import fractions\n",
    "def sum_differences_between_products_and_LCMs(pairs):\n",
    "   return sum( [pair[0]*pair[1]*(1-(1.0/fractions.gcd(pair[0], pair[1]) if fractions.gcd(pair[0], pair[1])!=0 else 0)) for pair in pairs])\n",
    "\n",
    "\n",
    "gcd = lambda x,y: gcd(y,x % y) if x and x%y else y\n",
    "lcm = lambda x,y: x*y / gcd(x,y) if x*y else 0\n",
    "def sum_differences_between_products_and_LCMs(pairs):\n",
    "    return sum(x[0]*x[1] - lcm(x[0],x[1]) for x in pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def how_many_years (date1,date2):\n",
    "    y1 = int(date1.split(\"/\")[0])\n",
    "    y2 = int(date2.split(\"/\")[0])\n",
    "    return abs(y2 - y1)\n",
    "\n",
    "# https://www.codewars.com/kata/588f5a38ec641b411200005b/solutions/python\n",
    "from operator import sub\n",
    "from functools import reduce\n",
    "def how_many_years (date1,date2):\n",
    "    return abs(reduce(sub, (map(int, map(lambda x: x[:4], [date1, date2])))))\n",
    "\n",
    "\n",
    "import datetime\n",
    "\n",
    "\n",
    "def how_many_years (date1,date2):\n",
    "    date_time1 = datetime.datetime.strptime(date1, '%Y/%m/%d')\n",
    "    date_time2 = datetime.datetime.strptime(date2, '%Y/%m/%d')\n",
    "    \n",
    "    result = date_time2 - date_time1\n",
    "    \n",
    "    return int(abs(result.days / 365))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_dig = lambda n, D={str(d): d*d for d in range(10)}: sum(map(D.get, str(n)))\n",
    "is_happy = lambda n: n > 4 and is_happy(sum_dig(n)) or n == 1\n",
    "\n",
    "happy_set = set(filter(is_happy, range(100)))\n",
    "for n in range(100, 3 * 10 ** 5):\n",
    "    if sum_dig(n) in happy_set: happy_set.add(n)\n",
    "\n",
    "from bisect import bisect\n",
    "def performant_numbers(n, happy_list=sorted(happy_set)): return happy_list[:bisect(happy_list, n)]\n",
    "# https://www.codewars.com/kata/5adf5b6a2f10c6c4bc000200/solutions/python\n",
    "def is_happy(n):\n",
    "    while n > 4:\n",
    "        n = sum((d - 48)**2 for d in str(n).encode())\n",
    "    return n == 1\n",
    "\n",
    "happy = list(filter(is_happy, range(3 * 10 ** 5)))\n",
    "\n",
    "from bisect import bisect_right\n",
    "def performant_numbers(n):\n",
    "    return happy[:bisect_right(happy, n)]\n",
    "\n",
    "F = [2,4,16,37,58,89,145,42,20]\n",
    "\n",
    "from bisect import bisect\n",
    "\n",
    "def f(n):\n",
    "    for i in range(50):\n",
    "        n = sum(int(i)**2 for i in str(n))\n",
    "        if n in F:\n",
    "            return False\n",
    "        if n == 1:\n",
    "            return True\n",
    "\n",
    "H = [i for i in range(1,300000) if f(i)]\n",
    "\n",
    "def performant_numbers(n):\n",
    "    return H[:bisect(H, n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from itertools import count, islice\n",
    "\n",
    "def performant_smallest(arr, n):\n",
    "    cnts = Counter(arr)\n",
    "    total = 0\n",
    "    for i, c in sorted(cnts.items()):\n",
    "        total += c\n",
    "        if total >= n:\n",
    "            break\n",
    "    available = count(c + n - total, -1)\n",
    "    it = (x for x in arr if x < i or (x == i and next(available) > 0))\n",
    "    return list(islice(it, n))\n",
    "\n",
    "# https://www.codewars.com/kata/5aeed69804a92621a7000077/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count, permutations\n",
    "\n",
    "def next_perfectsq_perm(limit_below, k):\n",
    "    for n in count(int(limit_below**.5)+1):\n",
    "        s = str(n**2)\n",
    "        if '0' not in s:\n",
    "            sq_set = {x for x in (int(''.join(p)) for p in permutations(s)) if (x**.5).is_integer()}\n",
    "            if len(sq_set) == k:\n",
    "                return max(sq_set)\n",
    "\n",
    "# https://www.codewars.com/kata/5b2cd515553292a4ff0000c2/solutions/python            \n",
    "from itertools import permutations\n",
    "from math import sqrt\n",
    "\n",
    "def is_per(n):\n",
    "    return str(sqrt(int(n)))[-1] == '0'\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    perfect = [i**2 for i in range(2000) if '0' not in str(i**2) if i**2 > lower_limit]\n",
    "    for i in perfect: \n",
    "        if i > lower_limit:\n",
    "            num = set()\n",
    "            per = set(permutations(str(i)))\n",
    "            tem = [int(''.join(j)) for j in per if is_per(''.join(j))]\n",
    "            if len(tem) == k:\n",
    "                num.add(i)\n",
    "                ma = max(tem)\n",
    "                break\n",
    "    return max(tem)\n",
    "\n",
    "\n",
    "from itertools import permutations\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    while 1:\n",
    "        lower_limit += 1\n",
    "        if '0' not in str(lower_limit) and int(lower_limit ** 0.5 + 0.5) ** 2 == lower_limit:\n",
    "            perms = list(map(lambda x: ''.join(x), set(permutations(str(lower_limit)))))\n",
    "            perms = list(map(int, perms))\n",
    "            perfects = 0\n",
    "            perfect_list = []\n",
    "            for i in perms:\n",
    "                if int(i ** 0.5 + 0.5) ** 2 == i:\n",
    "                    perfects += 1\n",
    "                    perfect_list.append(i)\n",
    "            if perfects == k:\n",
    "                return max(perfect_list)   \n",
    "\n",
    "            \n",
    "candidates = ((sq, str(sq)) for sq in (i*i for i in range(12, 3000)))\n",
    "candidates = ((sq, s) for sq, s in candidates if '0' not in s)\n",
    "\n",
    "d = {}  # 144: [144, 441], 256: [256, 625], ...\n",
    "sqs = {}  # 144: [144, 441], 256: [256, 625], 441: [144, 441], 625: [256, 625], ...\n",
    "for sq, s in candidates:\n",
    "    sqs[sq] = d.setdefault(int(''.join(sorted(s))), [])\n",
    "    sqs[sq].append(sq)\n",
    "\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    return sqs[min(x for x in sqs if x > lower_limit and len(sqs[x]) == k)][-1]\n",
    "\n",
    "from itertools import permutations\n",
    "\n",
    "def is_perfect(square):\n",
    "    return round(square**0.5)**2 == square\n",
    "\n",
    "def permuted(n):\n",
    "    return (int(\"\".join(p)) for p in set(permutations(str(n))))\n",
    "\n",
    "def perfect_permutations(n):\n",
    "    return tuple(p for p in permuted(n) if is_perfect(p))\n",
    "    \n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    root = int(lower_limit**0.5) + 1\n",
    "    while True:\n",
    "        square = root**2\n",
    "        if not \"0\" in str(square):\n",
    "            p = perfect_permutations(square)\n",
    "            if len(p) == k:\n",
    "                return max(p)\n",
    "        root += 1\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "def solve(n, k):\n",
    "    return ''.join(min(combinations(str(n), len(str(n))-k)))\n",
    "\n",
    "\n",
    "from itertools import combinations\n",
    "\n",
    "def solve(n,k):\n",
    "    return min((''.join(c) for c in combinations(str(n), len(str(n))-k)), key=int)\n",
    "\n",
    "\n",
    "from itertools import combinations as c\n",
    "def solve(n,k):\n",
    "    b=len(str(n))-k\n",
    "    l=[''.join(i) for i in c(str(n),b)]\n",
    "    return min(l)\n",
    "\n",
    "# https://www.codewars.com/kata/59fd6d2332b8b9955200005f/solutions/python\n",
    "from itertools import combinations\n",
    "\n",
    "def solve(n, k):\n",
    "    s = str(n)\n",
    "    return ''.join(min(xs for xs in combinations(s, len(s)-k)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_dig = lambda n, D={str(d): d*d for d in range(10)}: sum(map(D.get, str(n)))\n",
    "is_happy = lambda n: n > 4 and is_happy(sum_dig(n)) or n == 1\n",
    "\n",
    "happy_set = set(filter(is_happy, range(100)))\n",
    "for n in range(100, 3 * 10 ** 5):\n",
    "    if sum_dig(n) in happy_set: happy_set.add(n)\n",
    "\n",
    "from bisect import bisect\n",
    "def performant_numbers(n, happy_list=sorted(happy_set)): return happy_list[:bisect(happy_list, n)]\n",
    "# https://www.codewars.com/kata/5adf5b6a2f10c6c4bc000200/solutions/python \n",
    "def is_happy(n):\n",
    "    while n > 4:\n",
    "        n = sum((d - 48)**2 for d in str(n).encode())\n",
    "    return n == 1\n",
    "\n",
    "happy = list(filter(is_happy, range(3 * 10 ** 5)))\n",
    "\n",
    "from bisect import bisect_right\n",
    "def performant_numbers(n):\n",
    "    return happy[:bisect_right(happy, n)]\n",
    " \n",
    "F = [2,4,16,37,58,89,145,42,20]\n",
    "\n",
    "from bisect import bisect\n",
    "\n",
    "def f(n):\n",
    "    for i in range(50):\n",
    "        n = sum(int(i)**2 for i in str(n))\n",
    "        if n in F:\n",
    "            return False\n",
    "        if n == 1:\n",
    "            return True\n",
    "\n",
    "H = [i for i in range(1,300000) if f(i)]\n",
    "\n",
    "def performant_numbers(n):\n",
    "    return H[:bisect(H, n)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "from itertools import count, islice\n",
    "\n",
    "def performant_smallest(arr, n):\n",
    "    cnts = Counter(arr)\n",
    "    total = 0\n",
    "    for i, c in sorted(cnts.items()):\n",
    "        total += c\n",
    "        if total >= n:\n",
    "            break\n",
    "    available = count(c + n - total, -1)\n",
    "    it = (x for x in arr if x < i or (x == i and next(available) > 0))\n",
    "    return list(islice(it, n))\n",
    "\n",
    "\n",
    "def performant_smallest(arr, n):\n",
    "    keys = sorted(range(len(arr)), key=arr.__getitem__)\n",
    "    return [arr[i] for i in sorted(keys[:n])]\n",
    "\n",
    "\n",
    "def performant_smallest(xs, n):\n",
    "    ys = sorted(xs)\n",
    "    del ys[n:]\n",
    "    m = ys[-1]\n",
    "    km = ys.count(m)\n",
    "    res = []\n",
    "    for x in xs:\n",
    "        if x <= m:\n",
    "            if x < m:\n",
    "                res.append(x)\n",
    "            elif km > 0:\n",
    "                res.append(x)\n",
    "                km -= 1\n",
    "    return res\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "def performant_smallest(a, n):\n",
    "    l = len(a)\n",
    "    arr = np.array([v + (i / l) for i, v in enumerate(a)])\n",
    "    ag = np.argpartition(arr, n - 1)\n",
    "    args = np.sort(ag[:n])\n",
    "    return [a[x] for x in args]\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "def performant_smallest(arr, n):\n",
    "    c=Counter(sorted(arr)[:n])\n",
    "    r=[]\n",
    "    for x in arr:\n",
    "        if c.get(x,0)>0:\n",
    "            r.append(x)\n",
    "            c[x]-=1\n",
    "    return r\n",
    "\n",
    "# https://www.codewars.com/kata/5aeed69804a92621a7000077/solutions/python\n",
    "from itertools import chain, islice\n",
    "\n",
    "def performant_smallest(a, n):\n",
    "    m = [[] for _  in range(51)]\n",
    "    for i, v in enumerate(a): m[v] += [i]\n",
    "    return [a[i] for i in sorted( islice( chain(*m), n ) )]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count, permutations\n",
    "\n",
    "def next_perfectsq_perm(limit_below, k):\n",
    "    for n in count(int(limit_below**.5)+1):\n",
    "        s = str(n**2)\n",
    "        if '0' not in s:\n",
    "            sq_set = {x for x in (int(''.join(p)) for p in permutations(s)) if (x**.5).is_integer()}\n",
    "            if len(sq_set) == k:\n",
    "                return max(sq_set)\n",
    "\n",
    "# https://www.codewars.com/kata/5b2cd515553292a4ff0000c2/solutions/python            \n",
    "from itertools import permutations\n",
    "from math import sqrt\n",
    "\n",
    "def is_per(n):\n",
    "    return str(sqrt(int(n)))[-1] == '0'\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    perfect = [i**2 for i in range(2000) if '0' not in str(i**2) if i**2 > lower_limit]\n",
    "    for i in perfect: \n",
    "        if i > lower_limit:\n",
    "            num = set()\n",
    "            per = set(permutations(str(i)))\n",
    "            tem = [int(''.join(j)) for j in per if is_per(''.join(j))]\n",
    "            if len(tem) == k:\n",
    "                num.add(i)\n",
    "                ma = max(tem)\n",
    "                break\n",
    "    return max(tem)\n",
    "\n",
    "\n",
    "from itertools import permutations\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    while 1:\n",
    "        lower_limit += 1\n",
    "        if '0' not in str(lower_limit) and int(lower_limit ** 0.5 + 0.5) ** 2 == lower_limit:\n",
    "            perms = list(map(lambda x: ''.join(x), set(permutations(str(lower_limit)))))\n",
    "            perms = list(map(int, perms))\n",
    "            perfects = 0\n",
    "            perfect_list = []\n",
    "            for i in perms:\n",
    "                if int(i ** 0.5 + 0.5) ** 2 == i:\n",
    "                    perfects += 1\n",
    "                    perfect_list.append(i)\n",
    "            if perfects == k:\n",
    "                return max(perfect_list)   \n",
    "\n",
    "            \n",
    "candidates = ((sq, str(sq)) for sq in (i*i for i in range(12, 3000)))\n",
    "candidates = ((sq, s) for sq, s in candidates if '0' not in s)\n",
    "\n",
    "d = {}  # 144: [144, 441], 256: [256, 625], ...\n",
    "sqs = {}  # 144: [144, 441], 256: [256, 625], 441: [144, 441], 625: [256, 625], ...\n",
    "for sq, s in candidates:\n",
    "    sqs[sq] = d.setdefault(int(''.join(sorted(s))), [])\n",
    "    sqs[sq].append(sq)\n",
    "\n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    return sqs[min(x for x in sqs if x > lower_limit and len(sqs[x]) == k)][-1]\n",
    "\n",
    "\n",
    "from itertools import permutations\n",
    "\n",
    "def is_perfect(square):\n",
    "    return round(square**0.5)**2 == square\n",
    "\n",
    "def permuted(n):\n",
    "    return (int(\"\".join(p)) for p in set(permutations(str(n))))\n",
    "\n",
    "def perfect_permutations(n):\n",
    "    return tuple(p for p in permuted(n) if is_perfect(p))\n",
    "    \n",
    "def next_perfectsq_perm(lower_limit, k): \n",
    "    root = int(lower_limit**0.5) + 1\n",
    "    while True:\n",
    "        square = root**2\n",
    "        if not \"0\" in str(square):\n",
    "            p = perfect_permutations(square)\n",
    "            if len(p) == k:\n",
    "                return max(p)\n",
    "        root += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict, Counter\n",
    "\n",
    "# https://www.codewars.com/kata/55f95dbb350b7b1239000030/solutions/python\n",
    "def count_sel(nums):\n",
    "    cnt = Counter(nums)\n",
    "    d = defaultdict(list)\n",
    "    total = 0\n",
    "    unique = 0\n",
    "    for k, v in cnt.iteritems():\n",
    "        d[v].append(k)\n",
    "        total += v\n",
    "        unique += 1\n",
    "    maximum = max(d)\n",
    "    return [total, unique, len(d[1]), [sorted(d[maximum]), maximum]]\n",
    "\n",
    "\n",
    "def count_sel(lst):\n",
    "    occ = lst.count(sorted(lst, key=lambda x: lst.count(x), reverse=True)[0])\n",
    "    return [len(lst), len(set(lst)), len([x for x in lst if lst.count(x) == 1]), [sorted(set(x for x in lst if lst.count(x) == occ)), occ]]\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "\n",
    "def count_sel(lst):\n",
    "    c = Counter(lst)\n",
    "    m = max(c.values())\n",
    "    return [\n",
    "        len(lst),\n",
    "        len(c),\n",
    "        sum(x == 1 for x in c.values()),\n",
    "        [sorted(k for k, v in c.items() if v == m), m,],\n",
    "    ]\n",
    "\n",
    "\n",
    "def count_sel(lst):\n",
    "    dic = {}\n",
    "    result = []\n",
    "    arr_temp = []\n",
    "    for elm in lst:\n",
    "        if elm not in dic:\n",
    "            dic[elm] = 1\n",
    "        else:\n",
    "            dic[elm] += 1\n",
    "    result.append(len(lst))\n",
    "    result.append(len(dic.keys()))\n",
    "    result.append(list(dic.values()).count(1))\n",
    "    for elm, occurrence in dic.items():\n",
    "        if occurrence == max(dic.values()):\n",
    "            arr_temp.append(elm)\n",
    "    result.append([sorted(arr_temp), max(dic.values())])\n",
    "    return result\n",
    "\n",
    "\n",
    "def count_sel(lst):\n",
    "    r = [len(lst),len(set(lst)),sum(lst.count(i)==1 for i in set(lst))]\n",
    "    rm = max(lst.count(i) for i in set(lst))\n",
    "    rv = sorted(i for i in set(lst) if lst.count(i)==rm)    \n",
    "    r.append([rv,rm])\n",
    "    return r\n",
    "\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "def count_sel(lst):\n",
    "    freq = Counter(lst)\n",
    "    return [len(lst),len(set(lst)),len([x for x in lst if lst.count(x) == 1]),[sorted(k for k,v in freq.items() if v == freq[max(freq, key=freq.get)]), freq[max(freq, key=freq.get)]]]\n",
    "\n",
    "from collections import Counter, defaultdict\n",
    "\n",
    "def count_sel(lst):\n",
    "    c    = Counter(lst)\n",
    "    freq = defaultdict(list)\n",
    "    for n,v in c.items(): freq[v].append(n)\n",
    "    maxF,fLst = max(freq.items(), default=(0,[]))\n",
    "    \n",
    "    return [len(lst),\n",
    "            len(c),\n",
    "            len(freq[1]),\n",
    "            [ sorted(fLst),\n",
    "              maxF] ]\n",
    "\n",
    "import collections\n",
    "\n",
    "def count_sel(lst):\n",
    "    counter = collections.Counter(lst)\n",
    "    mode_count = counter.most_common(1)[0][1] if lst else 0\n",
    "    return [len(lst),\n",
    "            len(counter),\n",
    "            sum(v == 1 for v in counter.values()),\n",
    "            [sorted(k for k, v in counter.items() if v == mode_count), mode_count]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import groupby\n",
    "\n",
    "\n",
    "def substring(strng):\n",
    "    return max(\n",
    "        enumerate(iter_candidates(strng, 2)),\n",
    "        key=lambda ix: (len(ix[1]), -ix[0]),\n",
    "    )[1]\n",
    "\n",
    "\n",
    "def iter_candidates(strng, n):\n",
    "    xs = []\n",
    "    seen = set()\n",
    "    for c, grp in groupby(strng):\n",
    "        if len(seen) >= n and c not in seen:\n",
    "            yield \"\".join(xs)\n",
    "            seen.discard(xs[-n][0])\n",
    "            del xs[:1-n]\n",
    "        xs.append(\"\".join(grp))\n",
    "        seen.add(c)\n",
    "    yield \"\".join(xs)\n",
    "    \n",
    "# https://www.codewars.com/kata/55bc0c54147a98798f00003e/solutions/python    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def alphabetized(s):\n",
    "    return \"\".join(sorted(filter(str.isalpha, s),key=str.lower))\n",
    "\n",
    "# https://www.codewars.com/kata/5970df092ef474680a0000c9/solutions/python\n",
    "import re\n",
    "\n",
    "def alphabetized(s):\n",
    "    return ''.join(sorted(re.sub(r'[^A-Za-z]','',s), key=str.lower))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def pick_peaks(arr):\n",
    "    slope = \"\".join(\"u\" if b > a else \"d\" if a > b else \"p\" for a, b in zip(arr, arr[1:]))\n",
    "    positions = [m.start() + 1 for m in re.finditer(r\"up*d\", slope)]\n",
    "    peaks = [arr[pos] for pos in positions]\n",
    "    return {\"pos\": positions, \"peaks\": peaks}\n",
    "\n",
    "# https://www.codewars.com/kata/5279f6fe5ab7f447890006a7/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations_with_replacement as comb\n",
    "\n",
    "# Brute force!\n",
    "def find(arr, n):\n",
    "    return sum(sum(L) == n for i in range(1, len(arr)+1) for L in comb(arr, i))\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as comb\n",
    "\n",
    "def find(lst, n):\n",
    "    return sum(1 for l in range(1, len(lst)+1) for c in comb(lst, l) if sum(c) == n)\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as c\n",
    "\n",
    "def find(arr, n):\n",
    "    return sum(\n",
    "        sum(xs) == n\n",
    "        for i in range(len(arr))\n",
    "        for xs in c(arr, i + 1)\n",
    "    )\n",
    "\n",
    "from itertools import combinations_with_replacement as c\n",
    "find=lambda a,k:sum(1for i in range(1,len(a)+1)for j in c(a,i)if sum(j)==k)\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as cr\n",
    "find=lambda a,n:sum(n==sum(c)for r in range(1,len(a)+1)for c in cr(a,r=r))\n",
    "\n",
    "\n",
    "def N(Q,S,R,L,D,C,I) :\n",
    "    if 0 < D and 0 < S :\n",
    "        for I in range(I,L) :\n",
    "            N(Q,S - Q[I],R,L,D - 1,C + (Q[I],),I)\n",
    "    elif 0 == S :\n",
    "        R.add(C)\n",
    "    return R\n",
    "\n",
    "def find (Q,S) :\n",
    "    Q = sorted(set(Q))\n",
    "    return len(N(Q,S,set(),len(Q),len(Q),(),0))\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as cwr\n",
    "def find(arr,n):\n",
    "    return sum(map(len, [[x for x in cwr(arr,i) if sum(x)==n] for i in range(1,len(arr)+1)]))\n",
    "\n",
    "\n",
    "from itertools import combinations_with_replacement as cwr\n",
    "def find(arr,n):\n",
    "    res=[[x for x in cwr(arr,i) if sum(x)==n] for i in range(1,len(arr)+1)]\n",
    "    return sum(map(len, res))\n",
    "\n",
    "\n",
    "import itertools\n",
    "def find(arr,n):\n",
    "    result = []\n",
    "    for i in range(1,len(arr)+1):\n",
    "        l = list(itertools.combinations_with_replacement(arr, i))\n",
    "        for x in l:\n",
    "            if sum(x)==n:\n",
    "                result.append(x)\n",
    "\n",
    "    return len(result)\n",
    "\n",
    "# https://www.codewars.com/kata/59f3178e3640cef6d90000d5/solutions/python\n",
    "from itertools import combinations_with_replacement\n",
    "\n",
    "def find(arr, num):\n",
    "    combinations = []\n",
    "    combs_with_repl = [list(combinations_with_replacement(arr, r)) for r in range(1, len(arr) + 1)]\n",
    "    for combination in combs_with_repl:\n",
    "        combinations.extend(combination)\n",
    "    return len(list(filter(lambda s: sum(s) == num, combinations)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "def can_jump(arr):\n",
    "    @lru_cache(maxsize=None)\n",
    "    def rec(i):\n",
    "        if i >= len(arr)-1: return i >= len(arr)\n",
    "        return any(rec(i+j) for j in range(1, arr[i]+1))\n",
    "    return rec(0)\n",
    "\n",
    "# https://www.codewars.com/kata/594fae1a0462da7beb000046/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gmpy2 import is_prime\n",
    "from math import log2, ceil\n",
    "from itertools import product\n",
    "from bisect import bisect_left, insort\n",
    "\n",
    "def create_solve(limit = 1_500_000):\n",
    "    sieve = []\n",
    "    for a, b in product(range(ceil(log2(limit))), repeat=2):\n",
    "        n = 2 ** a * 3 ** b + 1\n",
    "        if n <= limit and is_prime(n):\n",
    "            insort(sieve, n)\n",
    "            \n",
    "    def f(x, y):\n",
    "        px = bisect_left(sieve, x)\n",
    "        return bisect_left(sieve, y, px) - px\n",
    "    return f\n",
    "\n",
    "solve = create_solve()\n",
    "\n",
    "# https://www.codewars.com/kata/5a1502db46d84395ab00008a/solutions/python\n",
    "from gmpy2 import is_prime\n",
    "from bisect import bisect_left, bisect_right\n",
    "\n",
    "x, memo, MAXI = 1, [], 1500000\n",
    "while x < MAXI:\n",
    "    y = x\n",
    "    while y < MAXI:\n",
    "        if is_prime(y+1):\n",
    "            memo.append(y+1)\n",
    "        y *= 3\n",
    "    x *= 2\n",
    "memo.sort()\n",
    "'''\n",
    "[2, 3, 5, 7,\n",
    " 13, 17, 19, 37, 73, 97,\n",
    " 109, 163, 193, 257, 433, 487, 577, 769,\n",
    " 1153, 1297, 1459, 2593, 2917, 3457, 3889,\n",
    " 10369, 12289, 17497, 18433, 39367, 52489, 65537,\n",
    " 139969, 147457, 209953, 331777, 472393, 629857, 746497, 786433, 839809, 995329,\n",
    " 1179649, 1492993]\n",
    "'''\n",
    "\n",
    "def solve(x, y):\n",
    "    return bisect_right(memo, y) - bisect_left(memo, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "VOWELS = re.compile(r'[aeiuo]')\n",
    "\n",
    "def solve(s):\n",
    "    vows, cons  = sorted(VOWELS.findall(s)), sorted(VOWELS.sub('',s))\n",
    "    long, short = sorted((vows, cons), key=len, reverse = True)                                                 # preserve vowels first if length are the same\n",
    "    return 'failed' if len(long)-len(short) not in [0,1] else ''.join(a+b for a,b in zip(long, short+['']))\n",
    "\n",
    "# https://www.codewars.com/kata/59cf8bed1a68b75ffb000026/solutions/python\n",
    "from itertools import zip_longest\n",
    "\n",
    "def solve(s):\n",
    "    vow = sorted(c for c in list(s) if c in 'aeiou')\n",
    "    con = sorted(c for c in list(s) if c not in 'aeiou')\n",
    "    if abs(len(vow)-len(con)) > 1: return 'failed'\n",
    "    arr = [vow, con] if len(vow)>=len(con) else [con, vow]\n",
    "    return ''.join(''.join(p) for p in list(zip_longest(*arr, fillvalue='')))\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    vow, con = [], []\n",
    "    for c in s:\n",
    "        if c in 'aeiou':\n",
    "            vow.append(c)\n",
    "        else:\n",
    "            con.append(c)\n",
    "    \n",
    "    len_v, len_c = len(vow), len(con)\n",
    "    \n",
    "    if len_v - len_c in [0, 1]:\n",
    "        return ''.join(v+c for v, c in zip(sorted(vow), sorted(con) + ['']))\n",
    "    elif len_v - len_c == -1:\n",
    "        return ''.join(v+c for v, c in zip(sorted(con), sorted(vow) + ['']))\n",
    "    \n",
    "    return 'failed'\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    vs = sorted(c for c in s if c in 'aeiou')\n",
    "    cs = sorted(c for c in s if c not in 'aeiou')\n",
    "    vl, cl = len(vs), len(cs)\n",
    "    if abs(vl - cl) > 1:\n",
    "        return 'failed'\n",
    "    if vl == cl:\n",
    "        return ''.join(v+c for v, c in zip(vs, cs))\n",
    "    if vl > cl:\n",
    "        return vs[0] + ''.join(c+v for v, c in zip(vs[1:], cs))\n",
    "    return cs[0] + ''.join(v+c for v, c in zip(vs, cs[1:]))\n",
    "\n",
    "\n",
    "def solve(stg):\n",
    "    split = [[], []]\n",
    "    for c in sorted(stg):\n",
    "        split[0 if c in \"aeiou\" else 1].append(c)\n",
    "    a, b = sorted(split, key=len, reverse=True)\n",
    "    if len(a) - len(b) > 1:\n",
    "        return \"failed\"\n",
    "    return \"\".join(f\"{c}{d}\" for c, d in zip(a, b + [\"\"]))\n",
    "\n",
    "\n",
    "import re\n",
    "def solve(s):\n",
    "    vowels = sorted(re.findall(r'[aeiou]', s))[::-1]\n",
    "    consonant = sorted(re.findall(r'[^aeiou]', s))[::-1]\n",
    "    if abs(len(consonant) - len(vowels)) > 1: return 'failed'\n",
    "\n",
    "    out = []\n",
    "    if len(vowels) >= len(consonant):\n",
    "        while vowels and consonant:\n",
    "            out.append(vowels.pop())\n",
    "            out.append(consonant.pop())\n",
    "    \n",
    "    else:\n",
    "        while vowels and consonant:\n",
    "            out.append(consonant.pop())\n",
    "            out.append(vowels.pop())\n",
    "\n",
    "    return consonant and ''.join(out + consonant) or ''.join(out + vowels)\n",
    "\n",
    "\n",
    "from itertools import zip_longest, chain\n",
    "vowels = {'a', 'e', 'i', 'o', 'u'}\n",
    "\n",
    "def solve(s):\n",
    "    vow, con = [], []\n",
    "    for c in s: (con, vow)[c in vowels].append(c)\n",
    "    if abs(len(con) - len(vow)) > 1: return \"failed\"\n",
    "    vow.sort(); con.sort()\n",
    "    x, y = (vow, con) if len(vow) >= len(con) else (con, vow)\n",
    "    return ''.join(chain.from_iterable(zip_longest(x, y, fillvalue='')))\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    vowels = ''.join(sorted(ch for ch in s if ch in \"aeiou\")) + '_'\n",
    "    consonants = ''.join(sorted(ch for ch in s if ch not in \"aeiou\")) + '_'\n",
    "    if abs(len(vowels) - len(consonants)) > 1: \n",
    "        return 'failed'\n",
    "    if len(vowels) >= len(consonants): \n",
    "        res = ''.join(v+c for v, c in zip(vowels, consonants))\n",
    "    else: \n",
    "        res = ''.join(v+c for v, c in zip(consonants, vowels))\n",
    "    return res.strip('_')\n",
    "\n",
    "\n",
    "from itertools import zip_longest\n",
    "\n",
    "def solve(s):\n",
    "    a, b = sorted(x for x in s if x in \"aiueo\"), sorted(x for x in s if x not in \"aiueo\")\n",
    "    if len(b) > len(a): a, b = b, a\n",
    "    return \"failed\" if len(a) - len(b) > 1 else \"\".join(f\"{x}{y}\" for x, y in zip_longest(a, b, fillvalue=\"\"))\n",
    "\n",
    "\n",
    "from itertools import zip_longest\n",
    "\n",
    "def solve(s):\n",
    "    v = sorted(x for x in s if x in 'aeiou')\n",
    "    c = sorted(x for x in s if x not in 'aeiou')\n",
    "    if abs(len(v) - len(c)) > 1:\n",
    "        return 'failed'\n",
    "    if len(c) > len(v):\n",
    "        v, c = c, v\n",
    "    return ''.join(a + b for a, b in zip_longest(v, c, fillvalue=''))\n",
    "\n",
    "\n",
    "import re\n",
    "def solve(s):\n",
    "    c,v  = sorted(re.findall(r'[^aeiou]',s)), sorted(re.findall(r'[aeiou]',s))\n",
    "    m, n = (max(c,v,key=len),min(c,v,key=len)) if len(v) != len(c) else (v,c)\n",
    "    return \"\".join(sum(zip(m,n+[\"\"]),())) if abs(len(v) - len(c)) <= 1 else \"failed\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "def one_down(txt):\n",
    "    return \"Input is not a string\" if type(txt) != str else string.translate(txt,\n",
    "                                                                             string.maketrans(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\",\n",
    "                                                                                              \"ZABCDEFGHIJKLMNOPQRSTUVWXYzabcdefghijklmnopqrstuvwxy\"))\n",
    "\n",
    "\n",
    "from string import ascii_lowercase as a \n",
    "from string import ascii_uppercase as A \n",
    "import string\n",
    "def one_down(txt):\n",
    "    try:\n",
    "        return txt.translate(string.maketrans(a[1:]+a[0]+A[1:]+A[0],a+A))\n",
    "    except:\n",
    "        return \"Input is not a string\"\n",
    "\n",
    "    \n",
    "lower = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "\n",
    "def one_down(txt):\n",
    "    if not isinstance(txt, str):\n",
    "        return \"Input is not a string\"\n",
    "    shifted = lower[-1] + lower[:-1]\n",
    "    table = str.maketrans(lower + lower.upper(), shifted + shifted.upper())\n",
    "    return txt.translate(table)\n",
    "\n",
    "# https://www.codewars.com/kata/56419475931903e9d1000087/solutions/python\n",
    "from string import ascii_lowercase as al, ascii_uppercase as au, maketrans\n",
    "\n",
    "tbl = maketrans(al+au, al[-1]+al[:-1]+au[-1]+au[:-1])\n",
    "\n",
    "def one_down(txt):\n",
    "    if not isinstance(txt, str):\n",
    "        return 'Input is not a string'\n",
    "    return txt.translate(tbl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from re import findall\n",
    "\n",
    "def solve(s):\n",
    "    return max(map(len, findall(\"[aeiou]+\", s)))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def solve(s):\n",
    "    return max(len(x.group(0)) for x in re.finditer(r'[aeiou]+', s))\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    vowels = 'aeiou'\n",
    "    max_len = 0\n",
    "    tmp_len = 0\n",
    "    prev_vowel = False\n",
    "    for c in s:\n",
    "        max_len = max(max_len, tmp_len)\n",
    "        if not prev_vowel:\n",
    "            tmp_len = 0\n",
    "        if c in vowels:\n",
    "            tmp_len += 1\n",
    "        prev_vowel = c in vowels\n",
    "    return max_len\n",
    "\n",
    "\n",
    "def solve(s):\n",
    "    for x in s:\n",
    "        if x not in 'aeiou':\n",
    "            s=s.replace(x,' ')\n",
    "    s=(s.split())   \n",
    "    a=[len(x) for x in s]\n",
    "    return (max(a))\n",
    "\n",
    "\n",
    "from re import compile\n",
    "\n",
    "r = compile(\"[aeiou]+\")\n",
    "\n",
    "\n",
    "def solve(s: str):\n",
    "    return max(map(len, r.findall(s)))\n",
    "\n",
    "# https://www.codewars.com/kata/59c5f4e9d751df43cf000035/solutions/python\n",
    "def solve(s):\n",
    "    return max(len(w) for w in ''.join([' ', c][c in 'aeiou'] for c in s).split())    \n",
    "\n",
    "\n",
    "import re\n",
    "def solve(s):\n",
    "    return max(map(len, re.findall('[uoiae]+', s)))\n",
    "\n",
    "\n",
    "import re\n",
    "def solve(s):\n",
    "  return len(max(re.findall(r\"[aeiou]+\", s), key=len, default=\"\"))\n",
    "\n",
    "\n",
    "import re\n",
    "\n",
    "def solve(s):\n",
    "    return max(map(len, re.split('[^aeiou]+', s)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def pak(s):\n",
    "    return re.sub(' (?=.)',' pak ',s)\n",
    "\n",
    "# https://www.codewars.com/kata/57e92812750fcc051800004d/solutions/python\n",
    "def pak(s):\n",
    "    ss = s.split()\n",
    "    return ' pak '.join(ss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "from itertools import product\n",
    "from operator import mul\n",
    "\n",
    "def solve(arr):\n",
    "    xss = [[min(a), max(a)] for a in arr]\n",
    "    return max(reduce(mul, xs) for xs in product(*xss))\n",
    "\n",
    "# https://www.codewars.com/kata/5d0365accfd09600130a00c9/solutions/python\n",
    "from itertools import product\n",
    "from functools import reduce\n",
    "from operator  import mul\n",
    "\n",
    "def solve(A):\n",
    "    return max(map(lambda g: reduce(mul, g, 1), product(*A)))\n",
    "\n",
    "\n",
    "from functools import reduce\n",
    "def solve(arr):\n",
    "    f = lambda x, y: [i*j for i in x for j in y]\n",
    "    return max(reduce(f, arr))\n",
    "\n",
    "\n",
    "from itertools import product\n",
    "from functools import reduce\n",
    "\n",
    "def solve(arr):\n",
    "    return max(reduce(lambda m, n: m * n, prod) for prod in product(*arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import mul\n",
    "\n",
    "def max_product(lst, n):\n",
    "    lst.sort()\n",
    "    return reduce(mul, lst[-n:])\n",
    "\n",
    "\n",
    "# https://www.codewars.com/kata/5a63948acadebff56f000018/solutions/python\n",
    "\n",
    "def max_product(lst, n):\n",
    "    from functools import reduce\n",
    "    return reduce(lambda x,y: x*y, sorted(lst, reverse=True)[:n])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import mul\n",
    "\n",
    "\n",
    "def unique_digit_products(nums):\n",
    "    return len({reduce(mul, (int(a) for a in str(num))) for num in nums})\n",
    "\n",
    "# https://www.codewars.com/kata/5897d94dd07028546c00009d/solutions/python\n",
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "def unique_digit_products(a):\n",
    "    return len({reduce(mul, map(int, str(x))) for x in a})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def digit_degree(n):\n",
    "    if n < 10: return 0\n",
    "    return 1 + digit_degree(sum(map(int, str(n))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "\n",
    "def product(numbers):\n",
    "    return reduce(mul, numbers) if numbers else None\n",
    "\n",
    "def product(numbers):\n",
    "    if not numbers:\n",
    "        return None\n",
    "    prod = 1\n",
    "\n",
    "    for i in numbers:\n",
    "        prod *= i\n",
    "\n",
    "    return prod\n",
    "# https://www.codewars.com/kata/5901f361927288d961000013/solutions/python\n",
    "def product(numbers):\n",
    "    if numbers==[] or numbers==None:\n",
    "        return None\n",
    "    res=1\n",
    "    for i in numbers:\n",
    "        res*=i\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prime_string(s):\n",
    "    return (s + s).find(s, 1) == len(s)\n",
    "\n",
    "import re\n",
    "def prime_string(s):\n",
    "  return not not re.sub(r\"^(.+)\\1+$\",\"\",s)\n",
    "# https://www.codewars.com/kata/589d36bbb6c071f7c20000f7/solutions/python\n",
    "def prime_string(s):\n",
    "    return (s*2).find(s, 1) == len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count, islice\n",
    "\n",
    "def arithmetic_sequence_elements(a, r, n):\n",
    "    return ', '.join([str(x) for x in islice(count(a, r), n)])\n",
    "\n",
    "# https://www.codewars.com/kata/55caf1fd8063ddfa8e000018/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_twisted37(arr):\n",
    "    def key(x):\n",
    "        return int(str(x).translate(str.maketrans('37', '73')))\n",
    "    return sorted(arr, key=key)\n",
    "# https://www.codewars.com/kata/58068479c27998b11900056e/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "def max_product(a):\n",
    "    x = heapq.nlargest(2,a)\n",
    "    return x[0]*x[1]\n",
    "\n",
    "from heapq import nlargest\n",
    "from operator import mul\n",
    "\n",
    "def max_product(a):\n",
    "    return mul(*nlargest(2,a))\n",
    "\n",
    "# https://www.codewars.com/kata/5784c89be5553370e000061b/solutions/python\n",
    "import heapq\n",
    "\n",
    "def max_product(a):\n",
    "    first, second = heapq.nlargest(2, a)\n",
    "    return first * second\n",
    "\n",
    "\n",
    "\n",
    "import heapq\n",
    "from functools import reduce\n",
    "from operator import mul\n",
    "\n",
    "def max_product(a):\n",
    "  return reduce(mul, heapq.nlargest(2,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "def capitals_first(text):\n",
    "    cap, low = [], []\n",
    "    for w in text.split():\n",
    "        if w[0].isalpha():\n",
    "            (cap, low)[w[0].islower()].append(w)\n",
    "    return ' '.join(chain(cap, low))\n",
    "\n",
    "# https://www.codewars.com/kata/55c353487fe3cc80660001d4/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import maketrans\n",
    "\n",
    "def to_leet_speak(text):\n",
    "    return text.translate(maketrans(\"ABCEGHILOSTZ\", \"@8(36#!10$72\"))\n",
    "\n",
    "\n",
    "table = str.maketrans(\n",
    "    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',\n",
    "    '@8(D3F6#!JK1MN0PQR$7UVWXY2'\n",
    ")\n",
    "\n",
    "def to_leet_speak(text):\n",
    "    return text.translate(table)\n",
    "\n",
    "\n",
    "def to_leet_speak(s):\n",
    "    r = {\".\": \".\", \"!\": \"!\", \"?\": \"?\", \",\": \",\",\" \": \" \", \"A\":'@', \"B\":'8', \"C\":'(', \"D\":'D', \"E\":'3', \"F\":'F', \"G\":'6', \"H\":'#', \"I\":'!', \"J\":'J', \"K\":'K', \"L\":'1', \"M\":'M', \"N\":'N', \"O\":'0', \"P\":'P', \"Q\":'Q', \"R\":'R', \"S\":'$', \"T\":'7', \"U\":'U', \"V\":'V', \"W\":'W', \"X\":'X', \"Y\":'Y', \"Z\":'2'}\n",
    "    return ''.join(r[c] for c in s)\n",
    "\n",
    "\n",
    "from string import maketrans\n",
    "\n",
    "def to_leet_speak(str):\n",
    "    from_tab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "    to_tab = '@8(D3F6#!JK1MN0PQR$7UVWXY2'\n",
    "    return str.translate(maketrans(from_tab, to_tab))\n",
    "\n",
    "#https://www.codewars.com/kata/57c1ab3949324c321600013f/solutions/python\n",
    "\n",
    "\n",
    "from string import ascii_uppercase\n",
    "\n",
    "tr = str.maketrans(ascii_uppercase, '@8(D3F6#!JK1MN0PQR$7UVWXY2')\n",
    "\n",
    "def to_leet_speak(s):\n",
    "    return s.translate(tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import maketrans\n",
    "\n",
    "def ones_complement(b):\n",
    "    return b.translate(maketrans(\"10\",\"01\"))\n",
    "\n",
    "# https://www.codewars.com/kata/59b11f57f322e5da45000254/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "PATTERN = re.compile(r\"^(1+)0\\1$\")\n",
    "\n",
    "def cyclops(n):\n",
    "    return bool(re.match(PATTERN, bin(n)[2:]))\n",
    "# https://www.codewars.com/kata/56b0bc0826814364a800005a/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import ascii_lowercase\n",
    "\n",
    "pos = {x: i for i, x in enumerate(ascii_lowercase)}\n",
    "\n",
    "def alpha_seq(string):\n",
    "    return ','.join(x.upper() + x.lower() * pos[x] for x in sorted(string.lower()))\n",
    "\n",
    "# https://www.codewars.com/kata/5bd00c99dbc73908bb00057a/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "def permutation_average(n):\n",
    "    a = [int(\"\".join(x)) for x in set(permutations(str(n)))]\n",
    "    return round(float(sum(a)) / len(a))\n",
    "\n",
    "\n",
    "from math import factorial\n",
    "\n",
    "def permutation_average(n):\n",
    "    digits = map(int, str(n))\n",
    "    nd = len(digits)\n",
    "    return round(sum(digits) * factorial(nd-1) * int('1'*nd) / float(factorial(nd)))\n",
    "\n",
    "\n",
    "import itertools\n",
    "from numpy import mean\n",
    "\n",
    "def permutation_average(n):\n",
    "    i_list = [x for x in str(n)]\n",
    "    r_list = list(itertools.permutations(i_list))\n",
    "    n_list = [int(''.join(x)) for x in r_list]\n",
    "    avg = mean(n_list)\n",
    "    return round(avg,0)\n",
    "\n",
    "\n",
    "from itertools import permutations\n",
    "\n",
    "def permutation_average(n):\n",
    "  perms = [float(''.join(x)) for x in permutations(str(n))]\n",
    "  return round(sum(perms) / len(perms))\n",
    "\n",
    "\n",
    "from itertools import permutations\n",
    "from math import factorial\n",
    "\n",
    "def permutation_average(n):\n",
    "    return round(sum(int(''.join(x)) for x in permutations(str(n))) / float(factorial(len(str(n)))))\n",
    "\n",
    "# https://www.codewars.com/kata/56b18992240660a97c00000a/solutions/python\n",
    "from math import factorial\n",
    "\n",
    "\n",
    "def permutation_average(n):\n",
    "    m = len(str(n))\n",
    "    s = sum(map(int, str(n)))\n",
    "    return round(sum(s * 10 ** i for i in range(m)) / float(m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import maketrans\n",
    "\n",
    "def reverse_complement(dna):\n",
    "    if len(dna.translate(None, \"ATGC\")) > 0:\n",
    "        return \"Invalid sequence\"\n",
    "    return dna.translate(maketrans(\"ATCG\",\"TAGC\"))[::-1]\n",
    "\n",
    "\n",
    "from string import maketrans\n",
    "\n",
    "\n",
    "def reverse_complement(dna):\n",
    "    if not set('ACTG').issuperset(dna):\n",
    "        return 'Invalid sequence'\n",
    "    return dna[::-1].translate(maketrans('ACTG', 'TGAC'))\n",
    "\n",
    "# https://www.codewars.com/kata/574a7d0dca4a8a0fbe000100/solutions/python\n",
    "from string import maketrans\n",
    "\n",
    "def reverse_complement(dna):\n",
    "    return dna.translate(maketrans('AGTC', 'TCAG'))[::-1] if set(dna) <= set('AGTC') else 'Invalid sequence'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def DNA_strand(dna):\n",
    "    return dna.translate(string.maketrans('ATCG', 'TAGC'))\n",
    "\n",
    "# https://www.codewars.com/kata/554e4a2f232cdd87d9000038/solutions/python\n",
    "def DNA_strand(dna):\n",
    "  return \"\".join([{'A':'T', 'T':'A', 'C':'G', 'G':'C'}[l] for l in dna])\n",
    "\n",
    "\n",
    "import string\n",
    "\n",
    "TABLE = string.maketrans('ATCG', 'TAGC')\n",
    "\n",
    "\n",
    "def DNA_strand(dna):\n",
    "    return dna.translate(TABLE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def how_much_coffee(events):\n",
    "    number_of_coffees = sum(1 if re.fullmatch(r\"cw|dog|cat|movie\", event) else 2 if re.match(r\"CW|DOG|CAT|MOVIE\", event)else 0 for event in events)\n",
    "    return number_of_coffees if number_of_coffees<4 else \"You need extra sleep\"\n",
    "\n",
    "# https://www.codewars.com/kata/57de78848a8b8df8f10005b1/solutions/python\n",
    "def how_much_coffee(events):\n",
    "    EVENTS = (\"cat\", \"dog\", \"movie\", \"cw\")\n",
    "    cups = 0\n",
    "    for event in events:\n",
    "        if event.lower() in EVENTS:\n",
    "            if event.isupper():\n",
    "                cups += 2\n",
    "            elif event.islower():\n",
    "                cups += 1\n",
    "    if cups > 3:\n",
    "        return 'You need extra sleep'\n",
    "    return cups\n",
    "\n",
    "\n",
    "def how_much_coffee(events):\n",
    "    coffees = 0\n",
    "    for s in ['cw', 'cat', 'dog', 'movie']:\n",
    "        coffees += events.count(s)\n",
    "        coffees += 2* events.count(s.upper())\n",
    "    if coffees > 3:\n",
    "        return 'You need extra sleep'\n",
    "    return coffees\n",
    "\n",
    "\n",
    "def how_much_coffee(events):\n",
    "    score = sum(1 if event in (\"cw\", \"cat\", \"dog\", \"movie\") else 2 if event in (\"CW\", \"CAT\", \"DOG\", \"MOVIE\") else 0 for event in events)\n",
    "    return \"You need extra sleep\" if score > 3 else score\n",
    "\n",
    "import re\n",
    "def how_much_coffee(events):\n",
    "    if events:\n",
    "        a = sum([1 if re.match('^(cw|cat|dog|movie)$',i) else 0 for i in events])\n",
    "        b = sum([2 if re.match('^(CW|CAT|DOG|MOVIE)$',i) else 0 for i in events])\n",
    "        return 'You need extra sleep' if (a+b)>3 else a+b\n",
    "    return 0\n",
    "\n",
    "import re\n",
    "def how_much_coffee(events):\n",
    "    c = 0\n",
    "    for event in events:\n",
    "        m = re.match(r'^(cw|dog|cat|movie)$', event, re.I)\n",
    "        if m:\n",
    "            if event.isupper():\n",
    "                c+=2\n",
    "            else:\n",
    "                c+=1\n",
    "    if c <= 3:\n",
    "        return c\n",
    "    else:\n",
    "        return \"You need extra sleep\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import ceil\n",
    "from operator import truediv\n",
    "\n",
    "\n",
    "def how_many_times(annual_price, individual_price):\n",
    "    return int(ceil(truediv(annual_price, individual_price)))\n",
    "\n",
    "# https://www.codewars.com/kata/57efcb78e77282f4790003d8/solutions/python\n",
    "from math import ceil\n",
    "def how_many_times(ap, ip):\n",
    "    return ceil(ap/ip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "from math import gcd\n",
    "lcm = lambda x,y: x*y//gcd(x, y)\n",
    "\n",
    "# Note: there is a lcm function in numpy 1.17 but codewars uses 1.14\n",
    "def smallest(n):\n",
    "    return reduce(lcm, range(1, n+1))\n",
    "\n",
    "# https://www.codewars.com/kata/55e7d9d63bdc3caa2500007d/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_sigfigs(number):\n",
    "    if '.' in number:\n",
    "        dig, dec = number.split('.')\n",
    "        return len(dec) + len(dig.lstrip('0'))\n",
    "    return len(number.strip('0'))\n",
    "\n",
    "# https://www.codewars.com/kata/5d9fe0ace0aad7001290acb7/solutions/python\n",
    "import re\n",
    "\n",
    "def number_of_sigfigs(s):\n",
    "    return len(re.sub('^0*|'+['0*$','\\.']['.' in s], '', s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "\n",
    "def days_represented(trips):\n",
    "    return len(set(chain(*(range(a,b+1) for a,b in trips))))\n",
    "\n",
    "# https://www.codewars.com/kata/58e93b4706db4d24ee000096/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def initialize_names(name):\n",
    "    return re.sub(' (.).*?(?= )', r' \\1.', name)\n",
    "# https://www.codewars.com/kata/5822b65bb81f702016000026/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def linux_type(file_attribute):\n",
    "    file_type = {\n",
    "                    '-': 'file',\n",
    "                    'd': 'directory',\n",
    "                    'l': 'symlink',\n",
    "                    'c': 'character_file',\n",
    "                    'b': 'block_file',\n",
    "                    'p': 'pipe',\n",
    "                    's': 'socket',\n",
    "                    'D': 'door'\n",
    "                }\n",
    "    res = re.search('^.', file_attribute)\n",
    "    print(res.group(0))\n",
    "    return file_type[res.group(0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import mul\n",
    "from functools import reduce\n",
    "def factorial(n):\n",
    "    if (n < 0):\n",
    "        return None\n",
    "    return reduce(mul, range(1,n+1), 1)\n",
    "\n",
    "# https://www.codewars.com/kata/528e95af53dcdb40b5000171/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "\n",
    "names = defaultdict(lambda: 'non-smooth', {\n",
    "    2: 'power of 2',\n",
    "    3: '3-smooth',\n",
    "    5: 'Hamming number',\n",
    "    7: 'humble number',\n",
    "})\n",
    "\n",
    "\n",
    "def is_smooth(n):\n",
    "    divisors = set()\n",
    "    for d in [2, 3, 5, 7]:\n",
    "        while n % d == 0:\n",
    "            divisors.add(d)\n",
    "            n //= d\n",
    "    if n != 1:\n",
    "        divisors.add(9)\n",
    "    return names[max(divisors, default=9)]\n",
    "\n",
    "# https://www.codewars.com/kata/5b2f6ad842b27ea689000082/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "from itertools import count\n",
    "from bisect import bisect\n",
    "\n",
    "def gen():\n",
    "    D = defaultdict(list)\n",
    "    for q in count(2):\n",
    "        if q not in D:\n",
    "            yield q\n",
    "            D[q*q] = [q]\n",
    "        else:\n",
    "            for p in D[q]: D[p+q].append(p)\n",
    "            del D[q]\n",
    "primes, memo = gen(), []\n",
    "\n",
    "def generate_primes(x):\n",
    "    while not memo or memo[-1] < x: memo.append(next(primes))\n",
    "    return memo[:bisect(memo, x)]\n",
    "\n",
    "# https://www.codewars.com/kata/58fa5e33a6d84c1324000207/solutions/python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}