Feature/improve coverage maze search

algorithms/bfs/maze_search.py

@@ -27,14 +27,21 @@
 '''
 
 def maze_search(maze):
+ flags = [False for i in range(10)]
  BLOCKED, ALLOWED = 0, 1
  UNVISITED, VISITED = 0, 1
 
  initial_x, initial_y = 0, 0
 
  if maze[initial_x][initial_y] == BLOCKED:
+ flags[0] = True
+ print(flags)
+ print(len(list(filter(lambda x:(x == True) , flags))) / len(flags)) 
  return -1
 
+ else:
+ flags[1] = True 
+
  directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]
 
  height, width = len(maze), len(maze[0])
@@ -47,21 +54,59 @@ def maze_search(maze):
  is_visited[initial_x][initial_y] = VISITED
 
  while queue:
+ flags[2] = True
  x, y, steps = queue.popleft()
 
  if x == target_x and y == target_y:
+ flags[3] = True
+ print(flags)
+ print(len(list(filter(lambda x:(x == True) , flags))) / len(flags)) 
  return steps
+ else:
+ flags[4] = True
 
  for dx, dy in directions:
+ flags[5] = True
  new_x = x + dx
  new_y = y + dy
-
  if not (0 <= new_x < height and 0 <= new_y < width):
+ flags[6] = True
  continue
+ else:
+ flags[7] = True
 
  if maze[new_x][new_y] == ALLOWED and is_visited[new_x][new_y] == UNVISITED:
+ flags[8] = True
  queue.append((new_x, new_y, steps + 1))
  is_visited[new_x][new_y] = VISITED
-
+ else:
+ flags[9] = True 
+ print(len(list(filter(lambda x:(x == True) , flags))) / len(flags)) 
+ print(flags)
  return -1 
 
+
+
+if __name__ == "__main__":
+ print("Coverages for ex1")
+ ex1 = [[1,0,0],
+ [0,1,1],
+ [0,1,1]] 
+ maze_search(ex1)
+ print("Coverages for ex2")
+ ex2 = [[1,0,1,1,1,1],
+ [1,0,1,0,1,0],
+ [1,0,1,0,1,1],
+ [1,1,1,0,1,1]]
+ maze_search(ex2)
+ print("Coverages for ex3")
+ ex3 = [[0,0,0,0], [0,0,0,0],[0,0,0,0],[0,0,0,0]]
+ maze_search(ex3)
+ print("Coverages for ex4")
+ ex4 = [[0],[0],[0]]
+ maze_search(ex4)
+
+
+
+
+

algorithms/linkedlist/intersection.py

@@ -12,90 +12,118 @@
 import unittest
 
 
+
+
 class Node(object):
  def __init__(self, val=None):
  self.val = val
  self.next = None
 
 
 def intersection(h1, h2):
+ flags = [False for i in range(9)]
 
  count = 0
  flag = None
  h1_orig = h1
  h2_orig = h2
 
- while h1 or h2:
+ while h1 or h2: ## 1
+ flags[0] = True
  count += 1
 
- if not flag and (h1.next is None or h2.next is None):
+ if not flag and (h1.next is None or h2.next is None): ## 3
+ flags[1] = True
  # We hit the end of one of the lists, set a flag for this
  flag = (count, h1.next, h2.next)
 
- if h1:
+ if h1: #5
+ flags[2] = True
  h1 = h1.next
- if h2:
+ if h2: #6
+ flags[3] = True
  h2 = h2.next
 
  long_len = count # Mark the length of the longer of the two lists
  short_len = flag[0]
 
- if flag[1] is None:
+ if flag[1] is None: #7
+ flags[4] = True
  shorter = h1_orig
  longer = h2_orig
- elif flag[2] is None:
+ elif flag[2] is None: #8
+ flags[5] = True
  shorter = h2_orig
  longer = h1_orig
 
- while longer and shorter:
+ while longer and shorter: #9
+ flags[6] = True
 
- while long_len > short_len:
+ while long_len > short_len: #10
+ flags[7] = True
  # force the longer of the two lists to "catch up"
  longer = longer.next
  long_len -= 1
 
- if longer == shorter:
- # The nodes match, return the node
- return longer
- else:
+ if longer == shorter: #11
+ flags[7] = True
+
+
+ print(len(list(filter(lambda x:(x == True) , flags))) / len(flags))
+
+
+
+ return longer ##12
+ else: ## 13
+ flags[8] = True
  longer = longer.next
  shorter = shorter.next
-
+ print(flags)
+ # branch_coverage = len(flags) / len(filter(lambda x:(x == True) , flags))
+ # print(branch_coverage)
  return None
 
 
-class TestSuite(unittest.TestCase):
 
- def test_intersection(self):
 
- # create linked list as:
- # 1 -> 3 -> 5
- # \
- # 7 -> 9 -> 11
- # /
- # 2 -> 4 -> 6
- a1 = Node(1)
- b1 = Node(3)
- c1 = Node(5)
- d = Node(7)
- a2 = Node(2)
- b2 = Node(4)
- c2 = Node(6)
- e = Node(9)
- f = Node(11)
+
+
+def test_intersection():
 
- a1.next = b1
- b1.next = c1
- c1.next = d
- a2.next = b2
- b2.next = c2
- c2.next = d
- d.next = e
- e.next = f
+ # create linked list as:
+ # 1 -> 3 -> 5
+ # \
+ # 7 -> 9 -> 11
+ # /
+ # 2 -> 4 -> 6
+ a1 = Node(1)
+ b1 = Node(3)
+ c1 = Node(5)
+ d = Node(7)
+ a2 = Node(2)
+ b2 = Node(4)
+ c2 = Node(6)
+ e = Node(9)
+ f = Node(11)
 
- self.assertEqual(7, intersection(a1, a2).val)
+ a1.next = d
+ b1.next = d
+ c1.next = d
+ a2.next = d
+ b2.next = d
+ c2.next = d
+ d.next = d
+ e.next = d
+ intersection(a1, a2)
+
+
 
 
 if __name__ == '__main__':
 
- unittest.main()
+
+
+ test_intersection()
+
+
+ # unittest.main()