fixed the bug in validate.py

Author: dalyndalton

.gitignore

@@ -0,0 +1 @@
+__pycache__

program6/6grade.ps1

@@ -1,27 +1,18 @@
 # SPECIAL GRADER FOR PROGRAM 6 ONLY
-[CmdletBinding()]
-param (
-    [Parameter(Mandatory=$true, Position=0)]
-    [System.IO.File] $in
-
-    [Parameter(Position=1)]
-)
-
 
 $in = $args[0]
-$inputFile = $args[1]
 
 # Compile and run with test input found in .\input.txt
 $exe = ".\" + (Get-Item $in).BaseName + ".exe"
 
 # Only Error's and Warning during compile time are displayed.
-cl $in 1> $null 4> $null 5> $null 6> $null 
+cl $in /nologo 1> $null 4> $null 5> $null 6> $null 
 
-$exe | python validate.py
+& $exe | python -m validate
 Start-Sleep -s 1
-$exe | python validate.py
+& $exe | python -m validate
 Start-Sleep -s 1
-$exe | python validate.py
+& $exe | python -m validate
 
 # Character limit break
 $data = Get-Content $in

program6/__init__.py

@@ -1,81 +1,120 @@
-from operator import ne
+""" 
+Oversimplified version of a path walker for grading the assignment
+
+TODO:
+ - Implement a recursive algorithm instead of a while true to seach all possible paths instead.
+"""
 import sys
-from time import sleep
-from typing import List, Set, Tuple
+import copy
+from typing import List, Tuple
+
+
+class bcolors:
+    HEADER = "\033[95m"
+    OKBLUE = "\033[94m"
+    OKCYAN = "\033[96m"
+    OKGREEN = "\033[92m"
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
 
 
-def fail(x: int, y: int, current: str, grid):
+def fail(x: int, y: int, current: str, grid, used):
     print(f"Board is invalid, see position [{x},{y}], should be {current}")
-    for line in grid:
-        print(line)
+    for x, line in enumerate(grid):
+        for y, ele in enumerate(line):
+            if used[x][y]:
+                print(bcolors.OKGREEN + f"{ele} ", end="")
+            else:
+                print(bcolors.WARNING + f"{ele} ", end="")
+        print(bcolors.ENDC)
 
 
 def sucess():
-    print("Board is valid")
+    print(bcolors.BOLD + bcolors.OKGREEN + "Board is valid" + bcolors.ENDC)
 
 
 # returns them in [up, right, left, down]
 def getneighbor(x: int, y: int, grid: List[List[str]]):
     neighbors = [0] * 4
-    neighbors[0] = grid[x - 1][y] if (x - 1) >= 0 else "#"
+    neighbors[0] = grid[x - 1][y] if x - 1 >= 0 else "#"
     neighbors[1] = grid[x][y + 1] if y + 1 < 10 else "#"
     neighbors[2] = grid[x][y - 1] if y - 1 >= 0 else "#"
     neighbors[3] = grid[x + 1][y] if x + 1 < 10 else "#"
     return neighbors
 
 
-grid: List[List[str]] = []
-
-# Grab board from stdin
-for line in sys.stdin:
-    grid.append(line.split())
-
+def move(direction: int, x: int, y: int) -> Tuple[int, int]:
+    if direction == 0:
+        x = x - 1
+    elif direction == 1:
+        y = y + 1
+    elif direction == 2:
+        y = y - 1
+    elif direction == 3:
+        x = x + 1
+    return (x, y)
 
-# Check to see if A starts in top right
-used: Set[Tuple[int, int]] = set()
-current: str = "A"
-x: int = 0
-y: int = 0
 
-while True:
+def check(current, grid, used, x, y):
     # Check whether letter is correct
     if current != grid[x][y]:
-        fail(x, y, current)
-        break
+        print("manually review the board, possible mixed paths")
+        fail(x, y, current, grid, used)
+        return False
 
     # Log position to prevent loops
-    used.add((x, y))
+    used[x][y] = True
+
     # Increment current
     current = chr(ord(current) + 1)
     if ord(current) > ord("Z"):
         current = "A"
+
     # Get neighbors
     neighbors = getneighbor(x, y, grid)
 
     # Check if the next element exists in the neighbors
     if current not in neighbors:
         # if the next element isn't found, check for empty neighbors
         if "." in neighbors:
-            fail(x, y, current, grid)
-            break
+            fail(x, y, current, grid, used)
+            return False
         else:
             # check to see if all have been visited
-            if (x - 1, y) in used or x - 1 < 0:
-                if (x, y + 1) in used or y + 1 >= 10:
-                    if (x, y - 1) in used or y - 1 < 0:
-                        if (x + 1, y) in used or x + 1 >= 10:
-                            sucess()
-                            break
-            fail(x, y, current, grid)
-            break
+            bounds = getneighbor(x, y, used)
+            if any([not x for x in bounds]):
+                fail(x, y, current, grid, used)
+                return False
+            return True
 
-    direction = neighbors.index(current)
+    for idx, dir in enumerate(neighbors):
+        if dir == current:
+            nx, ny = move(idx, x, y)
+            if not used[nx][ny]:  # If we've reached a new spot
+                if check(current, grid, copy.deepcopy(used), nx, ny):
+                    return True
+    return False
 
-    if direction == 0:
-        x = x - 1
-    elif direction == 1:
-        y = y + 1
-    elif direction == 2:
-        y = y - 1
+
+grid: List[List[str]] = []
+# Check to see if A starts in top right
+used: List[List[bool]] = [[False for _ in range(10)] for _ in range(10)]
+current: str = "A"
+x: int = 0
+y: int = 0
+
+# Grab board from stdin
+for line in sys.stdin:
+    grid.append(line.split())
+
+try:
+    if check(current, grid, used, x, y):
+        sucess()
     else:
-        x = x + 1
+        print("program failed, terminating...")
+except KeyboardInterrupt:
+    for line in grid:
+        print(line)