numpyUtilsUpdated 0.0.1__py3-none-any.whl

numpyUtilsUpdated/__init__.py

@@ -0,0 +1,5 @@
+print("[numpyUtilsNani] Submodules loaded: daa, cs, ai")
+print("for more details import the submodule you want to use:")
+print("use `import numpyUtilsNani.daa`....")
+print("use `import numpyUtilsNani.cs`....")
+print("use `import numpyUtilsNani.ai`....")

numpyUtilsUpdated/ai/AlphaBetaPr.py

@@ -0,0 +1,42 @@
+code = '''
+import math
+def alpha_beta_pruning(index, depth, alpha, beta, maximizing_player):
+    if depth == 0 or index >= len(scores):
+        return scores[index] if index < len(scores) else 0
+
+
+    left_index, right_index = 2 * index, 2 * index + 1
+
+
+    if maximizing_player:
+        max_eval = -float('inf')
+        for child_index in [left_index, right_index]:
+            if child_index < len(scores):
+                ab_val = alpha_beta_pruning(child_index, depth - 1, alpha, beta, False)
+                max_eval = max(max_eval, ab_val)
+                alpha = max(alpha, max_eval)
+                if beta <= alpha:
+                    break
+        return max_eval
+    else:
+        min_eval = float('inf')
+        for child_index in [left_index, right_index]:
+            if child_index < len(scores):
+                ab_val = alpha_beta_pruning(child_index, depth - 1, alpha, beta, True)
+                min_eval = min(min_eval, ab_val)
+                beta = min(beta, min_eval)
+                if beta <= alpha:
+                    break
+        return min_eval
+
+
+scores = list(map(int, input("Enter Scores: ").split()))
+depth = int(math.log2(len(scores)))
+print("The Optimal Value is:", alpha_beta_pruning(0, depth, -float('inf'), float('inf'), True))
+
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/BFS_8pz.py

@@ -0,0 +1,46 @@
+code = '''
+from collections import deque
+def get_neighbors(s):
+    i = s.index(0)
+    neighbors = []
+    for d in [-3, 3, -1, 1]:
+        j = i + d
+        if 0 <= j < 9 and abs(j//3 - i//3) + abs(j%3 - i%3) == 1:
+            n = [*s]
+            n[i], n[j] = n[j], n[i]
+            neighbors.append(n)
+    return neighbors
+
+
+def bfs_8_puzzle(start, goal):
+    if sum(a > b for i, a in enumerate(start[:-1]) for b in start[i+1:] if a and b) % 2:
+        return print("Unsolvable")
+    q = deque([(start, [])])
+    v = {tuple(start)}
+    while q:
+        s, p = q.popleft()
+        if s == goal:
+            for i, t in enumerate([start] + p):
+                print(f"Step {i + 1}:")
+                for j in range(0, 9, 3):
+                    print(' '.join(map(str, t[j:j+3])))
+                print()
+            return
+        for n in get_neighbors(s):
+            nt = tuple(n)
+            if nt not in v:
+                q.append((n, p + [n]))
+                v.add(nt)
+    print("No solution")
+
+
+print("Enter 3 rows :")
+start = sum([[int(x) for x in input(f"Row {i+1}: ").split()] for i in range(3)], [])
+goal = [1,2,3,4,5,6,7,8,0]
+bfs_8_puzzle(start, goal)
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/DFS_8pz.py

@@ -0,0 +1,50 @@
+code  = '''
+def get_matrix(prompt):
+    print(prompt)
+    return [list(map(int, input().split())) for _ in range(3)]
+
+def find_blank(state):
+    for i, row in enumerate(state):
+        if 0 in row:
+            return i, row.index(0)
+
+def generate_moves(state):
+    x, y = find_blank(state)
+    moves, directions = [], {'Up': (-1, 0), 'Down': (1, 0), 'Left': (0, -1), 'Right': (0, 1)}
+    
+    for move, (dx, dy) in directions.items():
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < 3 and 0 <= ny < 3:
+            new_state = [row[:] for row in state]
+            new_state[x][y], new_state[nx][ny] = new_state[nx][ny], new_state[x][y]
+            moves.append((move, new_state))
+    
+    return moves[::-1]
+
+def dfs(initial, goal):
+    stack, visited = [(initial, [], 0)], {tuple(map(tuple, initial))}
+    
+    while stack:
+        state, path, step = stack.pop()
+        print(f"Step {step}: {path[-1] if path else 'Start'}\n" + "\n".join(" ".join(map(str, row)) for row in state) + "\n")
+        
+        if state == goal:
+            print("Goal reached!")
+            return
+        
+        for move, new_state in generate_moves(state):
+            state_tuple = tuple(map(tuple, new_state))
+            if state_tuple not in visited:
+                visited.add(state_tuple)
+                stack.append((new_state, path + [move], step + 1))
+
+if __name__ == "__main__":
+    initial, goal = get_matrix("Enter initial state (3x3, space as 0):"), get_matrix("Enter goal state (3x3, space as 0):")
+    print("\nSolving 8-puzzle using DFS:\n")
+    dfs(initial, goal)
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/DLimitS_8pz.py

@@ -0,0 +1,48 @@
+code = '''
+def get_neighbors(state):
+    i = state.index(0)
+    moves = {'up': -3, 'down': 3, 'left': -1, 'right': 1}
+    return [swap(state, i, i + d) for m, d in moves.items()
+            if 0 <= i + d < 9 and abs((i + d) // 3 - i // 3) + abs((i + d) % 3 - i % 3) == 1]
+
+
+def swap(state, i, j):
+    s = state[:]
+    s[i], s[j] = s[j], s[i]
+    return s
+
+
+def print_matrix(state):
+    for i in range(0, 9, 3):
+        print(' '.join(map(str, state[i:i+3])))
+    print()
+
+
+def dfs_8_puzzle(start, goal, depth_limit):
+    stack, visited = [(start, [])], {tuple(start)}
+    while stack:
+        state, path = stack.pop()
+        if state == goal:
+            for i, s in enumerate(path):
+                print(f"Step {i+1}:")
+                print_matrix(s)
+            return
+        if len(path) < depth_limit:
+            for n in get_neighbors(state)[::-1]:
+                if tuple(n) not in visited:
+                    visited.add(tuple(n))
+                    stack.append((n, path + [n]))
+    print("No solution found within depth limit.")
+
+
+print("Enter 3 rows:")
+start = [int(x) for _ in range(3) for x in input(f"Row {_+1}: ").split()]
+depth_limit = int(input("Enter Depth limit: "))
+goal = [1, 2, 3, 4, 5, 6, 7, 8, 0]
+dfs_8_puzzle(start, goal, depth_limit)
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/GBFS.py

@@ -0,0 +1,33 @@
+code = '''
+graph = {'A': {'B': 6, 'F': 3}, 'B': {'C': 3, 'D': 2}, 'C': {'E': 5}, 'D': {'E': 8},
+         'E': {'J': 5, 'I': 5}, 'F': {'G': 1, 'H': 7}, 'G': {'I': 3}, 'H': {'I': 2},
+         'I': {'J': 3}, 'J': {}}
+heuristic = {'A': 10, 'B': 8, 'C': 5, 'D': 7, 'E': 3, 'F': 6, 'G': 5, 'H': 3, 'I': 1, 'J': 0}
+
+
+def gbfs(start, dest):
+    open_list, closed = [start], []
+    while open_list:
+        cur = min(open_list, key=heuristic.get)
+        open_list.remove(cur)
+        closed.append(cur)
+        if cur == dest:
+            return closed
+        open_list.extend(adj for adj in graph[cur] if adj not in open_list + closed)
+    return None
+
+
+start, end = input("Enter Starting Point: "), input("Enter Destination: ")
+path = gbfs(start, end)
+if path:
+    for n in path:
+        print(' '.join(f'[{n}, {heuristic[n]}]' ))
+else:
+    print("None")
+
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/GraphColor.py

@@ -0,0 +1,42 @@
+code = '''
+n = 7
+m = 3
+variables = ["A", "B", "C", "D", "E", "F", "G"]
+
+graph = [
+    [0, 1, 1, 0, 0, 0, 0],
+    [1, 0, 1, 1, 0, 0, 0],
+    [1, 1, 0, 1, 1, 1, 0],
+    [0, 1, 1, 1, 1, 0, 0],
+    [0, 0, 1, 1, 0, 1, 0],
+    [0, 0, 1, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0]
+]
+colors = ["R", "Y", "P"]
+color = [0]*n
+
+def is_Safe(curr, color, c):
+    return all(graph[curr][i] == 0 or color[i] != c for i in range(n))
+
+def graphColor(curr, color):
+    if curr == n:
+        return True
+    for c in range(1, m+1):
+        if is_Safe(curr, color, c):
+            color[curr] = c
+            if graphColor(curr + 1, color):
+                return True
+            color[curr] = 0
+    return False
+
+if graphColor(0, color):
+    for i in range(n):
+        print(f"{variables[i]}: {colors[color[i] - 1]}")
+else:
+    print("Solution does not exist")
+
+'''
+
+def getCode():
+    global code
+    print(code)

numpyUtilsUpdated/ai/Minimax.py

@@ -0,0 +1,71 @@
+code = '''
+def show(b):
+    for r in b:
+        print(" | ".join(r))
+    print("- " * 9)
+
+def win(b, p):
+    for i in range(3):
+        if all(b[i][j]==p for j in range(3)): return True
+        if all(b[j][i]==p for j in range(3)): return True
+    if all(b[i][i]==p for i in range(3)): return True
+    if all(b[i][2-i]==p for i in range(3)): return True
+    return False
+
+def full(b):
+    return all(c != " " for r in b for c in r)
+
+def minimax(b, turn):
+    if win(b, "X"): return 1
+    if win(b, "O"): return -1
+    if full(b): return 0
+    best = -2 if turn else 2
+    p = "X" if turn else "O"
+    for i in range(3):
+        for j in range(3):
+            if b[i][j] == " ":
+                b[i][j] = p
+                score = minimax(b, not turn)
+                b[i][j] = " "
+                if turn: best = max(best, score)
+                else: best = min(best, score)
+    return best
+
+def best_move(b):
+    best, pos = -2, None
+    for i in range(3):
+        for j in range(3):
+            if b[i][j] == " ":
+                b[i][j] = "X"
+                score = minimax(b, False)
+                b[i][j] = " "
+                if score > best:
+                    best = score
+                    pos = (i, j)
+    return pos
+
+b = [[" "] * 3 for _ in range(3)]
+print("Tic-Tac-Toe (O=You, X=AI)")
+show(b)
+
+while True:
+    r, c = map(int, input("Row Col: ").split())
+    if b[r][c] != " ":
+        print("Invalid"); continue
+    b[r][c] = "O"
+    show(b)
+    if win(b, "O"): print("You win!"); break
+    if full(b): print("Tie!"); break
+    m = best_move(b)
+    if m: b[m[0]][m[1]] = "X"
+    print("AI move:")
+    show(b)
+    if win(b, "X"): print("AI wins!"); break
+    if full(b): print("Tie!"); break
+
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/Prologs.py

@@ -0,0 +1,53 @@
+code = """
+%facts
+owns(nono,m).
+missile(m).
+enemy(nono,america).
+american(west).
+
+%rules
+sells(west,X,nono):-
+    missile(X),owns(nono,X).
+weapon(X):-
+    missile(X).
+hostile(X):-
+    enemy(X,america).
+criminal(X):-
+    american(X),weapon(Y),sells(X,Y,Z),hostile(Z).
+
+%Query
+is_criminal(X):-
+    criminal(X).
+
+---------------------------------------------------
+
+% Facts
+man(marcus).
+pompeian(marcus).
+
+ruler(caesar).
+tried_assassinate(marcus, caesar).
+
+% Rules
+
+roman(X) :- 
+    pompeian(X).
+loyal_to(X, caesar) :-
+    roman(X),
+    \+ tried_assassinate(X, caesar).
+
+hate(X, caesar) :-
+    roman(X),
+    \+ loyal_to(X, caesar).
+
+% Goal
+did_hate(marcus, caesar) :-
+    hate(marcus, caesar).
+
+"""
+
+def getCode():
+    global code
+    print(code)
+
+    

numpyUtilsUpdated/ai/UCS.py

@@ -0,0 +1,38 @@
+code = '''
+def get_matrix(): return [list(map(int, input().split())) for _ in range(3)]
+
+def find_blank(state): return next((i, j) for i in range(3) for j in range(3) if not state[i][j])
+
+def swap(state, x1, y1, x2, y2):
+    new_state = [row[:] for row in state]
+    new_state[x1][y1], new_state[x2][y2] = new_state[x2][y2], new_state[x1][y1]
+    return new_state
+
+def print_state(state): print("\n".join(" ".join(map(str, row)) for row in state), "\n")
+
+def uniform_cost_search(initial, goal):
+    queue, visited = [(0, initial, [])], set()
+    while queue:
+        queue.sort()
+        cost, state, path = queue.pop(0)
+        if state == goal: [print_state(step) for step in path + [state]]; return
+        state_tuple = tuple(map(tuple, state))
+        if state_tuple in visited: continue
+        visited.add(state_tuple)
+        x, y = find_blank(state)
+        for nx, ny in [(x-1,y), (x+1,y), (x,y-1), (x,y+1)]:
+            if 0 <= nx < 3 and 0 <= ny < 3:
+                queue.append((cost+1, swap(state, x, y, nx, ny), path + [state]))
+
+print("Enter initial state:")
+initial_state = get_matrix()
+print("Enter goal state:")
+goal_state = get_matrix()
+print("Solution Steps:")
+uniform_cost_search(initial_state, goal_state)
+
+'''
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/VaccumCleaner.py

@@ -0,0 +1,59 @@
+code = '''
+
+def initialize_environment():
+    n_rooms = int(input("No.of rooms: "))
+    room_dic = {}
+    for i in range(1, n_rooms + 1):
+        r_num = f"Room{i}"
+        status = input(f"Enter status of {r_num} (Clean/Dirty): ").strip().capitalize()
+        room_dic[r_num] = status
+    return room_dic
+
+
+def sense(room_dic, cur_loc):
+    return room_dic[cur_loc]
+
+
+def suck(room_dic, cur_loc):
+    if room_dic[cur_loc] == "Dirty":
+        print(f"Cleaning {cur_loc}")
+        room_dic[cur_loc] = "Clean"
+
+
+def isdone(room_dic):
+    return all(status == "Clean" for status in room_dic.values())
+
+
+def move(room_dic, cur_loc):
+    room_index = list(room_dic)
+    cur_index = room_index.index(cur_loc)
+    next_loc = room_index[(cur_index + 1) % len(room_index)]
+    print(f"Moving from {cur_loc} to {next_loc}")
+    return next_loc
+
+
+def act(room_dic, cur_loc):
+    if sense(room_dic, cur_loc) == "Dirty":
+        suck(room_dic, cur_loc)
+        return cur_loc
+    else:
+        return move(room_dic, cur_loc)
+
+if __name__ == "__main__":
+    room_dic = initialize_environment()
+    cur_loc = list(room_dic.keys())[0]
+    step = 1
+    print("\nInitial State:", room_dic)
+    while not all(status == "Clean" for status in room_dic.values()):
+        print(f"\nStep {step}:")
+        print(f"Current Location: {cur_loc}")
+        cur_loc = act(room_dic, cur_loc)
+        print("Environment State:", room_dic)
+        step += 1
+    print("\nFINAL STATE:", room_dic,"\n")
+
+'''
+
+def getCode():
+    global code
+    print(code)

numpyUtilsUpdated/ai/Wumpus.py

@@ -0,0 +1,89 @@
+code = '''
+import random
+
+grid_size = 4
+
+
+def generate_world():
+    world = [[' ' for _ in range(grid_size)] for _ in range(grid_size)]
+   
+    # Place Wumpus, Gold, and Pits randomly
+    elements = ['W', 'G', 'P', 'P']
+    positions = random.sample([(i, j) for i in range(grid_size) for j in range(grid_size) if (i, j) != (0, 0)], len(elements))
+   
+    for (x, y), elem in zip(positions, elements):
+        world[x][y] = elem
+   
+    return world
+
+
+def display_percepts(world, x, y):
+    percepts = []
+   
+    if any(world[i][j] == 'W' for i, j in get_neighbors(x, y)):
+        percepts.append("Stench detected!")
+    if any(world[i][j] == 'P' for i, j in get_neighbors(x, y)):
+        percepts.append("Breeze detected!")
+   
+    return percepts
+
+
+def get_neighbors(x, y):
+    neighbors = []
+    for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+        nx, ny = x + dx, y + dy
+        if 0 <= nx < grid_size and 0 <= ny < grid_size:
+            neighbors.append((nx, ny))
+    return neighbors
+
+
+def display_state(x, y):
+    for i in range(grid_size):
+        for j in range(grid_size):
+            if (i, j) == (x, y):
+                print('A', end=' ')
+            else:
+                print('.', end=' ')
+        print()
+    print()
+
+
+if __name__ == "__main__":
+    world = generate_world()
+    x, y = 0, 0  # Starting position
+   
+    while True:
+        display_state(x, y)
+        percepts = display_percepts(world, x, y)
+        for p in percepts:
+            print(p)
+       
+        move = input("Move (up/down/left/right): ").strip().lower()
+        if move == "up" and x > 0:
+            x -= 1
+        elif move == "down" and x < grid_size - 1:
+            x += 1
+        elif move == "left" and y > 0:
+            y -= 1
+        elif move == "right" and y < grid_size - 1:
+            y += 1
+        else:
+            print("Invalid move. Try again.")
+            continue
+       
+        if world[x][y] == 'W':
+            print("You were eaten by the Wumpus! Game Over.")
+            break
+        elif world[x][y] == 'P':
+            print("You fell into a pit! Game Over.")
+            break
+        elif world[x][y] == 'G':
+            print("You found the Gold! You Win!")
+            break
+            
+'''
+
+def getCode():
+    global code
+    print(code)
+    

numpyUtilsUpdated/ai/__init__.py

@@ -0,0 +1,19 @@
+files = '''
+ AlphaBetaPr 
+ BFS_8pz 
+ DFS_8pz 
+ DLimitS_8pz 
+ GBFS 
+ GraphColor 
+ Minimax 
+ Prologs 
+ ticTacToe 
+ UCS 
+ VaccumCleaner 
+ waterJug 
+ Wumpus 
+
+'''
+
+print(f"[ai] Modules: {files}")
+print("example usage: `import numpyUtilsNani.ai.{Module}.getcode()`....")