postfix.ipynb

{
 "metadata": {
  "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.8.10"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3810jvsc74a57bd0e8b146b0d29e47713dec59b4f63f5de9ae53685ca14c7d00a69339700df174d8",
   "display_name": "Python 3.8.10 64-bit ('venv': venv)",
   "language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import re\n",
    "\n",
    "\"\"\"\n",
    "Evaluates the prefix expression and calculates the result for the given\n",
    "variable values.\n",
    "\n",
    "@param {String} expression - the prefix expression to evaluate.\n",
    "@param {Object} variables - all the variables in the expression are the keys of\n",
    "    this object and their corresponding values are the values the variable\n",
    "    should take\n",
    "@returns {Number|null} the numerical result of the expression evaluated with the\n",
    "    given variable values. If the expression is invalid, it will return `null`.\n",
    "\n",
    "Steps:\n",
    "    - Remove any extra spaces or tabs\n",
    "    - Split by single whitespace\n",
    "    - Reverse the resultant list\n",
    "    - Initialize an empty stack to hold the values (result + operands)\n",
    "    - For each item:\n",
    "        1) if is operator, calculate the expression (using 2 top stack value) and push the result to stack\n",
    "        2) else:\n",
    "            - if it's a valid number (btwn 1 and 9), push it to stack\n",
    "            - check if is its a variable that requires replacement.\n",
    "    - If stack has only one value, return it else return null\n",
    "    \n",
    "    - Edge cases to consider:\n",
    "        - Expression values must be separated with atleast a single space\n",
    "        - Division should return the floored value\n",
    "        - Expression & variables operands must be positive and between 1-9\n",
    "        - Only *, - , + , / operators are allowed\n",
    "        - Operation must be between two operands\n",
    "\n",
    "\"\"\"\n",
    "def result_expression(expression, variables):\n",
    "    operators = ['*','-','+','/']\n",
    "    exp = re.sub(r'\\s+',' ',expression).split(' ')\n",
    "    exp.reverse()\n",
    "    stack=[]\n",
    "    for xcter in exp:\n",
    "        xcter = xcter.strip()\n",
    "        if(xcter in operators):\n",
    "            # the stack must have atleast 2 operands\n",
    "            if (len(stack)<2):\n",
    "                return None\n",
    "            o1=stack.pop()\n",
    "            o2 =stack.pop()   \n",
    "            if (xcter =='+'):\n",
    "                stack.append(o1+o2)\n",
    "            elif (xcter =='-'):\n",
    "                stack.append(o1-o2)\n",
    "            elif (xcter =='*'):\n",
    "                stack.append(o1*o2)\n",
    "            elif (xcter =='/'):\n",
    "                # division by error is not valid\n",
    "                if o2 == 0:\n",
    "                    return None\n",
    "                stack.append(math.floor(o1/o2))\n",
    "        else:\n",
    "            #check if is a valid digit (asci code between)\n",
    "            if(ord(xcter) >48 and ord(xcter) <58): \n",
    "                stack.append(int(xcter))\n",
    "            elif xcter in variables and xcter.isdigit():\n",
    "                #check if it's valid digit\n",
    "                stack.append(int(xcter))\n",
    "            else:\n",
    "                return None\n",
    "    if len(stack)==1:\n",
    "        return stack.pop()\n",
    "    return None\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert result_expression('+ 3 5', {}) == 8\n",
    "assert result_expression('/ + 3 5', {}) == None\n"
   ]
  }
 ]
}