pracai 0.0.1__tar.gz

pracai-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+
+---
+
+### `LICENSE`
+
+```text id="vs1qjv"
+MIT License
+
+Copyright (c) 2026 Arya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

pracai-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: pracai
+Version: 0.0.1
+Summary: Python package containing multiple utility scripts
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nltk
+Dynamic: license-file
+
+# MyPackage
+
+A Python package containing multiple utility scripts.
+
+## Installation
+
+```bash
+pip install mypackage

pracai-0.0.1/README.md

@@ -0,0 +1,8 @@
+# MyPackage
+
+A Python package containing multiple utility scripts.
+
+## Installation
+
+```bash
+pip install mypackage

pracai-0.0.1/mypackage/A 8 puzzle.py

@@ -0,0 +1,73 @@
+import heapq
+import copy
+
+goal = [[1,2,3],
+        [4,5,6],
+        [7,8,0]]
+
+# Heuristic: Manhattan Distance
+def heuristic(state):
+    h = 0
+    for i in range(3):
+        for j in range(3):
+            val = state[i][j]
+            if val != 0:
+                goal_x = (val - 1) // 3
+                goal_y = (val - 1) % 3
+                h += abs(i - goal_x) + abs(j - goal_y)
+    return h
+
+# Get neighbors
+def get_neighbors(state):
+    neighbors = []
+
+    for i in range(3):
+        for j in range(3):
+            if state[i][j] == 0:
+                x, y = i, j
+
+    moves = [(0,1), (1,0), (0,-1), (-1,0)]
+
+    for dx, dy in moves:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < 3 and 0 <= ny < 3:
+            new_state = copy.deepcopy(state)
+            new_state[x][y], new_state[nx][ny] = new_state[nx][ny], new_state[x][y]
+            neighbors.append(new_state)
+
+    return neighbors
+
+
+def a_star(initial):
+    pq = []
+    heapq.heappush(pq, (heuristic(initial), 0, initial))  # (f, g, state)
+
+    visited = set()
+
+    while pq:
+        f, g, current = heapq.heappop(pq)
+
+        print("\nCurrent State:")
+        for row in current:
+            print(row)
+
+        if current == goal:
+            print("\nGoal Reached!")
+            return
+
+        visited.add(str(current))
+
+        for neighbor in get_neighbors(current):
+            if str(neighbor) not in visited:
+                new_g = g + 1
+                new_f = new_g + heuristic(neighbor)
+                heapq.heappush(pq, (new_f, new_g, neighbor))
+
+
+# Initial state
+initial = [[1,2,3],
+           [4,5,6],
+           [0,7,8]]
+
+print("A* Algorithm for 8 Puzzle:")
+a_star(initial)

pracai-0.0.1/mypackage/A CitiesDistance.py

@@ -0,0 +1,58 @@
+import heapq
+
+# Graph with distances
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('A', 1), ('D', 2), ('E', 5)],
+    'C': [('A', 4), ('F', 3)],
+    'D': [('B', 2), ('G', 1)],
+    'E': [('B', 5), ('G', 2)],
+    'F': [('C', 3), ('G', 6)],
+    'G': []
+}
+
+# Heuristic values (estimated distance to goal G)
+heuristic = {
+    'A': 6, 'B': 5, 'C': 4,
+    'D': 3, 'E': 2, 'F': 5, 'G': 0
+}
+
+def a_star(start, goal):
+    pq = []
+    heapq.heappush(pq, (heuristic[start], 0, start))  # (f, g, node)
+
+    visited = set()
+    parent = {start: None}
+
+    while pq:
+        f, g, current = heapq.heappop(pq)
+
+        if current in visited:
+            continue
+        visited.add(current)
+
+        # Goal check
+        if current == goal:
+            path = []
+            while current:
+                path.append(current)
+                current = parent[current]
+
+            print("Shortest Path:", " -> ".join(path[::-1]))
+            print("Total Cost:", g)
+            return
+
+        # Explore neighbors
+        for neighbor, cost in graph[current]:
+            if neighbor not in visited:
+                parent[neighbor] = current
+                new_g = g + cost
+                new_f = new_g + heuristic[neighbor]
+                heapq.heappush(pq, (new_f, new_g, neighbor))
+
+    print("No path found")
+
+
+# Run
+print("A* for Cities Distance:")
+a_star('A', 'G')

pracai-0.0.1/mypackage/A RobotNavigation.py

@@ -0,0 +1,62 @@
+import heapq
+
+def a_star(grid, start, goal):
+    
+    # Heuristic (Manhattan distance)
+    def h(pos):
+        return abs(pos[0] - goal[0]) + abs(pos[1] - goal[1])
+
+    pq = []
+    heapq.heappush(pq, (h(start), 0, start))  # (f, g, position)
+
+    visited = set()
+    parent = {start: None}
+
+    while pq:
+        f, g, current = heapq.heappop(pq)
+
+        # Goal check
+        if current == goal:
+            path = []
+            while current:
+                path.append(current)
+                current = parent[current]
+            print("Path:", path[::-1])
+            print("Cost:", g)
+            return
+
+        if current in visited:
+            continue
+        visited.add(current)
+
+        x, y = current
+
+        # Possible moves
+        for dx, dy in [(0,1), (1,0), (0,-1), (-1,0)]:
+            nx, ny = x + dx, y + dy
+
+            # Check valid move
+            if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]) and grid[nx][ny] == 0:
+                if (nx, ny) not in visited:
+                    new_g = g + 1
+                    new_f = new_g + h((nx, ny))
+
+                    parent[(nx, ny)] = current
+                    heapq.heappush(pq, (new_f, new_g, (nx, ny)))
+
+    print("No path found")
+
+
+# Example grid
+grid = [
+    [0, 0, 1, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 0],
+    [0, 1, 1, 0]
+]
+
+start = (0, 0)
+goal = (3, 3)
+
+print("A* Robot Navigation:")
+a_star(grid, start, goal)

pracai-0.0.1/mypackage/BFS 8puzzle.py

@@ -0,0 +1,69 @@
+import heapq
+import copy
+
+goal = [[1,2,3],
+        [4,5,6],
+        [7,8,0]]
+
+# Heuristic function (misplaced tiles)
+def heuristic(state):
+    h = 0
+    for i in range(3):
+        for j in range(3):
+            if state[i][j] != 0 and state[i][j] != goal[i][j]:
+                h += 1
+    return h
+
+# Get neighbors
+def get_neighbors(state):
+    neighbors = []
+
+    for i in range(3):
+        for j in range(3):
+            if state[i][j] == 0:
+                x, y = i, j
+
+    moves = [(0,1), (1,0), (0,-1), (-1,0)]
+
+    for dx, dy in moves:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < 3 and 0 <= ny < 3:
+            new_state = copy.deepcopy(state)
+            new_state[x][y], new_state[nx][ny] = new_state[nx][ny], new_state[x][y]
+            neighbors.append(new_state)
+
+    return neighbors
+
+
+def best_first_search(initial):
+    visited = set()
+    pq = []
+
+    # (heuristic, state)
+    heapq.heappush(pq, (heuristic(initial), initial))
+
+    while pq:
+        h, current = heapq.heappop(pq)
+
+        print("\nCurrent State:")
+        for row in current:
+            print(row)
+
+        if current == goal:
+            print("\nGoal Reached!")
+            return
+
+        visited.add(str(current))
+
+        for neighbor in get_neighbors(current):
+            if str(neighbor) not in visited:
+                heapq.heappush(pq, (heuristic(neighbor), neighbor))
+
+
+# Initial state
+initial = [[1,2,3],
+           [4,5,6],
+           [0,7,8]]
+
+print("Best First Search for 8 Puzzle:")
+best_first_search(initial)

pracai-0.0.1/mypackage/CitiesDistance.py

@@ -0,0 +1,49 @@
+import heapq
+
+# Graph (city connections with distances)
+graph = {
+    'A': [('B', 1), ('C', 4)],
+    'B': [('A', 1), ('D', 2), ('E', 5)],
+    'C': [('A', 4), ('F', 3)],
+    'D': [('B', 2), ('G', 1)],
+    'E': [('B', 5), ('G', 2)],
+    'F': [('C', 3), ('G', 6)],
+    'G': []
+}
+
+# Heuristic values (estimated distance to goal G)
+heuristic = {
+    'A': 6, 'B': 5, 'C': 4,
+    'D': 3, 'E': 2, 'F': 5, 'G': 0
+}
+
+def best_first_search(start, goal):
+    pq = [(heuristic[start], start)]  # (h, city)
+    visited = set()
+    parent = {start: None}
+
+    while pq:
+        _, current = heapq.heappop(pq)
+
+        # Goal check
+        if current == goal:
+            path = []
+            while current:
+                path.append(current)
+                current = parent[current]
+            print("Path:", " -> ".join(path[::-1]))
+            return
+
+        visited.add(current)
+
+        for neighbor, _ in graph[current]:
+            if neighbor not in visited:
+                parent[neighbor] = current
+                heapq.heappush(pq, (heuristic[neighbor], neighbor))
+
+    print("No path found")
+
+
+# Run
+print("Best First Search (Cities Distance):")
+best_first_search('A', 'G')

pracai-0.0.1/mypackage/CrossWord.py

@@ -0,0 +1,92 @@
+def print_grid(grid):
+    for row in grid:
+        print("".join(row))
+    print()
+
+
+def can_place_h(grid, word, row, col):
+    if col + len(word) > len(grid[0]):
+        return False
+    for i in range(len(word)):
+        if grid[row][col + i] != '-' and grid[row][col + i] != word[i]:
+            return False
+    return True
+
+
+def can_place_v(grid, word, row, col):
+    if row + len(word) > len(grid):
+        return False
+    for i in range(len(word)):
+        if grid[row + i][col] != '-' and grid[row + i][col] != word[i]:
+            return False
+    return True
+
+
+def place_h(grid, word, row, col):
+    temp = []
+    for i in range(len(word)):
+        temp.append(grid[row][col + i])
+        grid[row][col + i] = word[i]
+    return temp
+
+
+def place_v(grid, word, row, col):
+    temp = []
+    for i in range(len(word)):
+        temp.append(grid[row + i][col])
+        grid[row + i][col] = word[i]
+    return temp
+
+
+def unplace_h(grid, temp, row, col):
+    for i in range(len(temp)):
+        grid[row][col + i] = temp[i]
+
+
+def unplace_v(grid, temp, row, col):
+    for i in range(len(temp)):
+        grid[row + i][col] = temp[i]
+
+
+def solve_crossword(grid, words):
+    if not words:
+        return True
+
+    word = words[0]
+
+    for i in range(len(grid)):
+        for j in range(len(grid[0])):
+
+            # Horizontal
+            if can_place_h(grid, word, i, j):
+                temp = place_h(grid, word, i, j)
+                if solve_crossword(grid, words[1:]):
+                    return True
+                unplace_h(grid, temp, i, j)
+
+            # Vertical
+            if can_place_v(grid, word, i, j):
+                temp = place_v(grid, word, i, j)
+                if solve_crossword(grid, words[1:]):
+                    return True
+                unplace_v(grid, temp, i, j)
+
+    return False
+
+
+# Grid
+grid = [
+    ['+', '-', '+', '+', '+'],
+    ['+', '-', '-', '-', '+'],
+    ['+', '-', '+', '+', '+'],
+    ['+', '+', '+', '+', '+']
+]
+
+words = ["HI", "IT"]
+
+print("Solving Crossword...\n")
+
+if solve_crossword(grid, words):
+    print_grid(grid)
+else:
+    print("No solution found")

pracai-0.0.1/mypackage/Cryptarithmetic.py

@@ -0,0 +1,34 @@
+import itertools
+
+def solve_cryptarithmetic():
+    letters = "SENDMORY"
+    
+    print("Solving SEND + MORE = MONEY...\n")
+
+    # Try all permutations of digits
+    for perm in itertools.permutations(range(10), len(letters)):
+        s, e, n, d, m, o, r, y = perm
+
+        # Leading digit cannot be 0
+        if s == 0 or m == 0:
+            continue
+
+        # Form numbers
+        send  = s*1000 + e*100 + n*10 + d
+        more  = m*1000 + o*100 + r*10 + e
+        money = m*10000 + o*1000 + n*100 + e*10 + y
+
+        # Check condition
+        if send + more == money:
+            print("Solution Found!\n")
+            print(" SEND =", send)
+            print(" MORE =", more)
+            print("MONEY =", money)
+            print("\nMapping:")
+            print(dict(zip(letters, perm)))
+            return
+
+    print("No solution found")
+
+# Run
+solve_cryptarithmetic()

pracai-0.0.1/mypackage/HillClimbing8puzzle.py

@@ -0,0 +1,73 @@
+import copy
+
+# Heuristic: count misplaced tiles
+def heuristic(state, goal):
+    h = 0
+    for i in range(3):
+        for j in range(3):
+            if state[i][j] != 0 and state[i][j] != goal[i][j]:
+                h += 1
+    return h
+
+
+# Get neighbors by moving blank (0)
+def get_neighbors(state):
+    neighbors = []
+    
+    # Find position of 0
+    for i in range(3):
+        for j in range(3):
+            if state[i][j] == 0:
+                x, y = i, j
+
+    # Possible moves
+    moves = [(0,1), (1,0), (0,-1), (-1,0)]
+
+    for dx, dy in moves:
+        nx, ny = x + dx, y + dy
+        
+        if 0 <= nx < 3 and 0 <= ny < 3:
+            new_state = copy.deepcopy(state)
+            new_state[x][y], new_state[nx][ny] = new_state[nx][ny], new_state[x][y]
+            neighbors.append(new_state)
+
+    return neighbors
+
+
+def hill_climbing(initial, goal):
+    current = initial
+
+    while True:
+        print("\nCurrent State:")
+        for row in current:
+            print(row)
+
+        # Check goal
+        if current == goal:
+            print("\nGoal Reached!")
+            return
+
+        neighbors = get_neighbors(current)
+
+        # Choose best neighbor
+        next_state = min(neighbors, key=lambda x: heuristic(x, goal))
+
+        # If no improvement → stop
+        if heuristic(next_state, goal) >= heuristic(current, goal):
+            print("\nReached Local Optimum (stuck)")
+            return
+
+        current = next_state
+
+
+# Initial and Goal
+initial = [[1,2,3],
+           [4,5,6],
+           [0,7,8]]
+
+goal = [[1,2,3],
+        [4,5,6],
+        [7,8,0]]
+
+print("Hill Climbing for 8 Puzzle:")
+hill_climbing(initial, goal)

pracai-0.0.1/mypackage/MapColouring.py

@@ -0,0 +1,46 @@
+def is_safe(graph, color, node, c):
+    for i in range(len(graph)):
+        if graph[node][i] == 1 and color[i] == c:
+            return False
+    return True
+
+
+def solve(graph, m, color, node):
+    # If all nodes colored
+    if node == len(graph):
+        return True
+
+    for c in range(1, m + 1):
+        if is_safe(graph, color, node, c):
+            color[node] = c
+
+            if solve(graph, m, color, node + 1):
+                return True
+
+            color[node] = 0  # backtrack
+
+    return False
+
+
+def map_coloring():
+    # Adjacency matrix
+    graph = [
+        [0, 1, 1, 1],
+        [1, 0, 1, 0],
+        [1, 1, 0, 1],
+        [1, 0, 1, 0]
+    ]
+
+    m = 3  # number of colors
+    color = [0] * len(graph)
+
+    if solve(graph, m, color, 0):
+        print("Color assignment:")
+        for i in range(len(color)):
+            print(f"Region {i} -> Color {color[i]}")
+    else:
+        print("No solution exists")
+
+
+# Run
+map_coloring()

pracai-0.0.1/mypackage/MinimaxTicTacToe.py

@@ -0,0 +1,95 @@
+import math
+
+def print_board(board):
+    for row in board:
+        print(" | ".join(row))
+    print("-" * 9)
+
+
+def check_winner(board):
+    # Rows
+    for row in board:
+        if row[0] == row[1] == row[2] and row[0] != " ":
+            return row[0]
+
+    # Columns
+    for col in range(3):
+        if board[0][col] == board[1][col] == board[2][col] and board[0][col] != " ":
+            return board[0][col]
+
+    # Diagonals
+    if board[0][0] == board[1][1] == board[2][2] and board[0][0] != " ":
+        return board[0][0]
+
+    if board[0][2] == board[1][1] == board[2][0] and board[0][2] != " ":
+        return board[0][2]
+
+    return None
+
+
+def is_full(board):
+    return all(cell != " " for row in board for cell in row)
+
+
+def minimax(board, is_maximizing):
+    winner = check_winner(board)
+
+    if winner == 'X':
+        return 1
+    if winner == 'O':
+        return -1
+    if is_full(board):
+        return 0
+
+    if is_maximizing:
+        best = -math.inf
+        for i in range(3):
+            for j in range(3):
+                if board[i][j] == " ":
+                    board[i][j] = 'X'
+                    score = minimax(board, False)
+                    board[i][j] = " "
+                    best = max(best, score)
+        return best
+    else:
+        best = math.inf
+        for i in range(3):
+            for j in range(3):
+                if board[i][j] == " ":
+                    board[i][j] = 'O'
+                    score = minimax(board, True)
+                    board[i][j] = " "
+                    best = min(best, score)
+        return best
+
+
+def best_move(board):
+    best_score = -math.inf
+    move = None
+
+    for i in range(3):
+        for j in range(3):
+            if board[i][j] == " ":
+                board[i][j] = 'X'
+                score = minimax(board, False)
+                board[i][j] = " "
+
+                if score > best_score:
+                    best_score = score
+                    move = (i, j)
+
+    return move
+
+
+# Example board
+board = [
+    ['O', 'X', ' '],
+    [' ', 'X', ' '],
+    [' ', ' ', 'O']
+]
+
+print("Current Board:")
+print_board(board)
+
+move = best_move(board)
+print("Best move for X:", move)

pracai-0.0.1/mypackage/NQueens.py

@@ -0,0 +1,58 @@
+# N-Queens - Non AI (Backtracking)
+
+def print_board(board, n):
+    for i in range(n):
+        for j in range(n):
+            print(board[i][j], end=" ")
+        print()
+    print()
+
+def is_safe(board, row, col, n):
+    # Check column
+    for i in range(row):
+        if board[i][col] == 'Q':
+            return False
+
+    # Check left diagonal
+    i, j = row-1, col-1
+    while i >= 0 and j >= 0:
+        if board[i][j] == 'Q':
+            return False
+        i -= 1
+        j -= 1
+
+    # Check right diagonal
+    i, j = row-1, col+1
+    while i >= 0 and j < n:
+        if board[i][j] == 'Q':
+            return False
+        i -= 1
+        j += 1
+
+    return True
+
+def solve_n_queens(board, row, n):
+    if row == n:
+        print("Solution:")
+        print_board(board, n)
+        return True
+
+    for col in range(n):
+        if is_safe(board, row, col, n):
+            board[row][col] = 'Q'
+
+            if solve_n_queens(board, row + 1, n):
+                return True
+
+            board[row][col] = '.'  # backtrack
+
+    return False
+
+def main():
+    n = int(input("Enter value of N: "))
+    board = [['.' for _ in range(n)] for _ in range(n)]
+
+    if not solve_n_queens(board, 0, n):
+        print("No solution exists")
+
+main()

pracai-0.0.1/mypackage/POS Tagging.py

@@ -0,0 +1,24 @@
+import nltk
+
+def pos_tagging():
+    text = input("Enter a sentence: ")
+
+    # Tokenize words
+    words = nltk.word_tokenize(text)
+
+    # POS tagging
+    tags = nltk.pos_tag(words)
+
+    print("\nPOS Tags:")
+    for word, tag in tags:
+        print(word, "->", tag)
+
+
+# Download required data (only first time)
+nltk.download('punkt')
+nltk.download('punkt_tab')
+nltk.download('averaged_perceptron_tagger')
+nltk.download('averaged_perceptron_tagger_eng')
+
+# Run
+pos_tagging()

pracai-0.0.1/mypackage/RobotNavigation.py

@@ -0,0 +1,53 @@
+import heapq
+
+def best_first_search(grid, start, goal):
+    
+    # Heuristic function (Manhattan Distance)
+    def h(pos):
+        return abs(pos[0] - goal[0]) + abs(pos[1] - goal[1])
+
+    pq = [(h(start), start)]
+    visited = set([start])
+    parent = {start: None}
+
+    while pq:
+        _, current = heapq.heappop(pq)
+
+        # Goal check
+        if current == goal:
+            path = []
+            while current:
+                path.append(current)
+                current = parent[current]
+            print("Path:", path[::-1])
+            return
+
+        x, y = current
+
+        # Possible moves: right, down, left, up
+        for dx, dy in [(0,1), (1,0), (0,-1), (-1,0)]:
+            nx, ny = x + dx, y + dy
+
+            # Check valid move
+            if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]) and grid[nx][ny] == 0:
+                if (nx, ny) not in visited:
+                    visited.add((nx, ny))
+                    parent[(nx, ny)] = current
+                    heapq.heappush(pq, (h((nx, ny)), (nx, ny)))
+
+    print("No path found")
+
+
+# Example grid
+grid = [
+    [0, 0, 1, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 0],
+    [0, 1, 1, 0]
+]
+
+start = (0, 0)
+goal = (3, 3)
+
+print("Robot Navigation using Best First Search:")
+best_first_search(grid, start, goal)

pracai-0.0.1/mypackage/SimilarityScore.py

@@ -0,0 +1,33 @@
+from collections import Counter
+import math
+
+def cosine_similarity(text1, text2):
+    # Convert to word frequency
+    vec1 = Counter(text1.lower().split())
+    vec2 = Counter(text2.lower().split())
+
+    # Common words
+    intersection = set(vec1.keys()) & set(vec2.keys())
+
+    # Numerator
+    numerator = sum(vec1[x] * vec2[x] for x in intersection)
+
+    # Denominator
+    sum1 = sum(v**2 for v in vec1.values())
+    sum2 = sum(v**2 for v in vec2.values())
+
+    denominator = math.sqrt(sum1) * math.sqrt(sum2)
+
+    if denominator == 0:
+        return 0.0
+
+    return numerator / denominator
+
+
+# Input
+t1 = input("Enter first sentence: ")
+t2 = input("Enter second sentence: ")
+
+score = cosine_similarity(t1, t2)
+
+print("\nSimilarity Score:", round(score, 4))

pracai-0.0.1/mypackage/SpellChecker.py

@@ -0,0 +1,34 @@
+def levenshtein_distance(s1, s2):
+    if len(s1) < len(s2):
+        return levenshtein_distance(s2, s1)
+
+    if len(s2) == 0:
+        return len(s1)
+
+    previous_row = range(len(s2) + 1)
+
+    for i, c1 in enumerate(s1):
+        current_row = [i + 1]
+
+        for j, c2 in enumerate(s2):
+            insertions = previous_row[j + 1] + 1
+            deletions = current_row[j] + 1
+            substitutions = previous_row[j] + (c1 != c2)
+
+            current_row.append(min(insertions, deletions, substitutions))
+
+        previous_row = current_row
+
+    return previous_row[-1]
+
+
+# Dictionary
+dictionary = ["apple", "banana", "orange", "grape", "intelligence", "artificial"]
+
+# Input
+word = input("Enter word: ")
+
+# Find closest word
+closest = min(dictionary, key=lambda w: levenshtein_distance(word, w))
+
+print("\nDid you mean:", closest)

pracai-0.0.1/mypackage/TicTacToe.py

@@ -0,0 +1,59 @@
+# Tic Tac Toe - Non AI (Simple Version)
+
+board = [" " for _ in range(9)]
+
+def print_board():
+    print()
+    print(board[0], "|", board[1], "|", board[2])
+    print("--+---+--")
+    print(board[3], "|", board[4], "|", board[5])
+    print("--+---+--")
+    print(board[6], "|", board[7], "|", board[8])
+    print()
+
+def check_winner(player):
+    win_positions = [
+        [0,1,2], [3,4,5], [6,7,8],   # rows
+        [0,3,6], [1,4,7], [2,5,8],   # columns
+        [0,4,8], [2,4,6]             # diagonals
+    ]
+    
+    for pos in win_positions:
+        if board[pos[0]] == player and \
+           board[pos[1]] == player and \
+           board[pos[2]] == player:
+            return True
+    return False
+
+def play_game():
+    player = "X"
+    
+    for turn in range(9):
+        print_board()
+        move = int(input(f"Player {player}, enter position (0-8): "))
+
+        if move < 0 or move > 8:
+            print("Invalid input! Try again.")
+            continue
+
+        if board[move] != " ":
+            print("Position already taken!")
+            continue
+
+        board[move] = player
+
+        if check_winner(player):
+            print_board()
+            print(f"Player {player} wins!")
+            return
+
+        # switch player
+        if player == "X":
+            player = "O"
+        else:
+            player = "X"
+
+    print_board()
+    print("Match Draw!")
+
+play_game()

pracai-0.0.1/mypackage/WaterJugBFS.py

@@ -0,0 +1,45 @@
+from collections import deque
+
+def water_jug_bfs(cap1, cap2, target):
+    visited = set()
+    queue = deque([((0, 0), [])])  # (state, path)
+
+    while queue:
+        (jug1, jug2), path = queue.popleft()
+
+        # If already visited, skip
+        if (jug1, jug2) in visited:
+            continue
+
+        visited.add((jug1, jug2))
+        path = path + [(jug1, jug2)]
+
+        # Goal condition
+        if jug1 == target or jug2 == target:
+            print("Solution Path:")
+            for state in path:
+                print(state)
+            return
+
+        # All possible operations
+        next_states = [
+            (cap1, jug2),  # Fill jug1
+            (jug1, cap2),  # Fill jug2
+            (0, jug2),     # Empty jug1
+            (jug1, 0),     # Empty jug2
+            # Pour jug1 -> jug2
+            (jug1 - min(jug1, cap2 - jug2), jug2 + min(jug1, cap2 - jug2)),
+            # Pour jug2 -> jug1
+            (jug1 + min(jug2, cap1 - jug1), jug2 - min(jug2, cap1 - jug1))
+        ]
+
+        # Add new states to queue
+        for state in next_states:
+            if state not in visited:
+                queue.append((state, path))
+
+    print("No solution found")
+
+
+# Example
+water_jug_bfs(3, 5, 4)

pracai-0.0.1/mypackage/WaterJugDFS.py

@@ -0,0 +1,61 @@
+# Water Jug Problem using DFS
+
+def dfs(jug1, jug2, visited, path, cap1, cap2, target):
+    
+    # If already visited, stop
+    if (jug1, jug2) in visited:
+        return False
+
+    visited.add((jug1, jug2))
+    path.append((jug1, jug2))
+
+    # Goal condition
+    if jug1 == target or jug2 == target:
+        return True
+
+    # All possible operations
+
+    # Fill jug1
+    if dfs(cap1, jug2, visited, path, cap1, cap2, target):
+        return True
+
+    # Fill jug2
+    if dfs(jug1, cap2, visited, path, cap1, cap2, target):
+        return True
+
+    # Empty jug1
+    if dfs(0, jug2, visited, path, cap1, cap2, target):
+        return True
+
+    # Empty jug2
+    if dfs(jug1, 0, visited, path, cap1, cap2, target):
+        return True
+
+    # Pour jug1 → jug2
+    pour = min(jug1, cap2 - jug2)
+    if dfs(jug1 - pour, jug2 + pour, visited, path, cap1, cap2, target):
+        return True
+
+    # Pour jug2 → jug1
+    pour = min(jug2, cap1 - jug1)
+    if dfs(jug1 + pour, jug2 - pour, visited, path, cap1, cap2, target):
+        return True
+
+    path.pop()  # backtrack
+    return False
+
+
+def water_jug_dfs(cap1, cap2, target):
+    visited = set()
+    path = []
+
+    if dfs(0, 0, visited, path, cap1, cap2, target):
+        print("Solution Path:")
+        for state in path:
+            print(state)
+    else:
+        print("No solution")
+
+
+# Example
+water_jug_dfs(3, 5, 4)

pracai-0.0.1/mypackage/__init__.py

@@ -0,0 +1 @@
+# empty

pracai-0.0.1/mypackage/cli.py

@@ -0,0 +1,19 @@
+import os
+
+def main():
+    path = os.path.dirname(__file__)
+
+    files = []
+
+    for f in sorted(os.listdir(path)):
+        if f.endswith(".py") and f not in ["__init__.py", "cli.py"]:
+            files.append(f[:-3])   # .py remove karega
+
+    print("\nAvailable modules:\n")
+
+    for i, file in enumerate(files, 1):
+        print(f"{i}. {file}")
+
+
+if __name__ == "__main__":
+    main()

pracai-0.0.1/mypackage/magicSquare.py

@@ -0,0 +1,39 @@
+# Magic Square (Odd Order) - Non AI
+
+def generate_magic_square(n):
+    magic = [[0]*n for _ in range(n)]
+
+    i = 0
+    j = n // 2   # middle column
+
+    for num in range(1, n*n + 1):
+        magic[i][j] = num
+
+        new_i = (i - 1) % n
+        new_j = (j + 1) % n
+
+        if magic[new_i][new_j]:
+            i = (i + 1) % n
+        else:
+            i = new_i
+            j = new_j
+
+    return magic
+
+def print_square(square):
+    for row in square:
+        print(" ".join(str(x) for x in row))
+
+def main():
+    n = int(input("Enter odd number (n): "))
+
+    if n % 2 == 0:
+        print("Magic square only works for odd n")
+        return
+
+    square = generate_magic_square(n)
+
+    print("\nMagic Square:")
+    print_square(square)
+
+main()

pracai-0.0.1/pracai.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: pracai
+Version: 0.0.1
+Summary: Python package containing multiple utility scripts
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nltk
+Dynamic: license-file
+
+# MyPackage
+
+A Python package containing multiple utility scripts.
+
+## Installation
+
+```bash
+pip install mypackage

pracai-0.0.1/pracai.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+LICENSE
+README.md
+pyproject.toml
+mypackage/A 8 puzzle.py
+mypackage/A CitiesDistance.py
+mypackage/A RobotNavigation.py
+mypackage/BFS 8puzzle.py
+mypackage/CitiesDistance.py
+mypackage/CrossWord.py
+mypackage/Cryptarithmetic.py
+mypackage/HillClimbing8puzzle.py
+mypackage/MapColouring.py
+mypackage/MinimaxTicTacToe.py
+mypackage/NQueens.py
+mypackage/POS Tagging.py
+mypackage/RobotNavigation.py
+mypackage/SimilarityScore.py
+mypackage/SpellChecker.py
+mypackage/TicTacToe.py
+mypackage/WaterJugBFS.py
+mypackage/WaterJugDFS.py
+mypackage/__init__.py
+mypackage/cli.py
+mypackage/magicSquare.py
+pracai.egg-info/PKG-INFO
+pracai.egg-info/SOURCES.txt
+pracai.egg-info/dependency_links.txt
+pracai.egg-info/entry_points.txt
+pracai.egg-info/requires.txt
+pracai.egg-info/top_level.txt

pracai-0.0.1/pracai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pracai-0.0.1/pracai.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pracai = mypackage.cli:main

pracai-0.0.1/pracai.egg-info/requires.txt

@@ -0,0 +1 @@
+nltk

pracai-0.0.1/pracai.egg-info/top_level.txt

@@ -0,0 +1 @@
+mypackage

pracai-0.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pracai"
+version = "0.0.1"
+description = "Python package containing multiple utility scripts"
+readme = "README.md"
+requires-python = ">=3.8"
+
+dependencies = ["nltk"]
+
+[project.scripts]
+pracai = "mypackage.cli:main"
+
+[tool.setuptools]
+packages = ["mypackage"]

pracai-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+