feat(Watchtower): Simplification

# |<----  Using a Maximum Of 50 Characters  ---->|

# Explain why this change is being made
# |<----   Try To Limit Each Line to a Maximum Of 72 Characters   ---->|

# Provide links or keys to any relevant tickets, articles or other resources
# Example: Github issue #23

# --- COMMIT END ---
# Type can be
#    feat     (new feature)
#    fix      (bug fix)
#    refactor (refactoring production code)
#    style    (formatting, missing semi colons, etc; no code change)
#    docs     (changes to documentation)
#    test     (adding or refactoring tests; no production code change)
#    chore    (updating grunt tasks etc; no production code change)
# --------------------
# Remember to
#    Capitalize the subject line
#    Use the imperative mood in the subject line
#    Do not end the subject line with a period
#    Separate subject from body with a blank line
#    Use the body to explain what and why vs. how
#    Can use multiple lines with "-" for bullet points in body
# --------------------
# For more information about this template, check out
# https://gist.github.com/adeekshith/cd4c95a064977cdc6c50

Author: KenMercusLai

checkio/Watchtower/Simplification/simplification.py

@@ -0,0 +1,154 @@
+import functools
+import operator
+import re
+
+
+class Polynomial:
+    def __init__(self, val):
+        if isinstance(val, list):
+            self.plist = val
+
+    def __add__(self, other):
+        if len(self.plist) > len(other.plist):
+            new = [i for i in self.plist]
+            for i in range(len(other.plist)):
+                new[i] += other.plist[i]
+        else:
+            new = [i for i in other.plist]
+            for i in range(len(self.plist)):
+                new[i] += self.plist[i]
+        return Polynomial(new)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        return self.__add__(other.__neg__())
+
+    def __rsub__(self, other):
+        return -Polynomial.__sub__(other)
+
+    def __mul__(self, other):
+        result = []
+        for i in range(len(other.plist)):
+            result.append(
+                Polynomial([0] * i + [j * other.plist[i] for j in self.plist])
+            )
+        return functools.reduce(operator.add, result)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __neg__(self):
+        return Polynomial([-1]) * self
+
+    def __repr__(self):
+        result = []
+        for i in range(len(self.plist)):
+            if i == 0:
+                result.insert(0, str(self.plist[i]))
+            else:
+                if self.plist[i] == 0:
+                    continue
+                else:
+                    if self.plist[i] == 1:
+                        base_str = 'x'
+                    else:
+                        base_str = str(self.plist[i]) + '*x'
+                    if i == 1:
+                        result.insert(0, base_str)
+                    else:
+                        result.insert(0, base_str + '**' + str(i))
+        for i in range(1, len(result)):
+            if result[i][0] != '-':
+                result[i] = '+' + result[i]
+        for i in range(len(result)):
+            if result[i][0] == '-':
+                if result[i][1] == '1' and '*' in result[i] and result[i][2] == '*':
+                    result[i] = result[i][0] + result[i][3:]
+
+        if result[-1] == '+0' and len(result) > 1:
+            result.pop()
+        return ''.join(result)
+
+
+def tokenise(expr):
+    symbols = list(expr)
+    # merge numbers
+    changed = True
+    while changed:
+        changed = False
+        for i in range(len(symbols) - 1):
+            try:
+                int(symbols[i])
+                int(symbols[i + 1])
+                symbols = symbols[:i] + [symbols[i] + symbols[i + 1]] + symbols[i + 2 :]
+                changed = True
+                break
+            except ValueError:
+                pass
+
+    # convert numbers and x
+    for i in range(len(symbols)):
+        try:
+            int(symbols[i])
+            symbols[i] = Polynomial([int(symbols[i])])
+        except ValueError:
+            if symbols[i] == 'x':
+                symbols[i] = Polynomial([0, 1])
+    return symbols
+
+
+def calc(tokens):
+    while len(tokens) > 1:
+        if ')' in tokens:
+            right_bracket = tokens.index(')')
+            sub_tokens = tokens[:right_bracket]
+            sub_tokens.reverse()
+            left_bracket = len(sub_tokens) - sub_tokens.index('(') - 1
+            tokens = (
+                tokens[:left_bracket]
+                + calc(tokens[left_bracket + 1 : right_bracket])
+                + tokens[right_bracket + 1 :]
+            )
+        elif '*' in tokens:
+            index = tokens.index('*')
+            tokens = (
+                tokens[: index - 1]
+                + [tokens[index - 1] * tokens[index + 1]]
+                + tokens[index + 2 :]
+            )
+        elif '-' in tokens:
+            index = tokens.index('-')
+            tokens = (
+                tokens[: index - 1]
+                + [tokens[index - 1] - tokens[index + 1]]
+                + tokens[index + 2 :]
+            )
+        else:
+            index = tokens.index('+')
+            tokens = (
+                tokens[: index - 1]
+                + [tokens[index - 1] + tokens[index + 1]]
+                + tokens[index + 2 :]
+            )
+    return tokens
+
+
+def simplify(expr):
+    tokens = tokenise(expr)
+    result = calc(tokens)[0]
+    return str(result)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # These "asserts" using only for self-checking and not necessary for
+    # auto-testing
+    assert simplify("(x-1)*(x+1)") == "x**2-1", "First and simple"
+    assert simplify("(x+1)*(x+1)") == "x**2+2*x+1", "Almost the same"
+    assert simplify("(x+3)*x*2-x*x") == "x**2+6*x", "Different operations"
+    assert simplify("x+x*x+x*x*x") == "x**3+x**2+x", "Don't forget about order"
+    assert simplify("(2*x+3)*2-x+x*x*x*x") == "x**4+3*x+6", "All together"
+    assert simplify("x*x-(x-1)*(x+1)-1") == "0", "Zero"
+    assert simplify("5-5-x") == "-x", "Negative C1"
+    assert simplify("x*x*x-x*x*x-1") == "-1", "Negative C0"

checkio/Watchtower/Simplification/test_simplification.py

@@ -0,0 +1,77 @@
+import unittest
+
+from simplification import simplify
+
+
+class Tests(unittest.TestCase):
+    TESTS = {
+        "Basics": [
+            {"input": "(x-1)*(x+1)", "answer": "x**2-1"},
+            {"input": "(x+1)*(x+1)", "answer": "x**2+2*x+1"},
+            {"input": "(x+3)*x*2-x*x", "answer": "x**2+6*x"},
+            {"input": "x+x*x+x*x*x", "answer": "x**3+x**2+x"},
+            {"input": "(2*x+3)*2-x+x*x*x*x", "answer": "x**4+3*x+6"},
+            {"input": "x*x-(x-1)*(x+1)-1", "answer": "0"},
+            {"input": "5-5-x", "answer": "-x"},
+            {"input": "x*x*x-x*x*x-1", "answer": "-1"},
+        ],
+        "Extra": [
+            {"input": "(x-1)*(x-1)", "answer": "x**2-2*x+1"},
+            {"input": "(x+3)*(x+3)", "answer": "x**2+6*x+9"},
+            {"input": "(x+4)*x*3-x*x", "answer": "2*x**2+12*x"},
+            {"input": "x+x*x+x*x*x*x", "answer": "x**4+x**2+x"},
+            {"input": "2*(2*x+3)-x+x*x*x*x", "answer": "x**4+3*x+6"},
+            {"input": "3+4*x-24-2*x", "answer": "2*x-21"},
+            {"input": "(x+1)*x*(x+1)", "answer": "x**3+2*x**2+x"},
+            {"input": "x*x*x*x*x+100-2", "answer": "x**5+98"},
+            {"input": "(x-500)*(x+500)", "answer": "x**2-250000"},
+            {"input": "(x-2)*(x+2)*(x+2)", "answer": "x**3+2*x**2-4*x-8"},
+        ],
+        "Generated": [
+            {
+                "input": "84-x+x*37*80+78-98+x-(x)+(23)*x+x-x+x+78-(x*32+61+x-10*x*x)-(59*x)-(x)-x*49+x+23*72+0+(x+x)+(x*(x))",
+                "answer": "11*x**2+2844*x+1737",
+            },
+            {
+                "input": "74-x-15+x+31*x+95*(x+88)*38-x-25-23+x*x+49+x-(47+x+28-43*x-x-39+x-x-83*62)",
+                "answer": "x**2+3684*x+322850",
+            },
+            {
+                "input": "(x+13-(x*x*x)*x-(x)-x+19-x*10*(x*62)+x-x*0*(66)*83-93+x-(21*x+(85-77+x-x)))",
+                "answer": "-x**4-620*x**2-20*x-69",
+            },
+            {
+                "input": "79+15*7-x+x-x+48-65+x-38+x+46*x*x*(3)+0+(45)",
+                "answer": "138*x**2+x+174",
+            },
+            {
+                "input": "98*85*x*(x-x-(x*(x-41-(x)+3-31+(41)*54*13-x+(x))))",
+                "answer": "-239179290*x**2",
+            },
+            {
+                "input": "24*45*(23*42+73-x)-x-75-13-41*(47-49*(x*25*(x*(x-(x-48*16+55*97)+x-54))))",
+                "answer": "50225*x**3-232089725*x**2-1081*x+1120105",
+            },
+            {
+                "input": "x+x-x+x*x+x*x*x-x*x*x*(4*x+84*x*x-x*x*x-x-x)+x-x-x",
+                "answer": "x**6-84*x**5-2*x**4+x**3+x**2",
+            },
+            {"input": "72*x*x-(x+x-x*x)+x*81", "answer": "73*x**2+79*x"},
+            {
+                "input": "11+(x)*(x*x)*x*(x+x*20-(15)*x-(40+(x)-(x*x*x+x+x)*x+47-(x)))",
+                "answer": "x**8+2*x**6+6*x**5-87*x**4+11",
+            },
+        ],
+    }
+
+    def test_Basics(self):
+        for i in self.TESTS['Basics']:
+            assert simplify(i['input']) == i['answer']
+
+    def test_Extra(self):
+        for i in self.TESTS['Extra']:
+            assert simplify(i['input']) == i['answer']
+
+    def test_Generated(self):
+        for i in self.TESTS['Generated']:
+            assert simplify(i['input']) == i['answer']