ai-practical-kit 1.1.0__py3-none-any.whl

ai_practical_kit/experiments/robot_path_bfs.py

@@ -0,0 +1,98 @@
+"""Experiment 7: BFS for Robot Path Planning on a grid."""
+
+from collections import deque
+
+
+def solve_robot_bfs(maze):
+    """Find a shortest path in a grid containing S, G, # and . characters."""
+    if not maze or not maze[0]:
+        raise ValueError("Maze cannot be empty.")
+    rows = len(maze)
+    cols = len(maze[0])
+    if any(len(row) != cols for row in maze):
+        raise ValueError("All maze rows must have the same length.")
+
+    start = None
+    goal = None
+    for r in range(rows):
+        for c in range(cols):
+            if maze[r][c] == "S":
+                if start is not None:
+                    raise ValueError("Maze must contain exactly one S.")
+                start = (r, c)
+            elif maze[r][c] == "G":
+                if goal is not None:
+                    raise ValueError("Maze must contain exactly one G.")
+                goal = (r, c)
+    if start is None or goal is None:
+        raise ValueError("Maze must contain one S (start) and one G (goal).")
+
+    queue = deque([start])
+    parent = {start: None}
+    distance = {start: 0}
+    # Same direction order as the practical: Down, Right, Up, Left.
+    directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+    while queue:
+        current = queue.popleft()
+        if current == goal:
+            break
+        for dr, dc in directions:
+            nr = current[0] + dr
+            nc = current[1] + dc
+            next_cell = (nr, nc)
+            if nr < 0 or nr >= rows or nc < 0 or nc >= cols:
+                continue
+            if maze[nr][nc] == "#" or next_cell in parent:
+                continue
+            parent[next_cell] = current
+            distance[next_cell] = distance[current] + 1
+            queue.append(next_cell)
+
+    if goal not in parent:
+        return {"found": False, "path": [], "moves": None, "maze": list(maze)}
+
+    path = []
+    cell = goal
+    while cell is not None:
+        path.append(cell)
+        cell = parent[cell]
+    path.reverse()
+
+    marked = [list(row) for row in maze]
+    for r, c in path:
+        if marked[r][c] == ".":
+            marked[r][c] = "*"
+    return {"found": True, "path": path, "moves": distance[goal],
+            "maze": ["".join(row) for row in marked]}
+
+
+def run_cli():
+    print("\nEXPERIMENT 7: BFS ROBOT PATH PLANNING")
+    try:
+        rows, cols = [int(x) for x in input("Enter rows and columns: ").split()]
+        if rows < 1 or cols < 1 or rows > 50 or cols > 50:
+            raise ValueError("Rows and columns must be between 1 and 50.")
+        print("Enter each maze row using S=start, G=goal, #=wall, .=free:")
+        maze = [input().strip() for _ in range(rows)]
+        if any(len(row) != cols for row in maze):
+            raise ValueError("Each row must contain exactly the given number of columns.")
+        result = solve_robot_bfs(maze)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+
+    if not result["found"]:
+        print("No path exists from S to G.")
+        return
+    print("\nShortest path (1-based coordinates):")
+    print(" -> ".join("(" + str(r + 1) + "," + str(c + 1) + ")"
+                      for r, c in result["path"]))
+    print("Shortest path length:", result["moves"], "moves")
+    print("\nFinal path grid:")
+    for row in result["maze"]:
+        print(" ".join(row))
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/rule_chatbot.py

@@ -0,0 +1,47 @@
+"""Experiment 10: Rule-based chatbot with regular-expression matching."""
+
+import random
+import re
+
+RULES = [
+    (r"\b(hi|hello|hey)\b", ["Hello! How can I help you?", "Hi! Nice to meet you."]),
+    (r"\bhow are you\b", ["I am fine, thank you!", "I am doing great!"]),
+    (r"\b(admission|apply|application)\b", ["Please check the college admission portal."]),
+    (r"\b(fee|fees|tuition)\b", ["Please check the college fee portal."]),
+    (r"\b(library|books?)\b", ["Please check the college library."]),
+    (r"\b(hostel|accommodation)\b", ["Please contact the student affairs office."]),
+    (r"\b(thanks|thank you)\b", ["You are welcome!", "Happy to help!"]),
+    (r"\b(bye|goodbye|exit|quit)\b", ["Goodbye! Have a nice day!"]),
+]
+
+
+def respond(text):
+    """Return a rule-based response for a user message."""
+    text = text.strip()
+
+    # AND rule: both an admission topic and a fee topic must be present.
+    has_admission = re.search(r"\b(admission|apply|application)\b", text, re.I)
+    has_fees = re.search(r"\b(fee|fees|tuition)\b", text, re.I)
+    if has_admission and has_fees:
+        return "Check the admission portal AND the fee portal."
+
+    for pattern, replies in RULES:
+        if re.search(pattern, text, re.I):
+            return random.choice(replies)
+
+    return "Sorry, I do not understand your question."
+
+
+def run_cli():
+    print("\nEXPERIMENT 10: RULE-BASED CHATBOT")
+    print("Ask about greetings, admission, fees, library or hostel.")
+    print("Type bye to stop.")
+    while True:
+        user = input("You: ")
+        print("Bot:", respond(user))
+        if re.search(r"\b(bye|goodbye|exit|quit)\b", user, re.I):
+            break
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/sudoku_solver.py

@@ -0,0 +1,136 @@
+"""Experiment 5: Sudoku solver using constraint propagation and backtracking."""
+
+
+def is_safe(grid, row, col, number):
+    """Return True if number does not repeat in its row, column or 3x3 box."""
+    for i in range(9):
+        if grid[row][i] == number:
+            return False
+        if grid[i][col] == number:
+            return False
+
+    start_row = (row // 3) * 3
+    start_col = (col // 3) * 3
+    for r in range(start_row, start_row + 3):
+        for c in range(start_col, start_col + 3):
+            if grid[r][c] == number:
+                return False
+    return True
+
+
+def valid_initial_grid(grid):
+    if len(grid) != 9 or any(len(row) != 9 for row in grid):
+        return False
+    for row in range(9):
+        for col in range(9):
+            number = grid[row][col]
+            if not isinstance(number, int) or number < 0 or number > 9:
+                return False
+            if number != 0:
+                grid[row][col] = 0
+                safe = is_safe(grid, row, col, number)
+                grid[row][col] = number
+                if not safe:
+                    return False
+    return True
+
+
+def propagate(grid):
+    """Repeatedly fill empty cells having exactly one legal candidate."""
+    changed = True
+    while changed:
+        changed = False
+        for row in range(9):
+            for col in range(9):
+                if grid[row][col] == 0:
+                    candidates = []
+                    for number in range(1, 10):
+                        if is_safe(grid, row, col, number):
+                            candidates.append(number)
+                    if len(candidates) == 0:
+                        return False
+                    if len(candidates) == 1:
+                        grid[row][col] = candidates[0]
+                        changed = True
+    return True
+
+
+def solve_sudoku(puzzle):
+    """Return a solved 9x9 grid, or None when no solution exists."""
+    if not valid_initial_grid(puzzle):
+        return None
+
+    def solve(current_grid):
+        # Work on a copy so a failed guess cannot damage the previous state.
+        grid = [row[:] for row in current_grid]
+
+        if not propagate(grid):
+            return None
+
+        empty_row = -1
+        empty_col = -1
+        for row in range(9):
+            for col in range(9):
+                if grid[row][col] == 0:
+                    empty_row = row
+                    empty_col = col
+                    break
+            if empty_row != -1:
+                break
+
+        if empty_row == -1:
+            return grid
+
+        for number in range(1, 10):
+            if is_safe(grid, empty_row, empty_col, number):
+                next_grid = [row[:] for row in grid]
+                next_grid[empty_row][empty_col] = number
+                answer = solve(next_grid)
+                if answer is not None:
+                    return answer
+        return None
+
+    return solve(puzzle)
+
+
+def print_grid(grid):
+    for row in range(9):
+        if row in (3, 6):
+            print("------+-------+------")
+        for col in range(9):
+            if col in (3, 6):
+                print("|", end=" ")
+            print(grid[row][col], end=" ")
+        print()
+
+
+def run_cli():
+    print("\nEXPERIMENT 5: SUDOKU (CONSTRAINT PROPAGATION + BACKTRACKING)")
+    print("Enter 9 rows, using 0 for empty cells. Example: 530070000")
+    grid = []
+    try:
+        for _ in range(9):
+            line = input().strip()
+            if " " in line:
+                row = [int(x) for x in line.split()]
+            else:
+                row = [int(ch) for ch in line]
+            if len(row) != 9:
+                raise ValueError("Each row must contain 9 digits.")
+            grid.append(row)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+
+    print("\nInitial Sudoku:")
+    print_grid(grid)
+    answer = solve_sudoku(grid)
+    if answer is None:
+        print("No solution exists or the starting grid is invalid.")
+    else:
+        print("\nSolved Sudoku:")
+        print_grid(answer)
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/tictactoe_minimax.py

@@ -0,0 +1,148 @@
+"""Experiment 11: Tic-Tac-Toe game-playing agent using Minimax."""
+
+WINNING_LINES = [
+    (0, 1, 2), (3, 4, 5), (6, 7, 8),
+    (0, 3, 6), (1, 4, 7), (2, 5, 8),
+    (0, 4, 8), (2, 4, 6),
+]
+
+
+def check_winner(board):
+    for a, b, c in WINNING_LINES:
+        if board[a] != " " and board[a] == board[b] and board[b] == board[c]:
+            return board[a]
+    if " " in board:
+        return " "
+    return "D"
+
+
+def minimax(board, is_max):
+    result = check_winner(board)
+    if result == "X":
+        return 1
+    if result == "O":
+        return -1
+    if result == "D":
+        return 0
+
+    if is_max:
+        best = -2
+        for i in range(9):
+            if board[i] == " ":
+                board[i] = "X"
+                score = minimax(board, False)
+                board[i] = " "
+                if score > best:
+                    best = score
+        return best
+
+    best = 2
+    for i in range(9):
+        if board[i] == " ":
+            board[i] = "O"
+            score = minimax(board, True)
+            board[i] = " "
+            if score < best:
+                best = score
+    return best
+
+
+def find_best_move(board):
+    """Return the zero-based best move for X, or None if game is over."""
+    if len(board) != 9:
+        raise ValueError("Board must contain 9 cells.")
+    if check_winner(board) != " ":
+        return None
+
+    best_score = -2
+    move = None
+    for i in range(9):
+        if board[i] == " ":
+            board[i] = "X"
+            score = minimax(board, False)
+            board[i] = " "
+            if score > best_score:
+                best_score = score
+                move = i
+    return move
+
+
+def display_board(board):
+    for row in range(3):
+        cells = []
+        for col in range(3):
+            index = row * 3 + col
+            if board[index] == " ":
+                cells.append(str(index + 1))
+            else:
+                cells.append(board[index])
+        print(" | ".join(cells))
+        if row < 2:
+            print("---------")
+
+
+def run_demo():
+    board = ["X", "X", " ", "O", "O", " ", " ", " ", " "]
+    print("\nInitial board (X = AI, O = opponent):")
+    display_board(board)
+    move = find_best_move(board)
+    if move is None:
+        print("No move available; the game has ended.")
+        return
+    print("\nBest move for AI:", move + 1)
+    board[move] = "X"
+    print("\nBoard after AI move:")
+    display_board(board)
+    print("Minimax score:", minimax(board, True))
+
+
+def play_game():
+    board = [" "] * 9
+    print("\nTic-Tac-Toe: AI = X, You = O")
+    while True:
+        move = find_best_move(board)
+        if move is not None:
+            board[move] = "X"
+            print("\nAI chooses:", move + 1)
+            display_board(board)
+        result = check_winner(board)
+        if result == "X":
+            print("AI wins!")
+            break
+        if result == "D":
+            print("Draw!")
+            break
+
+        while True:
+            try:
+                position = int(input("Enter your move (1-9): "))
+            except ValueError:
+                print("Enter a number from 1 to 9.")
+                continue
+            if position >= 1 and position <= 9 and board[position - 1] == " ":
+                break
+            print("Invalid or occupied position. Try again.")
+        board[position - 1] = "O"
+        display_board(board)
+        result = check_winner(board)
+        if result == "O":
+            print("You win!")
+            break
+        if result == "D":
+            print("Draw!")
+            break
+
+
+def run_cli():
+    print("\nEXPERIMENT 11: TIC-TAC-TOE USING MINIMAX")
+    print("1. Demonstrate the best move (no human input)")
+    print("2. Play against the AI")
+    choice = input("Choose 1 or 2 [1]: ").strip()
+    if choice == "2":
+        play_game()
+    else:
+        run_demo()
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/tower_of_hanoi_bfs.py

@@ -0,0 +1,100 @@
+"""Experiment 4: Tower of Hanoi solved by BFS over legal states."""
+
+from collections import deque
+
+PEG_NAMES = "ABC"
+
+
+def solve_hanoi_bfs(number_of_disks):
+    """Return shortest sequence of moves and the number of explored states.
+
+    State is a tuple where state[d] is the peg index (0=A, 1=B, 2=C)
+    holding disk d. Disk 0 is the smallest disk.
+    """
+    if not isinstance(number_of_disks, int) or number_of_disks < 1 or number_of_disks > 8:
+        raise ValueError("Number of disks must be between 1 and 8.")
+
+    start = tuple(0 for _ in range(number_of_disks))
+    goal = tuple(2 for _ in range(number_of_disks))
+    queue = deque([start])
+    parent = {start: None}
+    move_to_state = {}
+
+    while queue:
+        current = queue.popleft()
+        if current == goal:
+            break
+
+        # Find the top (smallest numbered) disk on each peg.
+        top = [-1, -1, -1]
+        for disk in range(number_of_disks):
+            peg = current[disk]
+            if top[peg] == -1:
+                top[peg] = disk
+
+        for source in range(3):
+            disk = top[source]
+            if disk == -1:
+                continue
+
+            for destination in range(3):
+                if source == destination:
+                    continue
+
+                destination_top = top[destination]
+                # A larger disk cannot be placed on a smaller one.
+                if destination_top != -1 and disk > destination_top:
+                    continue
+
+                next_state = list(current)
+                next_state[disk] = destination
+                next_state = tuple(next_state)
+
+                if next_state not in parent:
+                    parent[next_state] = current
+                    move_to_state[next_state] = (
+                        disk + 1, PEG_NAMES[source], PEG_NAMES[destination]
+                    )
+                    queue.append(next_state)
+
+    if goal not in parent:
+        return {"found": False, "moves": [], "states_explored": len(parent)}
+
+    states = []
+    moves = []
+    state = goal
+    while state is not None:
+        states.append(state)
+        if state in move_to_state:
+            moves.append(move_to_state[state])
+        state = parent[state]
+    states.reverse()
+    moves.reverse()
+
+    return {"found": True, "states": states, "moves": moves,
+            "number_of_moves": len(moves), "states_explored": len(parent)}
+
+
+def run_cli():
+    print("\nEXPERIMENT 4: TOWER OF HANOI USING BFS")
+    try:
+        n = int(input("Enter number of disks (1-8): "))
+        result = solve_hanoi_bfs(n)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+
+    if not result["found"]:
+        print("No solution found.")
+        return
+    if not result["moves"]:
+        print("No moves needed.")
+    for step, move in enumerate(result["moves"], 1):
+        disk, source, destination = move
+        print("Step", step, ": Move disk", disk, "from", source, "to", destination)
+    print("Total moves:", result["number_of_moves"])
+    print("States explored:", result["states_explored"])
+
+
+if __name__ == "__main__":
+    run_cli()

ai_practical_kit/experiments/vacuum_cleaner.py

@@ -0,0 +1,70 @@
+"""Experiment 1: Simple Reflex Agent for the Vacuum Cleaner World.
+
+Run standalone with: python -m ai_practical_kit.experiments.vacuum_cleaner
+"""
+
+
+def solve_vacuum(room_a, room_b, position):
+    """Return the action sequence and final state for a two-room vacuum agent.
+
+    room_a / room_b accept 'D' or 'C' (also 1=dirty, 0=clean).
+    position accepts 'A' or 'B'.
+    """
+    def clean_status(value):
+        value = str(value).strip().upper()
+        if value in ("D", "1"):
+            return "D"
+        if value in ("C", "0"):
+            return "C"
+        raise ValueError("Room status must be D/C or 1/0.")
+
+    room_a = clean_status(room_a)
+    room_b = clean_status(room_b)
+    position = str(position).strip().upper()
+    if position not in ("A", "B"):
+        raise ValueError("Position must be A or B.")
+
+    actions = []
+    while room_a == "D" or room_b == "D":
+        if position == "A":
+            if room_a == "D":
+                actions.append("SUCK Room A")
+                room_a = "C"
+            else:
+                actions.append("MOVE RIGHT to Room B")
+                position = "B"
+        else:
+            if room_b == "D":
+                actions.append("SUCK Room B")
+                room_b = "C"
+            else:
+                actions.append("MOVE LEFT to Room A")
+                position = "A"
+
+    return {"actions": actions, "room_a": room_a, "room_b": room_b,
+            "position": position}
+
+
+def run_cli():
+    print("\nEXPERIMENT 1: VACUUM CLEANER AGENT")
+    print("Enter 1 for Dirty or 0 for Clean (D/C also accepted).")
+    a = input("Room A status: ")
+    b = input("Room B status: ")
+    pos = input("Agent starts in room A or B: ")
+    try:
+        result = solve_vacuum(a, b, pos)
+    except ValueError as error:
+        print("Input error:", error)
+        return
+    print("\nActions:")
+    if not result["actions"]:
+        print("No action needed.")
+    else:
+        for number, action in enumerate(result["actions"], 1):
+            print(str(number) + ". " + action)
+    print("Final state: A =", result["room_a"], ", B =", result["room_b"])
+    print("Both rooms are clean.")
+
+
+if __name__ == "__main__":
+    run_cli()