<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
    ['^', 'S', '^', '*', '*', '^', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '*', '^', '*', '^'],
    ['^', '*', '*', '*', '*', '*', '*', '*', '^'],
    ['^', '*', '^', '*', '*', '*', '^', '*', '^'],
    ['^', '*', '*', '*', '^', '*', '*', '*', '^'],
    ['^', '^', '*', '^', '*', '^', '*', '^', '^'],
    ['^', '^', '*', '*', '^', '^', '^', 'H', '^'],
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
]
```

Information about the problem:
1. "S": agent
2. "H": goal
3. "^": wall
4. "*": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]
```

The rewards are:
1. "H": 1
 [/INST]
import numpy as np

maze=[
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
    ['^', 'S', '^', '*', '*', '^', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '*', '^', '*', '^'],
    ['^', '*', '*', '*', '*', '*', '*', '*', '^'],
    ['^', '*', '^', '*', '*', '*', '^', '*', '^'],
    ['^', '*', '*', '*', '^', '*', '*', '*', '^'],
    ['^', '^', '*', '^', '*', '^', '*', '^', '^'],
    ['^', '^', '*', '*', '^', '^', '^', 'H', '^'],
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'H':
                    V[i][j] = 3
                    continue
                if maze[i][j] == '^':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', 'O', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', 'O', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
    ['@', 'T', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '@', '.', '@', '.', '.', '@', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '@', '.', '.', '.', '.', '.', '@', '@'],
    ['@', '@', '.', '.', '@', '.', '@', '.', '@', '.', '.', '@'],
    ['@', '.', '@', '.', '@', '.', '@', '@', '.', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'],
    ['@', '.', '.', '.', '@', '.', '@', '.', '.', '.', 'O', '@'],
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
]
```

Information about the problem:
1. "T": agent
2. "O": goal
3. "@": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "O": 1
 [/INST]
import numpy as np

maze=[
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
    ['@', 'T', '.', '.', '@', '.', '.', '.', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '.', '.', '.', '.', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '@', '.', '@', '.', '.', '@', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'],
    ['@', '@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '@', '.', '.', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '@', '.', '.', '.', '.', '.', '@', '@'],
    ['@', '@', '.', '.', '@', '.', '@', '.', '@', '.', '.', '@'],
    ['@', '.', '@', '.', '@', '.', '@', '@', '.', '.', '.', '@'],
    ['@', '.', '.', '.', '.', '@', '.', '.', '@', '.', '.', '@'],
    ['@', '.', '.', '.', '@', '.', '@', '.', '.', '.', 'O', '@'],
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'O':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '@':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', '*', '*', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', '*', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
]
```

Information about the problem:
1. "E": agent
2. "T": goal
3. "*": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "T": 1
 [/INST]
import numpy as np

maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', '*', '*', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', '*', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'T':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '*':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', '*', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'],
    ['*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', '*', '*', '*', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
]
```

Information about the problem:
1. "E": agent
2. "T": goal
3. "*": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "T": 1
 [/INST]
import numpy as np

maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', ' ', ' ', ' ', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', '*', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', '*', '*'],
    ['*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', '*', '*', '*', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'T':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '*':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', '*', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', '*', '*', ' ', '*', '*'],
    ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', '*', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]
```

Information about the problem:
1. "E": agent
2. "T": goal
3. "*": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "T": 1
 [/INST]
import numpy as np

maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', '*', '*', '*', '*', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', '*', '*', ' ', '*', '*'],
    ['*', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', '*', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'T':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '*':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
    ['@', 'T', '.', '@', '.', '.', '.', '.', '.', '.', '@', '@', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'],
    ['@', '@', '.', '@', '@', '.', '.', '@', '.', '@', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@', '.', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '.', '@', '@'],
    ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '.', '@', '.', '@'],
    ['@', '.', '@', '@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@', '.', 'O', '@'],
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
]
```

Information about the problem:
1. "T": agent
2. "O": goal
3. "@": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "O": 1
 [/INST]
import numpy as np

maze=[
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
    ['@', 'T', '.', '@', '.', '.', '.', '.', '.', '.', '@', '@', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@'],
    ['@', '@', '.', '@', '@', '.', '.', '@', '.', '@', '.', '.', '.', '@'],
    ['@', '.', '.', '@', '.', '.', '@', '.', '.', '.', '.', '@', '.', '@'],
    ['@', '@', '.', '.', '.', '.', '@', '.', '@', '.', '.', '.', '@', '@'],
    ['@', '.', '.', '.', '@', '.', '.', '@', '.', '.', '.', '@', '.', '@'],
    ['@', '.', '@', '@', '.', '.', '.', '.', '.', '.', '.', '@', '.', '@'],
    ['@', '.', '.', '.', '.', '.', '@', '.', '.', '.', '@', '.', 'O', '@'],
    ['@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@', '@'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '@'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'O':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '@':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]
```

Information about the problem:
1. "E": agent
2. "T": goal
3. "*": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "T": 1
 [/INST]
import numpy as np

maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*', '*', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', '*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', '*', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'T':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '*':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', 'O', 'O', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', 'O', 'O', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', 'O', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', '.', '.', '.', 'O', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '-', '~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '~', '~', '-', '-', '-', '~', '-', '-', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '~', '-', '-', '~'],
    ['~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '~', '-', '-', '~', '-', '-', '-', '~', '~'],
    ['~', '~', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "D": agent
2. "C": goal
3. "~": wall
4. "-": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "C": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '-', '~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '~', '~', '-', '-', '-', '~', '-', '-', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '~', '-', '-', '~'],
    ['~', '~', '-', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '~', '-', '-', '~', '-', '-', '-', '~', '~'],
    ['~', '~', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'C':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "L": agent
2. "B": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "B": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', 'O', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'B':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', '.', 'O', '.', '.', 'O', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O', 'O', '.', 'O'],
    ['O', '.', '.', 'O', 'O', 'O', '.', 'O', '.', '.', 'O', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', '~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', '~', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "P": agent
2. "X": goal
3. "~": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "X": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', '~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', '~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', '~', ' ', ' ', ' ', ' ', '~', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'X':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
    ['|', 'N', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'],
    ['|', '_', '_', '|', '|', '_', '_', '_', '|', '_', '_', '|'],
    ['|', '_', '_', '_', '_', '|', '_', '|', '_', '_', '|', '|'],
    ['|', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|'],
    ['|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '_', '_', '|', '_', '_', '_', '_', '|', '|', '_', '|'],
    ['|', '|', '_', '|', '_', '_', '_', '_', '|', '_', '_', '|'],
    ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', '_', '|'],
    ['|', '_', '_', '|', '_', '_', '_', '_', '_', '_', 'S', '|'],
    ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
]
```

Information about the problem:
1. "N": agent
2. "S": goal
3. "|": wall
4. "_": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]
```

The rewards are:
1. "S": 1
 [/INST]
import numpy as np

maze=[
    ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
    ['|', 'N', '_', '_', '_', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '|', '_', '_', '_', '_', '_', '_', '_', '_', '_', '|'],
    ['|', '_', '_', '|', '|', '_', '_', '_', '|', '_', '_', '|'],
    ['|', '_', '_', '_', '_', '|', '_', '|', '_', '_', '|', '|'],
    ['|', '|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|'],
    ['|', '_', '_', '_', '|', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '_', '_', '|', '|', '_', '_', '_', '_', '_', '|', '|'],
    ['|', '_', '_', '|', '_', '_', '_', '_', '|', '|', '_', '|'],
    ['|', '|', '_', '|', '_', '_', '_', '_', '|', '_', '_', '|'],
    ['|', '_', '_', '_', '_', '_', '_', '_', '|', '|', '_', '|'],
    ['|', '_', '_', '|', '_', '_', '_', '_', '_', '_', 'S', '|'],
    ['|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|', '|'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '|'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'S':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '|':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
    ['^', 'S', '*', '*', '*', '^', '*', '*', '^'],
    ['^', '*', '*', '*', '^', '*', '^', '*', '^'],
    ['^', '^', '*', '*', '*', '^', '^', '*', '^'],
    ['^', '*', '*', '^', '^', '*', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '*', '^', '^', '^'],
    ['^', '*', '*', '*', '^', '*', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '^', '^', 'H', '^'],
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
]
```

Information about the problem:
1. "S": agent
2. "H": goal
3. "^": wall
4. "*": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]
```

The rewards are:
1. "H": 1
 [/INST]
import numpy as np

maze=[
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
    ['^', 'S', '*', '*', '*', '^', '*', '*', '^'],
    ['^', '*', '*', '*', '^', '*', '^', '*', '^'],
    ['^', '^', '*', '*', '*', '^', '^', '*', '^'],
    ['^', '*', '*', '^', '^', '*', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '*', '^', '^', '^'],
    ['^', '*', '*', '*', '^', '*', '*', '*', '^'],
    ['^', '*', '*', '^', '*', '^', '^', 'H', '^'],
    ['^', '^', '^', '^', '^', '^', '^', '^', '^'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (0, 2), (2, 0), (0, -2), (-2, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '^'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'H':
                    V[i][j] = 3
                    continue
                if maze[i][j] == '^':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', '~', ' ', '~'],
    ['~', ' ', '~', ' ', ' ', '~', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', '~', ' ', '~', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', ' ', ' ', '~', '~', '~'],
    ['~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'],
    ['~', '~', ' ', ' ', ' ', '~', '~', ' ', '~'],
    ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "P": agent
2. "X": goal
3. "~": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "X": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', '~', ' ', ' ', ' ', '~', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', '~', '~', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', '~', ' ', '~'],
    ['~', ' ', '~', ' ', ' ', '~', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', '~', ' ', '~', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', '~', ' ', ' ', '~', '~', '~'],
    ['~', ' ', '~', '~', ' ', ' ', ' ', '~', '~'],
    ['~', '~', ' ', ' ', ' ', '~', '~', ' ', '~'],
    ['~', '~', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'X':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', '*', '*', '*', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]
```

Information about the problem:
1. "E": agent
2. "T": goal
3. "*": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "T": 1
 [/INST]
import numpy as np

maze=[
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
    ['*', 'E', '*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', '*', ' ', '*', ' ', '*', ' ', ' ', '*', '*', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', '*', ' ', ' ', '*', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', ' ', '*'],
    ['*', ' ', ' ', ' ', '*', ' ', ' ', '*', ' ', ' ', ' ', '*'],
    ['*', ' ', '*', '*', ' ', ' ', ' ', '*', '*', '*', ' ', '*'],
    ['*', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'T', '*'],
    ['*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*', '*'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '*'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'T':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '*':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', 'O', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', 'O', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', 'O', 'O', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', 'O'],
    ['O', 'O', '.', '.', 'O', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', 'O', '.', '.', 'O', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "L": agent
2. "B": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "B": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', 'O', '.', '.', 'O', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'B':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '~', '-', '-', '~', '~', '-', '~', '-', '~', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~', '~', '-', '~'],
    ['~', '-', '-', '-', '~', '~', '-', '~', '-', '~', '~', '-', '-', '~'],
    ['~', '-', '~', '-', '~', '-', '-', '-', '~', '-', '-', '~', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "D": agent
2. "C": goal
3. "~": wall
4. "-": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "C": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '~', '-', '-', '~', '~', '-', '~', '-', '~', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '-', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~', '~', '-', '~'],
    ['~', '-', '-', '-', '~', '~', '-', '~', '-', '~', '~', '-', '-', '~'],
    ['~', '-', '~', '-', '~', '-', '-', '-', '~', '-', '-', '~', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'C':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~', '~'],
    ['~', '~', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', '~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', ' ', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "P": agent
2. "X": goal
3. "~": wall
4. " ": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "X": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'P', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '~'],
    ['~', ' ', ' ', ' ', ' ', '~', '~', ' ', ' ', '~', '~', '~'],
    ['~', '~', '~', ' ', ' ', ' ', ' ', '~', ' ', ' ', ' ', '~'],
    ['~', '~', '~', '~', ' ', '~', '~', ' ', ' ', ' ', ' ', '~'],
    ['~', '~', ' ', ' ', '~', ' ', ' ', ' ', ' ', ' ', '~', '~'],
    ['~', ' ', '~', ' ', '~', ' ', ' ', '~', ' ', ' ', 'X', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'X':
                    V[i][j] = 5
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', 'O', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O', 'O', '.', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "L": agent
2. "B": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "B": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'L', '.', 'O', 'O', '.', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O', '.', 'O', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O', 'O', '.', 'O'],
    ['O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O', 'O', '.', '.', 'B', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'B':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', 'O', '.', 'O', '.', '.', 'O', 'O', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O', 'O'],
    ['O', '.', '.', '.', '.', '.', 'O', 'O', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', 'O', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', 'O', 'O', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', 'O', 'O', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', 'O', '.', 'O'],
    ['O', 'O', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', 'O', '.', 'O', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'],
    ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'],
    ['~', '~', '-', '-', '-', '~', '-', '-', '-', '~', '-', '~', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~'],
    ['~', '-', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~', '~'],
    ['~', '-', '-', '~', '-', '-', '~', '-', '~', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '~', '-', '-', '~', '-', '-', '~', '-', '-', '-', '-', '~'],
    ['~', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '~', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~', '~', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]
```

Information about the problem:
1. "D": agent
2. "C": goal
3. "~": wall
4. "-": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]
```

The rewards are:
1. "C": 1
 [/INST]
import numpy as np

maze=[
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
    ['~', 'D', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '~', '~', '~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~'],
    ['~', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '-', '~'],
    ['~', '~', '-', '-', '-', '~', '-', '-', '-', '~', '-', '~', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '-', '-', '-', '~', '-', '~'],
    ['~', '-', '-', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~', '~'],
    ['~', '-', '-', '~', '-', '-', '~', '-', '~', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '~'],
    ['~', '-', '~', '-', '-', '~', '-', '-', '~', '-', '-', '-', '-', '~'],
    ['~', '-', '~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '~'],
    ['~', '-', '-', '~', '-', '-', '-', '-', '~', '~', '-', '-', '-', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '-', '~', '~', '~', '~', '~', '~'],
    ['~', '-', '-', '-', '-', '-', '-', '~', '~', '-', '-', '-', 'C', '~'],
    ['~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~', '~'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != '~'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'C':
                    V[i][j] = 2
                    continue
                if maze[i][j] == '~':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', 'O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', 'O', '.', 'O', '.', '.', 'O', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', '.', 'O', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', 'O', 'O', 'O', 'O', '.', '.', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'O', 'O'],
    ['O', 'O', 'O', '.', 'O', '.', '.', 'O', 'O', '.', 'O'],
    ['O', '.', 'O', '.', '.', 'O', 'O', 'O', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', '.', '.', '.', '.', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>


<s>[INST] <<SYS>>\n\n<</SYS>>\n\n
This is a maze problem that I want you to solve.

```
maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', 'O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', 'O', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]
```

Information about the problem:
1. "R": agent
2. "P": goal
3. "O": wall
4. ".": empty space

These are the set of actions that an agent can perform:
```
actions=[(0, 1), (1, 0), (0, -1), (-1, 0)]
```

The rewards are:
1. "P": 1
 [/INST]
import numpy as np

maze=[
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
    ['O', 'R', 'O', 'O', '.', '.', '.', 'O', '.', '.', 'O'],
    ['O', '.', 'O', 'O', 'O', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', 'O', '.', '.', '.', 'O', '.', 'O', '.', 'O'],
    ['O', '.', '.', '.', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', '.', 'O', '.', 'O', 'O', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', '.', '.', 'O', '.', '.', '.', '.', 'O'],
    ['O', '.', 'O', '.', '.', '.', '.', '.', '.', '.', 'O'],
    ['O', 'O', '.', 'O', 'O', '.', '.', '.', '.', 'P', 'O'],
    ['O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O'],
]

def value_iteration(maze, gamma=0.9):
    rows = len(maze)
    cols = len(maze[0])

    # Initialize the value function
    V = np.zeros((rows, cols))

    # Define actions:
    actions = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Helper function to check if a cell is valid to move into
    def is_valid_move(x, y):
        return 0 <= x < rows and 0 <= y < cols and maze[x][y] != 'O'

    # Perform value iteration
    for i in range(1000):
        for i in range(rows):
            for j in range(cols):
                if maze[i][j] == 'P':
                    V[i][j] = 3
                    continue
                if maze[i][j] == 'O':
                    continue  # Walls or obstacles have no value

                max_value = float('-inf')
                for action in actions:
                    new_i, new_j = i + action[0], j + action[1]
                    if is_valid_move(new_i, new_j):
                        max_value = max(max_value, V[new_i][new_j])
                V[i][j] = gamma * max_value

    return V

np.set_printoptions(precision=2)
print(value_iteration(maze))
 </s>