Simplifying multilinear polynomials 2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Most Clever Answers on Codewars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# My Working Progress and Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+3xy+y-2x+2xy'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#This is gonna be a long one.\n",
    "\n",
    "#Check if the first character is a sign:\n",
    "Input = '3xy+y-2x+2xy'\n",
    "if Input[0] !='-':\n",
    "    Input = '+'+Input\n",
    "Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['+', '3', 'x', 'y', '+', 'y', '-', '2', 'x', '+', '2', 'x', 'y']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = list(Input)\n",
    "L\n",
    "len(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['']\n",
      "2\n",
      "3\n",
      "4\n",
      "['', '+3xy']\n",
      "2\n",
      "['', '+3xy', '+y']\n",
      "2\n",
      "3\n",
      "['', '+3xy', '+y', '-2x']\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['+3xy', '+y', '-2x', '+2xy']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Put each monomial in a list as an element\n",
    "Temp, e = [], ''\n",
    "for i in L:\n",
    "    if i != '+' and i != '-':\n",
    "        e += i\n",
    "        print(len(e))\n",
    "    else:\n",
    "        Temp.append(e)\n",
    "        print(Temp)\n",
    "        e = ''\n",
    "        e += i\n",
    "#The last one will be left out\n",
    "Temp.append(e)\n",
    "Temp.pop(0)\n",
    "Temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['+3xy', '+1y', '-2x', '+2xy']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Watch out for the format for list comprehension with if else\n",
    "SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "SortAndGiveOne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['xy', 'y', 'x', 'xy']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['+3', '+1', '-2', '+2']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Try to get letters from each element of the list\n",
    "Letter = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "Letter \n",
    "Coe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xy'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'+2'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['xy', 'y', 'x']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['5', '+1', '-2']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Try to merge the monopolials\n",
    "Play1 = Letter[:]\n",
    "Play2 = Coe[:]\n",
    "for i in range(len(Play1) - 1):\n",
    "    for j in range(i+1, len(Play1)):\n",
    "        if Play1[i] == Play1[j]:\n",
    "            Play1.pop(j)\n",
    "            Play2[i] = str(int(Play2[i]) + int(Play2[j]))\n",
    "            Play2.pop(j)\n",
    "Play1\n",
    "Play2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['+5xy', '+1y', '-2x']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Put the new lists together\n",
    "Put_t = list(map(lambda x,y : y + x, Play1, Play2))\n",
    "# Add the plus sign \n",
    "FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "FinalSign"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['+1y', '-2x', '+5xy']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Try sort the elements based on length of the letters part\n",
    "FS_sort1 = sorted(FinalSign, key = lambda s: (len(''.join(filter(str.isalpha, s)))))\n",
    "FS_sort1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['-2x', '+1y', '+5xy']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Try to sort the elements with two methods altogether.\n",
    "FS_sort2 = sorted(FinalSign, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "FS_sort2\n",
    "#Apparently this shall be how I sort in the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Putting together as a function\n",
    "def simplify(poly):\n",
    "    \n",
    "    #If the first coefficient is positive, then I add a + for calculation later on\n",
    "    if poly[0] !='-':\n",
    "        poly = '+'+poly\n",
    "    L = list(poly)\n",
    "    \n",
    "    #Put each monomial in a list as an element\n",
    "    Temp, e = [], ''\n",
    "    for i in L:\n",
    "        if i != '+' and i != '-':\n",
    "            e += i\n",
    "        else:\n",
    "            Temp.append(e)\n",
    "            e = ''\n",
    "            e += i\n",
    "            \n",
    "    #The last one will be left out and the first one will be None\n",
    "    Temp.append(e)\n",
    "    Temp.pop(0)\n",
    "    \n",
    "    #If the monomial only has a + or - in front of it, then give it a '1' so it's easier for calculation\n",
    "    SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "    \n",
    "    #Try to get letters from each element of the list\n",
    "    Var = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "    #Try to get coefficients from each element of the list\n",
    "    Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "    \n",
    "    #Calculation of equivalent monomials\n",
    "    newvar = []\n",
    "    newcoe = []\n",
    "    for va, co in zip(Var, Coe):\n",
    "        try:\n",
    "            ind = newvar.index(va)\n",
    "            newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "        except ValueError:\n",
    "            newvar.append(va)\n",
    "            newcoe.append(co)\n",
    "\n",
    "    # Put the new lists together\n",
    "    Put_t = list(map(lambda x,y : y + x, Play1, Play2))\n",
    "    # Add the plus sign \n",
    "    FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "    \n",
    "    #Sort the list based on length and then lexi order\n",
    "    FS_sort = sorted(FinalSign, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "    return FS_sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Putting together as a function\n",
    "def simplify(poly):\n",
    "    \n",
    "    #If the first coefficient is positive, then I add a + for calculation later on\n",
    "    if poly[0] !='-':\n",
    "        poly = '+'+poly\n",
    "    L = list(poly)\n",
    "    \n",
    "    #Put each monomial in a list as an element\n",
    "    Temp, e = [], ''\n",
    "    for i in L:\n",
    "        if i != '+' and i != '-':\n",
    "            e += i\n",
    "        else:\n",
    "            Temp.append(e)\n",
    "            e = ''\n",
    "            e += i\n",
    "            \n",
    "    #The last one will be left out and the first one will be None\n",
    "    Temp.append(e)\n",
    "    Temp.pop(0)\n",
    "    \n",
    "    #If the monomial only has a + or - in front of it, then give it a '1' so it's easier for calculation\n",
    "    SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "    \n",
    "    #Try to get letters from each element of the list\n",
    "    Var = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "    #Try to get coefficients from each element of the list\n",
    "    Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "    \n",
    "    #Calculation of equivalent monomials\n",
    "    newvar = []\n",
    "    newcoe = []\n",
    "    for va, co in zip(Var, Coe):\n",
    "        try:\n",
    "            ind = newvar.index(va)\n",
    "            newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "        except ValueError:\n",
    "            newvar.append(va)\n",
    "            newcoe.append(co)\n",
    "\n",
    "    # Put the new lists together\n",
    "    Put_t = list(map(lambda x,y : y + x, newvar, newcoe))\n",
    "    \n",
    "    # Add the plus sign as it will be gone if there was calculation involved.\n",
    "    FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "    \n",
    "    #Delete the elements with 0 as coefficient\n",
    "    Delete0 = [e for e in FinalSign if not e[1]=='0']\n",
    "    \n",
    "    #Sort the list based on length and then lexi order\n",
    "    FS_sort = sorted(Delete0, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "    return Put_t, FS_sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Add the code to change the coefficient of -1 and +1\n",
    "def simplify(poly):\n",
    "    \n",
    "    #If the first coefficient is positive, then I add a + for calculation later on\n",
    "    if poly[0] !='-':\n",
    "        poly = '+'+poly\n",
    "    L = list(poly)\n",
    "    \n",
    "    #Put each monomial in a list as an element\n",
    "    Temp, e = [], ''\n",
    "    for i in L:\n",
    "        if i != '+' and i != '-':\n",
    "            e += i\n",
    "        else:\n",
    "            Temp.append(e)\n",
    "            e = ''\n",
    "            e += i\n",
    "            \n",
    "    #The last one will be left out and the first one will be None\n",
    "    Temp.append(e)\n",
    "    Temp.pop(0)\n",
    "    \n",
    "    #If the monomial only has a + or - in front of it, then give it a '1' so it's easier for calculation\n",
    "    SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "    \n",
    "    #Try to get letters from each element of the list\n",
    "    Var = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "    #Try to get coefficients from each element of the list\n",
    "    Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "    \n",
    "    #Calculation of equivalent monomials\n",
    "    newvar = []\n",
    "    newcoe = []\n",
    "    for va, co in zip(Var, Coe):\n",
    "        try:\n",
    "            ind = newvar.index(va)\n",
    "            newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "        except ValueError:\n",
    "            newvar.append(va)\n",
    "            newcoe.append(co)\n",
    "\n",
    "    # Put the new lists together\n",
    "    Put_t = list(map(lambda x,y : y + x, newvar, newcoe))\n",
    "    \n",
    "    # Add the plus sign as it will be gone if there was calculation involved.\n",
    "    FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "    \n",
    "    #Delete the elements with 0 as coefficient\n",
    "    Delete0 = [e for e in FinalSign if not e[1]=='0']\n",
    "    \n",
    "    #Change the +1 and -1 coefficients to + and - \n",
    "    Change1 = [(e[0]+e[2:]) if (e[1]== '1' and e[2].isalpha() ) else e for e in Delete0 ]\n",
    "    \n",
    "    #Sort the list based on length and then lexi order\n",
    "    FS_sort = sorted(Change1, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "    \n",
    "    #Join together as a list\n",
    "    JT = ''.join(FS_sort)\n",
    "    \n",
    "    #Delete leading plus sign\n",
    "    if JT[0] == '+':\n",
    "        JT = JT[1:]\n",
    "        \n",
    "    return JT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Trying to fix the index out of range problem\n",
    "#The problem is that some input will \n",
    "def simplify(poly):\n",
    "    \n",
    "    #If the first coefficient is positive, then I add a + for calculation later on\n",
    "    if poly[0] !='-' and poly[0] != '+':\n",
    "        poly = '+'+poly\n",
    "    L = list(poly)\n",
    "    \n",
    "    #Put each monomial in a list as an element\n",
    "    Temp, e = [], ''\n",
    "    for i in L:\n",
    "        if i != '+' and i != '-':\n",
    "            e += i\n",
    "        else:\n",
    "            Temp.append(e)\n",
    "            e = ''\n",
    "            e += i\n",
    "            \n",
    "    #The last one will be left out and the first one will be None\n",
    "    Temp.append(e)\n",
    "    Temp.pop(0)\n",
    "    print(Temp)\n",
    "    #If the monomial only has a + or - in front of it, then give it a '1' so it's easier for calculation\n",
    "    SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "    \n",
    "    #Try to get letters from each element of the list\n",
    "    Var = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "    #Try to get coefficients from each element of the list\n",
    "    Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "    \n",
    "    #Calculation of equivalent monomials\n",
    "    newvar = []\n",
    "    newcoe = []\n",
    "    for va, co in zip(Var, Coe):\n",
    "        try:\n",
    "            ind = newvar.index(va)\n",
    "            newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "        except ValueError:\n",
    "            newvar.append(va)\n",
    "            newcoe.append(co)\n",
    "\n",
    "    # Put the new lists together\n",
    "    Put_t = list(map(lambda x,y : y + x, newvar, newcoe))\n",
    "    \n",
    "    # Add the plus sign as it will be gone if there was calculation involved.\n",
    "    FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "    \n",
    "    #Delete the elements with 0 as coefficient\n",
    "    Delete0 = [e for e in FinalSign if not e[1]=='0']\n",
    "    \n",
    "    #Change the +1 and -1 coefficients to + and - \n",
    "    Change1 = [(e[0]+e[2:]) if (e[1]== '1' and e[2].isalpha() ) else e for e in Delete0 ]\n",
    "    \n",
    "    #Sort the list based on length and then lexi order\n",
    "    FS_sort = sorted(Change1, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "    \n",
    "    #Join together as a list\n",
    "    JT = ''.join(FS_sort)\n",
    "    \n",
    "    #Delete leading plus sign\n",
    "    if JT[0] == '+':\n",
    "        JT = JT[1:]\n",
    "        \n",
    "    return JT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['+n', '-5hn', '+7tjhn', '-4nh', '-3n', '-6hnjt', '+2jhn', '+9hn']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'-2n+2hjn+hjnt'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(\"n-5hn+7tjhn-4nh-3n-6hnjt+2jhn+9hn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['-c', '+5ab', '+12x']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#How shall I change the -1 and +1 coefficient?\n",
    "\n",
    "Test2 = ['-1c', '+5ab', '+12x']\n",
    "\n",
    "[(e[0]+e[2:]) if (e[1]== '1' and e[2].isalpha() ) else e for e in Test2 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play1 = '-1xy'\n",
    "play1[2].isalpha() and play1[1] == '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['+2xy', '-yx']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'xy'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['-a', '+5ab', '+3a', '-c', '-2a']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'-c+5ab'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['+dc', '+dcba']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'cd+abcd'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['+3xy', '+y', '-2x', '+2xy']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'-2x+y+5xy'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(\"2xy-yx\")\n",
    "simplify(\"-a+5ab+3a-c-2a\")\n",
    "simplify(\"dc+dcba\")\n",
    "simplify(\"3xy+y-2x+2xy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '1', '5']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Fix the coefficient\n",
    "\n",
    "Test1 = ['+0a', '-1c', '+5ab']\n",
    "T1C = [''.join(i for i in e if i.isdigit()) for e in Test1 ]\n",
    "T1C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['-1c', '+5ab']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['-1c', '+5ab']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Delete the ones with 0 as coefficient\n",
    "T2C = [e for e in Test1 if not e[1]=='0']\n",
    "T2C\n",
    "def FilterF(x):\n",
    "    if ''.join([e for e in x if e.isdigit()]) == '0':\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "list(filter(FilterF, Test1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[e for e in '12abc' if e.isdigit()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['-1a', '+3a', '-2a', '-1c', '+5ab']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(\"-a+5ab+3a-c-2a\")\n",
    "# I may have found out where I'm wrong, I shall not delete elements while iterating through it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'ab', 'c']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['0', '+5', '-1']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Help I got from Stack Overflow\n",
    "\n",
    "Play1 = ['a', 'ab', 'a', 'c', 'a']\n",
    "Play2 = ['-1', '+5', '+3', '-1', '-2']\n",
    "Var = Play1[:]\n",
    "Coe = Play2[:]\n",
    "newVar = []\n",
    "newCoe = []\n",
    "\n",
    "for va, co in zip(Var, Coe):\n",
    "\n",
    "    # try/except (EAFP) is very Pythonic\n",
    "    try:\n",
    "        # See if this var is seen\n",
    "        ind = newVar.index(va)\n",
    "\n",
    "        # Yeah, seen, let's add the coefficient\n",
    "        newCoe[ind] = str(int(newCoe[ind]) + int(co))\n",
    "\n",
    "    except ValueError:\n",
    "        # No it's not seen, add both to the new lists\n",
    "        newVar.append(va)\n",
    "        newCoe.append(co)\n",
    "newVar\n",
    "newCoe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "'a' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-8221df2c02a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mnewCoe\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mind\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnewVar\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: 'a' is not in list"
     ]
    }
   ],
   "source": [
    "#Dissect and see why it works\n",
    "newVar = []\n",
    "newCoe = []\n",
    "\n",
    "ind = newVar.index('a')\n",
    "#This is an amazing answer, let me see if I can write it by myself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', '-1'), ('ab', '+5'), ('a', '+3'), ('c', '-1'), ('a', '-2')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(Var, Coe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0a', '+5ab', '-1c']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x,y: y+x, newVar, newCoe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'ab', 'c']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "['0', '+5', '-1']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Play1 = ['a', 'ab', 'a', 'c', 'a']\n",
    "Play2 = ['-1', '+5', '+3', '-1', '-2']\n",
    "Var = Play1[:]\n",
    "Coe = Play2[:]\n",
    "\n",
    "newvar = []\n",
    "newcoe = []\n",
    "for va, co in zip(Var, Coe):\n",
    "    try:\n",
    "        ind = newvar.index(va)\n",
    "        newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "    except ValueError:\n",
    "        newvar.append(va)\n",
    "        newcoe.append(co)\n",
    "newvar\n",
    "newcoe           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for va, co in zip(Var, Coe):\n",
    "\n",
    "    try:\n",
    "        ind = newVar.index(va)\n",
    "        newCoe[ind] = str(int(newCoe[ind]) + int(co))\n",
    "\n",
    "    except ValueError:\n",
    "        newVar.append(va)\n",
    "        newCoe.append(co)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'newvar' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-40-c5cb47b8b112>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m         \u001b[0mind\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnewvar\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mva\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         \u001b[0mnewcoe\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mind\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnewcoe\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mind\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mco\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'newvar' is not defined"
     ]
    }
   ],
   "source": [
    "for va, co in zip(Var, Coe):\n",
    "    \n",
    "    try:\n",
    "        ind = newvar.index(va)\n",
    "        newcoe[ind] = str(int(newcoe[ind]) + int(co))\n",
    "    except ValueError:\n",
    "        newVar.append(va)\n",
    "        newCoe.append(co)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['a', 'ab', 'c'], [0, 5, -1])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "Play1 = ['a', 'ab', 'a', 'c', 'a']\n",
    "Play2 = ['-1', '+5', '+3', '-1', '-2']\n",
    "Var = Play1[:]\n",
    "Coe = Play2[:]\n",
    "\n",
    "polynom = defaultdict(int)\n",
    "for var, coeff in zip(Var, Coe):\n",
    "    polynom[var] += int(coeff)\n",
    "\n",
    "Var, Coe = list(polynom.keys()), list(polynom.values())\n",
    "Var, Coe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Testing\n",
    "def simplify(poly):\n",
    "    \n",
    "    #If the first coefficient is positive, then I add a + for calculation later on\n",
    "    if poly[0] !='-':\n",
    "        poly = '+'+poly\n",
    "    L = list(poly)\n",
    "    \n",
    "    #Put each monomial in a list as an element\n",
    "    Temp, e = [], ''\n",
    "    for i in L:\n",
    "        if i != '+' and i != '-':\n",
    "            e += i\n",
    "        else:\n",
    "            Temp.append(e)\n",
    "            e = ''\n",
    "            e += i\n",
    "            \n",
    "    #The last one will be left out and the first one will be None\n",
    "    Temp.append(e)\n",
    "    Temp.pop(0)\n",
    "    \n",
    "    #If the monomial only has a + or - in front of it, then give it a '1' so it's easier for calculation\n",
    "    SortAndGiveOne = [''.join(e[0] + '1' + e[1:]) if not e[1].isdigit() else e for e in Temp]\n",
    "    \n",
    "    #Try to get letters from each element of the list\n",
    "    Letter = [''.join(sorted(i for i in e if i.isalpha())) for e in SortAndGiveOne]\n",
    "    #Try to get coefficients from each element of the list\n",
    "    Coe = [''.join(i for i in e if not i.isalpha()) for e in SortAndGiveOne]\n",
    "    \n",
    "    #Calculation of equivalent monomials\n",
    "    Play1 = Letter[:]\n",
    "    Play2 = Coe[:]\n",
    "    print(Play1, Play2)\n",
    "    for i in range(len(Play1) - 1):\n",
    "        for j in range(i+1, len(Play1)):\n",
    "            if Play1[i] == Play1[j]:\n",
    "                Play1.pop(j)\n",
    "                Play2[i] = str(int(Play2[i]) + int(Play2[j]))\n",
    "                Play2.pop(j)\n",
    "                \n",
    "    # Put the new lists together\n",
    "    Put_t = list(map(lambda x,y : y + x, Play1, Play2))\n",
    "    # Add the plus sign \n",
    "    FinalSign = ['+'+ e if e[0] != '+' and e[0] != '-' else e for e in Put_t]\n",
    "    \n",
    "    #Sort the list based on length and then lexi order\n",
    "    FS_sort = sorted(FinalSign, key = lambda s: (len(''.join(filter(str.isalpha, s))), (''.join(filter(str.isalpha, s)))))\n",
    "    return FS_sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Play1 = ['a', 'ab', 'a', 'c', 'a']\n",
    "Play2 = ['-1', '+5', '+3', '-1', '-2']\n",
    "list(range(len(Play1) - 1))\n",
    "list(range(4, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "''.join(filter(str.isalpha, '+5xy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Play1 = Letter[:]\n",
    "Play2 = Coe[:]\n",
    "list(map(lambda x,y : x + y, Play1, Play2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ZipTry = list(zip(Play2, Play1))\n",
    "ZipTry\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i = 1\n",
    "while not (i%2 == 1 and i%3 == 0 and i%4 == 1 and i%5 == 1 and i%6 == 3 and i%7 == 0 and i%8 == 1 and i% 9 == 0):\n",
    "    i += 1\n",
    "i\n",
    "441%7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "int('-1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "''.join(sorted('+25xzy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Temp.append('5')\n",
    "Temp"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}