arithmetic_arranger.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "critical-roman",
   "metadata": {},
   "source": [
    "<h2>1. Situations that will return an error</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-holmes",
   "metadata": {},
   "source": [
    "1.1 If there are **too many problems** supplied to the function. The limit is **five**, anything more will return:\n",
    "    `Error: Too many problems.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "applied-distinction",
   "metadata": {},
   "outputs": [],
   "source": [
    "def too_many(x):\n",
    "    if len(x) > 5:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "broad-addiction",
   "metadata": {},
   "source": [
    "1.2 The appropriate operators the function will accept are **addition** and **subtraction**. Multiplication and division will return an error. Other operators not mentioned in this bullet point will not need to be tested. The error returned will be:\n",
    "    `Error: Operator must be '+' or '-'.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "objective-trouble",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bad_operators(x):\n",
    "    flag = 0\n",
    "    for problem in x:\n",
    "        if problem.find(\"*\") > -1 or problem.find(\"/\") > -1:\n",
    "            flag += 1\n",
    "            break\n",
    "    \n",
    "    if flag > 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "agricultural-infrastructure",
   "metadata": {},
   "source": [
    "1.3 Each number (operand) should only contain digits. Otherwise, the function will return:\n",
    "    `Error: Numbers must only contain digits.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "floppy-penalty",
   "metadata": {},
   "outputs": [],
   "source": [
    "def any_non_num(x):\n",
    "    flag = 0\n",
    "    for problem in x:\n",
    "        if problem.find(\"+\") > -1:\n",
    "            y = problem.split(\"+\")\n",
    "            \n",
    "        elif problem.find(\"-\") > -1:\n",
    "            y = problem.split(\"-\")\n",
    "            \n",
    "        try:\n",
    "            y[0] = int(y[0])\n",
    "            y[1] = int(y[1])\n",
    "        except:\n",
    "            flag +=1\n",
    "            break\n",
    "    \n",
    "    if flag > 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pressing-grave",
   "metadata": {},
   "source": [
    "1.4 Each operand (aka number on each side of the operator) has a max of four digits in width. Otherwise, the error string returned will be:\n",
    "    `Error: Numbers cannot be more than four digits.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "constitutional-paragraph",
   "metadata": {},
   "outputs": [],
   "source": [
    "def five_digit_plus(x):\n",
    "    for problem in x:\n",
    "        if problem.find(\"+\") > -1:\n",
    "            y =  problem.replace(\" \", \"\").split(\"+\")\n",
    "        elif problem.find(\"-\") > -1:\n",
    "            y = problem.replace(\" \", \"\").split(\"-\")\n",
    "        \n",
    "        if len(y[0]) > 4 or len(y[1]) > 4:\n",
    "            return True\n",
    "            break\n",
    "        else: \n",
    "            return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tired-phoenix",
   "metadata": {},
   "source": [
    "2.0 If the user supplied the correct format of problems, the conversion you return will follow these rules:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charming-floor",
   "metadata": {},
   "source": [
    "2.1 There should be a single space between the operator and the longest of the two operands, the operator will be on the same line as the second operand, both operands will be in the same order as provided (the first will be the top one and the second will be the bottom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "moving-taste",
   "metadata": {},
   "outputs": [],
   "source": [
    "def arrange_problems(x, compute = False):\n",
    "    \n",
    "    txt_combine = []\n",
    "    \n",
    "    for i, problem in enumerate(x):\n",
    "        if problem.find(\"+\") > -1:\n",
    "            x[i] =  problem.replace(\" \", \"\").split(\"+\")\n",
    "            x[i].insert(1, '+')\n",
    "            \n",
    "            if compute:\n",
    "                res = int(x[i][0]) + int(x[i][2])\n",
    "                \n",
    "        elif problem.find(\"-\") > -1:\n",
    "            x[i] =  problem.replace(\" \", \"\").split(\"-\")\n",
    "            x[i].insert(1, '-')\n",
    "            \n",
    "            if compute:\n",
    "                res = int(x[i][0]) - int(x[i][2])\n",
    "\n",
    "        \n",
    "        if x[i].index(max(x[i], key=len)) == 0:\n",
    "            l1 = len(x[i][0])\n",
    "            l2 = 1 + l1 - len(x[i][2])\n",
    "            r_s = ' ' * 4\n",
    "            \n",
    "            temp_list = []\n",
    "            temp_list.append(' ' * 2 + x[i][0] + r_s)\n",
    "            temp_list.append(x[i][1] + ' ' * l2 + x[i][2] + r_s)\n",
    "            temp_list.append('-'*(l1+2) + r_s)\n",
    "            \n",
    "            if compute:\n",
    "                l3 = len(temp_list[0]) - len(r_s) - len(str(res))\n",
    "                temp_list.append(' ' * l3 + str(res) + r_s)\n",
    "            \n",
    "            txt_combine.append(temp_list)\n",
    "            \n",
    "        else:\n",
    "            l1 = len(x[i][2])\n",
    "            l2 = 2 + l1 - len(x[i][0])\n",
    "            r_s = ' ' * 4\n",
    "            \n",
    "            temp_list = []\n",
    "            temp_list.append(' ' * l2 + x[i][0] + r_s)\n",
    "            temp_list.append(x[i][1] + ' ' + x[i][2] + r_s)\n",
    "            temp_list.append('-'*(l1+2) + r_s)\n",
    "            \n",
    "            if compute:\n",
    "                l3 = len(temp_list[0]) -len(r_s) - len(str(res))\n",
    "                temp_list.append(' ' * l3 + str(res) + r_s)\n",
    "            \n",
    "            txt_combine.append(temp_list)\n",
    "    \n",
    "\n",
    "    resultant=\"\"\n",
    "    for i in range(len(txt_combine[0])):\n",
    "        for j in range(len(txt_combine)):\n",
    "            resultant = \"\".join((resultant, txt_combine[j][i]))\n",
    "\n",
    "        resultant = resultant.rstrip(' ')\n",
    "        if i != len(txt_combine[0])-1:\n",
    "            resultant = \"\".join((resultant,\"\\n\"))\n",
    "    \n",
    "    return resultant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "allied-japanese",
   "metadata": {},
   "outputs": [],
   "source": [
    "def arithmetic_arranger(problems, compute = False):\n",
    "    \n",
    "    # Check length\n",
    "    if too_many(problems):\n",
    "        arranged_problems = \"Error: Too many problems.\"\n",
    "        \n",
    "    # Check for incorrect operators\n",
    "    elif bad_operators(problems):\n",
    "        arranged_problems = \"Error: Operator must be '+' or '-'.\"\n",
    "        \n",
    "    # Check if only numbers\n",
    "    elif any_non_num(problems):\n",
    "        arranged_problems = \"Error: Numbers must only contain digits.\"\n",
    "    \n",
    "    # Check if more than 4 digits\n",
    "    elif five_digit_plus(problems):\n",
    "        arranged_problems = \"Error: Numbers cannot be more than four digits.\"\n",
    "        \n",
    "    # No issues found\n",
    "    else:\n",
    "        if compute:\n",
    "            arranged_problems = arrange_problems(problems, compute)\n",
    "        else:\n",
    "            arranged_problems = arrange_problems(problems)\n",
    "    \n",
    "    return arranged_problems"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lightweight-kennedy",
   "metadata": {},
   "source": [
    "Test Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "veterinary-flashing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  11      3801      1      123         1\\n+  4    - 2999    + 2    +  49    - 9380\\n----    ------    ---    -----    ------'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Correct Input\n",
    "# print(arithmetic_arranger([\"32 + 698\", \"3801 - 2\", \"45 + 43\", \"123 + 49\"]))\n",
    "\n",
    "# Too many problems\n",
    "# print(arithmetic_arranger([\"32 + 698\", \"3801 - 2\", \"45 + 43\", \"123 + 49\", \"100 + 20\"]))\n",
    "\n",
    "# Appropriate operators\n",
    "# print(arithmetic_arranger([\"32 + 698\", \"3801 - 2\", \"45 + 43\", \"123 * 49\"]))\n",
    "\n",
    "# Only digits\n",
    "# print(arithmetic_arranger([\"32.1 + 698\", \"3801 - 2\", \"45 + 43\", \"123 + 49\"]))\n",
    "\n",
    "# No more than four digits\n",
    "# print(arithmetic_arranger([\"32.1 + 698\", \"3801 - 2\", \"45 + 43\", \"123 + 49\"]))\n",
    "\n",
    "# No more than four digits\n",
    "# print(arithmetic_arranger([\"32012 + 6988\", \"3801 - 2\", \"45 + 43\", \"123 + 49\"]))\n",
    "\n",
    "arithmetic_arranger([\"11 + 4\", \"3801 - 2999\", \"1 + 2\", \"123 + 49\", \"1 - 9380\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "consistent-poultry",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}