?+???+???+??

2020/18.py

@@ -110,149 +110,184 @@ def lstToStr(lst):
 def copyList(lst):
     return [elem  for elem in lst]
 
-# def addPars(line:str):
-#     chars = strToList(line)
-#     plusCount = chars.count("+")
 
-#     seekingEnd = None
-#     parsPos = dict()
 
-#     print("#", line)
+# def addParsToSub(line:str):
-#     for i in range(len(chars)):
+#     # this function split the strings addition thing
-#         char = chars[i]
+#     # no parenthesis here
 
-#         if(char == "+"):
+#     addlines = line.split("*") # each element is an addition
-#             parsPos[i-1] = None
+#     #newline = "("
-#             seekingEnd = i-1
+#     newline = ""
 
-#         if( (char == "*" and seekingEnd != None) ):
+#     for i in range(len(addlines)):
-#             parsPos[seekingEnd] = i
+#         l = addlines[i]
-#             seekingEnd = None
+#         if( i < 1 ):
+#             newline += f"({l})*"
+#         elif( i >= 1 and i < len(addlines)-1 ):
+#             newline += f"({l})*"
+#         elif( i == len(addlines)-1 ):
+#             newline += f"({l})"
 
-#         if( seekingEnd != None and i >= len(chars) - 1 ):
+#     #newline += ")"
-#             parsPos[seekingEnd] = i+1
-#             seekingEnd = None
 
-#         if( seekingEnd != None and char == ")" ):
+#     return newline
-#             parsPos[seekingEnd] = i+1
-#             seekingEnd = None
 
-#         print(f"{i=}:{char=} {parsPos=}")
 
-#     offset = 0
+# def getLowestPar(par:dict):
-#     needEnd = 0
+#     bestdiff = None
-#     for pstart, pend in parsPos.items():
+#     bestkey = None
-#         print("#", pstart, pend)
 
-#         if(pend != None):
+#     for key, val in par.items():
-#             chars.insert(pstart+offset, "(")
+#         diff = val - key
-#             offset += 1
 
-#             chars.insert(pend+offset, ")")
+#         if( bestdiff == None ):
-#             offset += 1
+#             bestdiff = diff
-#         else:
+#             bestkey = key
-#             chars.insert(pstart+offset, 0)
+#             continue
-#             offset += 1
-#             printMath(chars)
 
-#             chars.insert(pstart+offset, "+")
+#         if( diff > bestdiff ):
-#             offset += 1
+#             bestdiff = diff
-#             printMath(chars)
+#             bestkey = key
+#             continue
 
-#             chars.insert(pstart+offset-2, "(")
+#     return bestkey
-#             offset += 1
-#             printMath(chars)
 
-#             needEnd += 1
 
-#     for i in range(needEnd):
-#         chars.append(")")
 
-#     print("RES", end=" ")
+# def addPars(line:str, usedPar=[]):
-#     printMath(chars)
+#     line = line.replace(" ", "")
+#     newline = line
+#     count = 0
 
-#     return chars
+#     # Get pars etc
+#     pars = findParens(line)
+#     chars = strToList(line)
 
-# import ast
+#     print(pars)
 
-# def recurse(node):
+#     # Get pars with lowest depth
-#     out = ""
+#     start = getLowestPar(pars)
-#     if( isinstance(node, ast.Add) ):
+#     end = pars[start]+1
 
 
-# def addPars(line:str):
+#     # Enclose addition in pars
-#     out = strToList(line)
+#     subline = lstToStr(chars[start:end])
+#     newsubline = addParsToSub(subline)
 
-#     offset = 0
+#     newline = newline.replace(subline, newsubline)
-#     parDepth = 0
+
-#     seekingClose = False
+#     # for start, end in pars.items():
+#     #     if( not start in usedPar ):
+#     #         x, y = start, end+1
+#     #         subline = lstToStr(chars[x:y])
+#     #         newsubline = addParsToSub(subline)
+
+#     #         newline.replace(subline, newsubline)
+#     #         print(f"{newsubline=}")
+
+#     print("FINAL", newline)
+#     print(subline, newsubline)
+#     print(addParsToSub(newline))
+
+# def addParsRec(line:str, usedPar=[]):
+#     line = line.replace(" ", "")
+#     newline = line
+
+#     pars = findParens(newline)
 
-#     startFound = None
-#     endFound = None
 
-#     for i in range(len(line)):
+# def addParsRec(line:str, i=0, it=None):
-#         char = line[i]
+#     it = it or line.count("(")
-#         prefix = "-----"
 
-#         if( char == "+" and not seekingClose ):
+#     if( i < it ):
-#             out.insert(i - 1 + offset, "(" )
+#         return addParsRec( addParsToSub(line), i+1, it )
-#             seekingClose = True
+#     else:
-#             startFound = i-1+offset
+#         return line
-#             offset += 1
 
 
-#             prefix = "start"
+# def addPars(chars:list):
+#     curDepth = 0
+#     addDepth = 0
 
-#         elif( char == "(" ):
+#     isSearching = False
-#             parDepth += 1
+
+#     offset = 0
+#     for i, char in enumerate(chars):
+#         if( char == "(" ):
+#             curDepth += 1
 #         elif( char == ")" ):
-#             parDepth -= 1
+#             curDepth -= 1
 
-#         elif( (char == "*") and seekingClose and parDepth == 0 ):
+#         if( char == "+" ):
-#             out.insert(i + offset, ")")
+#             before = chars[i-1+offset]
-#             offset += 1
+#             if(before == ")" or before == "("):
-#             seekingClose = False
+#                 chars.insert(i+offset, 0)
-#             endFound = i+offset
+#                 offset += 1
 
-#             prefix = "close"
+#             curDepth2 = curDepth
+#             for di, char2 in enumerate(chars[i+1:]):
 
+#                 if( char2 == "(" ):
+#                     curDepth2 += 1
+#                 elif( char2 == ")" ):
+#                     curDepth2 -= 1
 
+#                 print(f"{i=} : {di+1=} {char=} {char2=} {curDepth=}/{curDepth2=}")
 
-#         math = lstToStr(out)
+#                 if( char2 == "*" and curDepth == curDepth2 ):
-#         print(f"{prefix} {i=}:{char=} {math=} {offset=}")
+#                     chars.insert(i+offset+di, ")")
+#                     offset += 1
 
-#     return out
 
-def addParsToSub(line:str):
-    # this function split the strings addition thing
-    # no parenthesis here
 
-    addlines = line.split("*") # each element is an addition
+#         # if( char == "+" and not isSearching ):
-    newline = ""
+#         #     chars.insert(i-1+offset, "(")
+#         #     addDepth = curDepth
+#         #     isSearching = True
+#         #     offset += 1
 
-    for i in range(len(addlines)):
+#         # elif( char == "*" and curDepth == addDepth ):
-        l = addlines[i]
+#         #     chars.insert(i+offset, ")")
-        if( i < 1 ):
-            newline += f"({l})*"
-        elif( i >= 1 and i < len(addlines)-1 ):
-            newline += f"({l})*"
-        elif( i == len(addlines)-1 ):
-            newline += f"({l})"
 
-    return newline
+#     return chars
 
-    
+# addPars( strToList("2*3+(4*5)") )
-def parseMath2(line):
+
-    line = line.replace(" ", "")
+def parseMath2(line:str):
+    line =  line.replace(" ", "")
     count = 0
 
+    # calculate all pars  and replace them
+    pars = findParens(line)
+    chars = strToList(line)
+    print(chars)
+
+    for start, end in pars.items():
+        calc = calcMath(chars[start:end+1])
+
+        for j in range(start, end+1):
+            chars[j] = ""
+
+        chars[start] = str(calc)
 
 
+    print("##########3")
+    # remove bad chars
+    chars = list( filter(lambda c: c != "", chars) )
+    print(chars)
+
+
+    # calculate the rest
+    count += calcMath(chars)
+
+    return count
+
 
-problem = mathproblems[0]
+# problem = mathproblems[0]
-res = parseMath2(problem)
+# res = parseMath2(problem)
-print("\n--##########################--")
+# print("\n--##########################--")
-print( problem, "=", res )
+# print( problem, "=", res )
 
 # mathsum = 0