please provide the rectified version of my code in python for the above stated methods in task 7 and 8 can someone help me out by modifying my code based on the changes required and please ensure that all the test cases meet the expected output. Please make sure that the updated code would pass all the test cases giving the appropriate output. Please don't provide a sample code or something similar I have wasted most of my questions by getting them please modify my code to get the expected this is a code for a game of go in python. the exercise description and expected output of the test cases will be provided below the code. please modify the code and provide the modified version without errors as I have tried as much as i can but i keep on messing it up I have developed the following code shown below ______________________ from collections import deque def load_board(filename): result = " " with open(filename) as f: print(f) for index, line in enumerate(f): if index == 0: result += ' '+' '.join([chr(alphabets + 65) for alphabets in range(len(line) - 1)]) + ' ' # the alphabetical column heading result += f"{19 - index:2d}" result += ' ' + ' '.join(line.strip()) + ' ' return result

def save_board(filename, board): with open(filename, "wt") as f: f.write(str(board)) from string import ascii_uppercase as letters class Board: #Dictionary created for the colours and the respected symbols points = {'E': '.', 'B': '@', 'W': 'O'}

#Constructor def __init__(self,board,size=19,from_strings=None): assert 2

def get_size(self): #Returns the size of the grid created by the constructor return self.size

def __str__(self): # creating the grid padding = ' ' # Creating a variable with a space assigned so that it acts as a padding to the rows that have a single digit heading = ' ' + ' '.join(letters[:self.size]) # Alphabetical heading is created lines = [heading] # adding the alphabetical heading into a list named lines to which the rows will be added later for r, row in enumerate(self.grid): if len(self.grid) 9: # for rows 1 to 9 the single digits are aligned according to the first digit from the right of the two digit rows if (self.from_strings): line = f'{self.size - r} ' + ' '.join(self.from_strings[r]) else: line = f'{self.size - r} ' + ' '.join(self.points[x] for x in row) line = padding + line # adding the space using the variable padding to the row created lines.append(line) # adding the row to the list of rows else: # for the rows 10 onwards - as there is no requirement to add a padding it is not added here if (self.from_strings): line = f'{self.size - r} ' + ' '.join(self.from_strings[r]) else: line = f'{self.size - r} ' + ' '.join(self.points[x] for x in row) # creation of the row lines.append(line) # adding the newly created row to the list of rows return ' '.join(lines)

def _to_row_and_column(self, coords): # destructure coordinates like "B2" to "B" and 2 alpha, num = coords colnum = ord(alpha) - ord('A') + 1 rownum = self.size - int(num) + 1 assert 1

def set_colour(self, coords, colour_name): rownum, colnum = self._to_row_and_column(coords) assert len(coords)==2 or len(coords)==3, "invalid coordinates" assert colour_name in self.points,"invalid colour name" self.grid[rownum - 1][colnum - 1] = colour_name

def get_colour(self, coords): rownum, colnum = self._to_row_and_column(coords) return self.grid[rownum - 1][colnum - 1]

def to_strings(self): #padding = ' ' lines = [] for r, row in enumerate(self.grid): if self.from_strings: lines.append(''.join(self.from_strings[r])) else: lines.append(''.join(self.points[x] for x in row)) return lines

def to_integer(self): digit_colour="" for line in self.to_strings(): for character in line: if character=='.': character=0 elif character=='O': character=1 elif character=='@': character=2 character=str(character) digit_colour+=character return int(digit_colour,3)

# return ''.join(self.to_int[x] for line in self.grid for x in line)

def set_from_integer(self, integer_encoding): n = int(integer_encoding) list1 = [] p=[] m=[] t=[] while n != 0: rem = n % self.size #3 list1.append(rem) n = n // self.size#3 list1.reverse() list1=["." if item ==0 else item for item in list1] list1=["O" if item ==1 else item for item in list1] list1=["@" if item ==2 else item for item in list1] for i in range(0,len(list1),self.size):#3 p.append(list1[i:i+self.size])#3 #print(p) for x in p: m=''.join(map(str,x)) t.append(m) #print(Board(self.size,t)) self.from_strings=t

def fill_reaching(self,colour_name,reach_name, visited, r, c): new_list = [] new_list2 = [] for x in self.from_strings: for y in x: if y == ".": y = "E" elif y == "@": y = "B" elif y == "O": y = "W" new_list.append(y) for i in range(0, len(new_list), self.size): new_list2.append(new_list[i:i + self.size]) self.grid = new_list2 if r = self.size or c = self.size: #Checking whether the number of rows are within the size of the grid return False if visited[r][c] or self.grid[r][c] != colour_name:#Checking whether the number of columns are within the size of the grid return False if self.grid[r][c] == reach_name: return True visited[r][c] = True if self.fill_reaching(colour_name, reach_name, visited, r + 1, c): return True if self.fill_reaching(colour_name, reach_name, visited, r - 1, c): return True if self.fill_reaching(colour_name, reach_name, visited, r, c + 1): return True if self.fill_reaching(colour_name, reach_name, visited, r, c - 1): return True return False

def reaching_empty_matrix(self): # Create a matrix of the same size as the board, filled with False values matrix = [[False for i in range(self.size)] for j in range(self.size)] #false for the empty grid # Iterate over the points on the board print(self.grid[1][0]) for i in range(self.size): for j in range(self.size): # If the current point is empty or an "O" point, perform a BFS from this point if self.grid[i][j] == "." or self.grid[i][j] == "O": queue = deque([(i, j)]) matrix[i][j] = True while queue: r, c = queue.popleft() for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)): new_r = r + dr new_c = c + dc # If the new point is within the bounds of the board and has not been visited, add it to the queue and mark it as visited if 0

def is_legal(self): # Iterate over the points on the board for i in range(self.size): for j in range(self.size): # Skip empty points if self.board[i][j] == ".": continue # Check the surrounding points for any illegal positions for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)): new_r = i + dr new_c = j + dc # If the new point is out of bounds or empty, or if it has a different color than the current point, the position is illegal if not (0

----------Test cases----------- #Task 7 b = Board(3, ["O.O", ".@.", "@O."]) print(b.reaching_empty_matrix()) b = Board(3, ["O@O", ".O.", "@O."]) print(b.reaching_empty_matrix()) l19 = load_board("l19.txt") print(l19) e = l19.reaching_empty_matrix() for r in range(len(e)): for c in range(len(e[r])): if not e[r][c]: print((r, c))

#Task 8 l19 = load_board("l19.txt") print(l19) print(l19.is_legal()) l19.set_colour("E19", "E") print(l19.is_legal()) l19.set_colour("M9", "B") print(l19.is_legal()) print(l19)

l19.txt is shown below

---------- expected output -----------------

In the Board class, define a method reaching_empty_matrix(self) that returns a matrix (list of lists) of Booleans of the same size as the board. An element of this matrix is True if the corresponding point on the board is either empty or reaches empty and False otherwise. The method must not modify the board. Task 8 In the Board class, define a method is_legal(self) that returns True if the position on the board is legal and False otherwise (see Background Information for the definition of a legal position). he rules of the game 1. Go is played on a 1919 square grid of points, by two players called Black and White. 2. Each point on the grid may be coloured black, white or empty. 3. A point P, not coloured C, is said to reach C, if there is a path of (vertically or horizontally) adjacent points of P s colour from P to a point of colour C. 4. Clearing a colour is the process of emptying all points of that colour that don't reach empty. 5. Starting with an empty grid, the players alternate turns, starting with Black. 6. A turn is either a pass; or a move that doesn't repeat an earlier grid colouring. 7. A move consists of colouring an empty point one's own colour; then clearing the opponent colour, and then clearing one's own colour. 8. The game ends after two consecutive passes. 9. A player's score is the number of points of their colour, plus the number of empty points that reach only their colour. 10. The player with the higher score at the end of the game is the winner. Equal scores result in a tie. A legal position is a position in which every point coloured black or white reaches empty. The example above is not a legal position because there are points coloured white that don't reach empty. (Can you see how we had to fiddle with the image because Go software wouldn't let us create an illegal position ;-)?) It is a consequence of the rules that every valid move creates a legal position. This is because according to rule \#7, both colours are cleared, removing any stones that don't reach empty. Fun fact: the total number of legal positions on a 1919 Go board is about 2.0816810170. The exact number was computed by John Trump in 2016. 119.txt go.py Task 7 [[True, True, True], [True, True, True], [True, True, True] ] [[True, False, True], [True, True, True], [True, True, True] ] A BCDEFGHIJKLMNOPQRS 17@0..@0.00000.00000 @0 150. @. @. 0 @.000 @ @0...00 @0 8@@0@.0000.1@.00@.0 @@@.. @ 6@.0.00@@0.00.0@@..0.0. 500 @@. .00 @@. @.. @.00 @@0 0. 3 @00@.0.@@.0 @.@@0@0.. (1,4) (10,12) False False True ABCDEFGHIJKMNOPQRS 19.... @.@.00...@.0000.0 0 16..@@.00.@@...0@0..@.0 @