aoalabcode 1.0.0__py3-none-any.whl

aoalabcode/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

aoalabcode/cli.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+from importlib.resources import files
+import shutil
+import sys
+
+CODES = {
+    "floyd": "Floyd_Warshall.txt",
+    "binarysearch": "BinarySearch.txt",
+    "dijkstra": "Dijkstra.txt",
+    "bellmanford": "Bellman_Ford.txt",
+    "graphcolouring": "GraphColouring.txt",
+    "greedyknapsack": "GreedyKnapsack.txt",
+    "insertionsort": "InsertionSort.txt",
+    "kmp": "KMP.txt",
+    "kruskal": "Kruskal.txt",
+    "hamiltonian": "Hamiltonian.txt",
+    "lcs": "LCS.txt",
+    "maxmin": "MaxMin.txt",
+    "mergesort": "MergeSort.txt",
+    "nqueen": "NQueen.txt",
+    "naive": "naive_string_matches.txt",
+    "prims": "Prims.txt",
+    "quicksort": "QuickSort.txt",
+    "selectionsort": "SelectionSort.txt",
+    "rabinkarp": "Rabin_Karp_Matcher.txt",
+    "sumofsubsets": "SumOfSubsets.txt",
+}
+
+
+def copy_template(code):
+    try:
+        src = files("aoalabcode.templates").joinpath(CODES[code])
+        dst = Path.cwd() / CODES[code]
+
+        shutil.copy(str(src), dst)
+
+        print(f"\nDownloaded {CODES[code]}")
+        print(f"Saved to {dst}")
+
+    except Exception as e:
+        print(f"\nError: {e}")
+
+
+def list_codes():
+    print("\nAvailable Codes:\n")
+
+    for code in CODES:
+        print(code)
+
+
+def copy_all():
+    for code in CODES:
+        copy_template(code)
+
+
+def interactive_menu():
+    codes = list(CODES.keys())
+
+    print("\nAvailable Codes:\n")
+
+    for i, code in enumerate(codes, start=1):
+        print(f"{i}. {code}")
+
+    try:
+        choice = int(input("\nChoose option: "))
+
+        if 1 <= choice <= len(codes):
+            copy_template(codes[choice - 1])
+        else:
+            print("Invalid choice")
+
+    except ValueError:
+        print("Please enter a valid number")
+
+
+def main():
+    if len(sys.argv) == 1:
+        interactive_menu()
+        return
+
+    command = sys.argv[1].lower()
+
+    if command == "list":
+        list_codes()
+
+    elif command == "all":
+        copy_all()
+
+    elif command in CODES:
+        copy_template(command)
+
+    else:
+        print("\nCode not found.\n")
+
+        print("Available commands:")
+        print("  aoalabcode")
+        print("  aoalabcode list")
+        print("  aoalabcode all")
+        print("  aoalabcode <code>")
+
+
+if __name__ == "__main__":
+    main()

aoalabcode/templates/Bellman_Ford.txt

@@ -0,0 +1,39 @@
+def Bellman_Ford(G, s):
+    dist = {}
+
+    for v in G:
+        dist[v] = float('inf')
+
+    dist[s] = 0
+
+    for i in range(len(G) - 1):
+        for u, v, w in G["edges"]:
+            if dist[u] != float('inf') and dist[v] > dist[u] + w:
+                dist[v] = dist[u] + w
+
+    for u, v, w in G["edges"]:
+        if dist[u] != float('inf') and dist[v] > dist[u] + w:
+            return False
+
+    print("Shortest Distances:")
+    for v in dist:
+        print(v, ":", dist[v])
+
+    return True
+
+
+# Example
+G = {
+    "A": [],
+    "B": [],
+    "C": [],
+    "D": [],
+    "edges": [
+        ("A", "B", 4),
+        ("A", "C", 5),
+        ("B", "C", -2),
+        ("C", "D", 3)
+    ]
+}
+
+print("Negative Cycle Present:", not Bellman_Ford(G, "A"))

aoalabcode/templates/BinarySearch.txt

@@ -0,0 +1,26 @@
+def binary_search(a, x):
+    low = 0
+    high = len(a) - 1
+
+    while low <= high:
+        mid = (low + high) // 2
+
+        if a[mid] == x:
+            return mid
+        elif a[mid] < x:
+            low = mid + 1
+        else:
+            high = mid - 1
+
+    return -1
+
+
+a = [10, 20, 30, 40, 50]
+x = 30
+
+result = binary_search(a, x)
+
+if result == -1:
+    print("Element not found")
+else:
+    print("Element found at position", result + 1)

aoalabcode/templates/Dijikstra.txt

@@ -0,0 +1,38 @@
+def dijkstra(graph, s):
+    dist = {}
+
+    for v in graph:
+        dist[v] = float('inf')
+
+    dist[s] = 0
+
+    S = set()
+    Q = list(graph.keys())
+
+    while Q:
+        u = min(Q, key=lambda x: dist[x])
+
+        Q.remove(u)
+        S.add(u)
+
+        for v, w in graph[u]:
+            if dist[v] > dist[u] + w:
+                dist[v] = dist[u] + w
+
+    return dist
+
+
+# Example Graph
+graph = {
+    'A': [('B', 4), ('C', 1)],
+    'B': [('D', 1)],
+    'C': [('B', 2), ('D', 5)],
+    'D': []
+}
+
+s = 'A'
+
+dist = dijkstra(graph, s)
+
+for v in dist:
+    print(v, ":", dist[v])

aoalabcode/templates/Floyd_Warshall.txt

@@ -0,0 +1,26 @@
+def FLOYD_WARSHALL(W):
+    n = len(W)
+    D = [row[:] for row in W]
+
+    for k in range(n):
+        for i in range(n):
+            for j in range(n):
+                D[i][j] = min(D[i][j], D[i][k] + D[k][j])
+
+    return D
+
+
+# Example
+INF = float('inf')
+
+W = [
+    [0, 3, INF, 7],
+    [8, 0, 2, INF],
+    [5, INF, 0, 1],
+    [2, INF, INF, 0]
+]
+
+D = FLOYD_WARSHALL(W)
+
+for row in D:
+    print(row)

aoalabcode/templates/GraphColouring.txt

@@ -0,0 +1,33 @@
+def isSafe(k, color):
+    for j in range(1, n + 1):
+        if G[k][j] == 1 and x[j] == color:
+            return False
+    return True
+
+
+def GraphColoring(k):
+    for color in range(1, m + 1):
+        if isSafe(k, color):
+            x[k] = color
+
+            if k == n:
+                print(x[1:n + 1])
+            else:
+                GraphColoring(k + 1)
+
+
+# Example
+n = 4
+m = 3
+
+G = [
+    [0, 0, 0, 0, 0],
+    [0, 0, 1, 1, 1],
+    [0, 1, 0, 1, 0],
+    [0, 1, 1, 0, 1],
+    [0, 1, 0, 1, 0]
+]
+
+x = [0] * (n + 1)
+
+GraphColoring(1)

aoalabcode/templates/GreedyKnapsack.txt

@@ -0,0 +1,23 @@
+def fractionalKnapsack(items, capacity):
+    weightTaken = 0
+    profit = 0
+
+    items.sort(key=lambda x: x[0] / x[1], reverse=True)
+
+    for vi, wi in items:
+        if weightTaken + wi <= capacity:
+            weightTaken += wi
+            profit += vi
+        else:
+            remaining = capacity - weightTaken
+            profit += remaining * (vi / wi)
+            break
+
+    return profit
+
+
+# Example
+items = [(60, 10), (100, 20), (120, 30)]  # (value, weight)
+capacity = 50
+
+print("Maximum Profit =", fractionalKnapsack(items, capacity))

aoalabcode/templates/Hamiltonian.txt

@@ -0,0 +1,46 @@
+def nextValue(k):
+    while True:
+        x[k] = (x[k] + 1) % (n + 1)
+
+        if x[k] == 0:
+            return
+
+        if G[x[k - 1]][x[k]] == 1:
+            for j in range(1, k):
+                if x[j] == x[k]:
+                    break
+
+            if j == k - 1:
+                if k < n or (k == n and G[x[n]][x[1]] == 1):
+                    return
+
+
+def Hamiltonian(k):
+    while True:
+        nextValue(k)
+
+        if x[k] == 0:
+            return
+
+        if k == n:
+            print(x[1:n + 1])
+        else:
+            Hamiltonian(k + 1)
+
+
+# Example
+n = 5
+
+G = [
+    [0, 0, 0, 0, 0, 0],
+    [0, 0, 1, 1, 0, 1],
+    [0, 1, 0, 1, 1, 0],
+    [0, 1, 1, 0, 1, 1],
+    [0, 0, 1, 1, 0, 1],
+    [0, 1, 0, 1, 1, 0]
+]
+
+x = [0] * (n + 1)
+x[1] = 1
+
+Hamiltonian(2)

aoalabcode/templates/InsertionSort.txt

@@ -0,0 +1,19 @@
+def insertion_sort(a):
+    for i in range(1, len(a)):
+        key = a[i]
+        j = i - 1
+
+        while j >= 0 and a[j] > key:
+            a[j + 1] = a[j]
+            j -= 1
+
+        a[j + 1] = key
+
+
+a = [64, 25, 12, 22, 11]
+
+insertion_sort(a)
+
+print("Sorted Array:")
+for i in a:
+    print(i, end=" ")

aoalabcode/templates/KMP.txt

@@ -0,0 +1,41 @@
+def Compute_Prefix_Function(P):
+    m = len(P)
+    pi = [0] * m
+    k = 0
+
+    for q in range(1, m):
+        while k > 0 and P[k] != P[q]:
+            k = pi[k - 1]
+
+        if P[k] == P[q]:
+            k += 1
+
+        pi[q] = k
+
+    return pi
+
+
+def KMP_Matcher(S, P):
+    n = len(S)
+    m = len(P)
+
+    pi = Compute_Prefix_Function(P)
+    q = 0
+
+    for i in range(n):
+        while q > 0 and P[q] != S[i]:
+            q = pi[q - 1]
+
+        if P[q] == S[i]:
+            q += 1
+
+        if q == m:
+            print("Pattern occurs with shift", i - m + 1)
+            q = pi[q - 1]
+
+
+# Example
+S = input("Enter text: ")
+P = input("Enter pattern: ")
+
+KMP_Matcher(S, P)

aoalabcode/templates/Kruskal.txt

@@ -0,0 +1,32 @@
+def find(parent, i):
+    if parent[i] == i:
+        return i
+    return find(parent, parent[i])
+
+
+def union(parent, x, y):
+    parent[find(parent, x)] = find(parent, y)
+
+
+def MST_Kruskal(V, E):
+    A = []
+    parent = {}
+
+    for v in V:
+        parent[v] = v
+
+    E.sort(key=lambda x: x[2])
+
+    for u, v, w in E:
+        if find(parent, u) != find(parent, v):
+            A.append((u, v, w))
+            union(parent, u, v)
+
+    return A
+
+
+# Example
+V = [0, 1, 2, 3]
+E = [(0, 1, 10), (0, 2, 6), (0, 3, 5), (1, 3, 15), (2, 3, 4)]
+
+print(MST_Kruskal(V, E))

aoalabcode/templates/LCS.txt

@@ -0,0 +1,44 @@
+def LCS_LENGTH(X, Y):
+    m = len(X)
+    n = len(Y)
+
+    c = [[0] * (n + 1) for _ in range(m + 1)]
+    b = [[""] * (n + 1) for _ in range(m + 1)]
+
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if X[i - 1] == Y[j - 1]:
+                c[i][j] = c[i - 1][j - 1] + 1
+                b[i][j] = "↖"
+            elif c[i - 1][j] >= c[i][j - 1]:
+                c[i][j] = c[i - 1][j]
+                b[i][j] = "↑"
+            else:
+                c[i][j] = c[i][j - 1]
+                b[i][j] = "←"
+
+    return c, b
+
+
+def PRINT_LCS(b, X, i, j):
+    if i == 0 or j == 0:
+        return
+
+    if b[i][j] == "↖":
+        PRINT_LCS(b, X, i - 1, j - 1)
+        print(X[i - 1], end="")
+    elif b[i][j] == "↑":
+        PRINT_LCS(b, X, i - 1, j)
+    else:
+        PRINT_LCS(b, X, i, j - 1)
+
+
+X = input("Enter X: ")
+Y = input("Enter Y: ")
+
+c, b = LCS_LENGTH(X, Y)
+
+print("Length of LCS =", c[len(X)][len(Y)])
+print("LCS =", end=" ")
+PRINT_LCS(b, X, len(X), len(Y))
+print()

aoalabcode/templates/MaxMin.txt

@@ -0,0 +1,31 @@
+def maxmin(i, j, a):
+    if i == j:
+        return a[i], a[i]
+
+    if i == j - 1:
+        if a[i] > a[j]:
+            return a[i], a[j]
+        else:
+            return a[j], a[i]
+
+    mid = (i + j) // 2
+
+    max, min = maxmin(i, mid, a)
+    max1, min1 = maxmin(mid + 1, j, a)
+
+    if max < max1:
+        max = max1
+
+    if min > min1:
+        min = min1
+
+    return max, min
+
+
+# Example
+a = list(map(int, input("Enter elements: ").split()))
+
+max, min = maxmin(0, len(a) - 1, a)
+
+print("Maximum =", max)
+print("Minimum =", min)

aoalabcode/templates/MergeSort.txt

@@ -0,0 +1,39 @@
+def merge_sort(a):
+    if len(a) > 1:
+        mid = len(a) // 2
+
+        L = a[:mid]
+        R = a[mid:]
+
+        merge_sort(L)
+        merge_sort(R)
+
+        i = j = k = 0
+
+        while i < len(L) and j < len(R):
+            if L[i] < R[j]:
+                a[k] = L[i]
+                i += 1
+            else:
+                a[k] = R[j]
+                j += 1
+            k += 1
+
+        while i < len(L):
+            a[k] = L[i]
+            i += 1
+            k += 1
+
+        while j < len(R):
+            a[k] = R[j]
+            j += 1
+            k += 1
+
+
+a = [64, 25, 12, 22, 11]
+
+merge_sort(a)
+
+print("Sorted Array:")
+for i in a:
+    print(i, end=" ")

aoalabcode/templates/NQueen.txt

@@ -0,0 +1,23 @@
+def isSafe(k, i):
+    for j in range(1, k):
+        if x[j] == i or abs(x[j] - i) == abs(j - k):
+            return False
+    return True
+
+
+def NQueen(k, n):
+    for i in range(1, n + 1):
+        if isSafe(k, i):
+            x[k] = i
+
+            if k == n:
+                print(x[1:n + 1])
+            else:
+                NQueen(k + 1, n)
+
+
+# Example
+n = int(input("Enter n: "))
+x = [0] * (n + 1)
+
+NQueen(1, n)

aoalabcode/templates/Prims.txt

@@ -0,0 +1,30 @@
+def MST_Prim(G, r):
+    Q = list(G.keys())
+
+    key = {u: float('inf') for u in G}
+    pi = {u: None for u in G}
+
+    key[r] = 0
+
+    while Q:
+        u = min(Q, key=lambda x: key[x])
+        Q.remove(u)
+
+        for v, w in G[u]:
+            if v in Q and w < key[v]:
+                pi[v] = u
+                key[v] = w
+
+    return pi
+
+
+# Example
+G = {
+    0: [(1, 2), (3, 6)],
+    1: [(0, 2), (2, 3), (3, 8), (4, 5)],
+    2: [(1, 3), (4, 7)],
+    3: [(0, 6), (1, 8), (4, 9)],
+    4: [(1, 5), (2, 7), (3, 9)]
+}
+
+print(MST_Prim(G, 0))

aoalabcode/templates/QuickSort.txt

@@ -0,0 +1,28 @@
+def partition(a, low, high):
+    pivot = a[high]
+    i = low - 1
+
+    for j in range(low, high):
+        if a[j] <= pivot:
+            i += 1
+            a[i], a[j] = a[j], a[i]
+
+    a[i + 1], a[high] = a[high], a[i + 1]
+    return i + 1
+
+
+def quick_sort(a, low, high):
+    if low < high:
+        pi = partition(a, low, high)
+
+        quick_sort(a, low, pi - 1)
+        quick_sort(a, pi + 1, high)
+
+
+a = [64, 25, 12, 22, 11]
+
+quick_sort(a, 0, len(a) - 1)
+
+print("Sorted Array:")
+for i in a:
+    print(i, end=" ")

aoalabcode/templates/Rabin_Karp_Matcher.txt

@@ -0,0 +1,31 @@
+def Rabin_Karp_Matcher(T, P, d, q):
+    n = len(T)
+    m = len(P)
+
+    h = pow(d, m - 1, q)
+    p = 0
+    t0 = 0
+
+    for i in range(m):
+        p = (d * p + ord(P[i])) % q
+        t0 = (d * t0 + ord(T[i])) % q
+
+    for s in range(n - m + 1):
+        if p == t0:
+            if P == T[s:s + m]:
+                print("Pattern occurs with shift", s)
+
+        if s < n - m:
+            t0 = (d * (t0 - ord(T[s]) * h) + ord(T[s + m])) % q
+            if t0 < 0:
+                t0 += q
+
+
+# Example
+T = input("Enter text: ")
+P = input("Enter pattern: ")
+
+d = 256      # number of characters
+q = 101      # prime number
+
+Rabin_Karp_Matcher(T, P, d, q)

aoalabcode/templates/SelectionSort.txt

@@ -0,0 +1,20 @@
+def selection_sort(a):
+    n = len(a)
+
+    for i in range(n):
+        m = i
+
+        for j in range(i + 1, n):
+            if a[j] < a[m]:
+                m = j
+
+        a[i], a[m] = a[m], a[i]
+
+
+a = [64, 25, 12, 22, 11]
+
+selection_sort(a)
+
+print("Sorted Array:")
+for i in a:
+    print(i, end=" ")

aoalabcode/templates/SumOfSubsets.txt

@@ -0,0 +1,27 @@
+def promising(k, s, r):
+    return (s + r >= target) and (s == target or s + w[k + 1] <= target)
+
+
+def SumOfSubsets(k, s, r):
+    if promising(k, s, r):
+        if s == target:
+            subset = []
+            for i in range(1, len(w)):
+                if x[i] == 1:
+                    subset.append(w[i])
+            print(subset)
+        else:
+            x[k + 1] = 1
+            SumOfSubsets(k + 1, s + w[k + 1], r - w[k + 1])
+
+            x[k + 1] = 0
+            SumOfSubsets(k + 1, s, r - w[k + 1])
+
+
+# Example
+w = [0, 5, 10, 12, 13, 15, 18]  # 1-based indexing
+target = 30
+
+x = [0] * len(w)
+
+SumOfSubsets(0, 0, sum(w))

aoalabcode/templates/naive_string_matches.txt

@@ -0,0 +1,14 @@
+def string_matcher(T, P):
+    n = len(T)
+    m = len(P)
+
+    for s in range(n - m + 1):
+        if P == T[s:s + m]:
+            print("Pattern occurs with shift", s)
+
+
+# Example
+T = input("Enter text: ")
+P = input("Enter pattern: ")
+
+string_matcher(T, P)

aoalabcode-1.0.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: aoalabcode
+Version: 1.0.0
+Summary: AOA Lab code templates
+Requires-Python: >=3.8

aoalabcode-1.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+aoalabcode/__init__.py,sha256=Aj77VL1d5Mdku7sgCgKQmPuYavPpAHuZuJcy6bygQZE,21
+aoalabcode/cli.py,sha256=hsFes4O7-tCNbVcc5OG8WOxbzjIMeJqVU3EaA-01kWU,2353
+aoalabcode/templates/Bellman_Ford.txt,sha256=YJfkBURS9BdKzb4IlH9zzuXsrQ6bCllbL9tCTOnMH5s,777
+aoalabcode/templates/BinarySearch.txt,sha256=pylYjlttCCTSIFmiYnKXZXotbZ0WB9ks9qf1qGA1aCk,464
+aoalabcode/templates/Dijikstra.txt,sha256=0X3qX_FsXmY3SxM4ygbyPmAoA6rb3xYY1mPGHBtKqBo,607
+aoalabcode/templates/Floyd_Warshall.txt,sha256=G8HFIZnpoV4cfB8xvVl4yVB77gwJsxGIFnhb8OftBzo,420
+aoalabcode/templates/GraphColouring.txt,sha256=TVj27ftdieR5NbWe8otQw8cWNsC90NGHqKlijXmoY7s,566
+aoalabcode/templates/GreedyKnapsack.txt,sha256=QoPWwLbM9FGdzkl3_uclkF3L6UtAt2a8mdPagiPZRlA,568
+aoalabcode/templates/Hamiltonian.txt,sha256=aQ5tum9JlvK0uwmVu_eAgSuaAnipimbCr7nXtFin4QE,811
+aoalabcode/templates/InsertionSort.txt,sha256=T-8FHFNqr3FCQ2NUESb6J1pkxfNs66bU8tZ476etdRQ,321
+aoalabcode/templates/KMP.txt,sha256=PGYIfcYAgJJpB8Ax5h3xZPXARtPs80UWGEngZ4jPLSc,708
+aoalabcode/templates/Kruskal.txt,sha256=n2T0zyduz1e66fbXT5Ey2Mgdb3OAOAd4kvk6YcHf2o4,587
+aoalabcode/templates/LCS.txt,sha256=3F4Td4ix90QDy6Og87mIj9SRE8tnRIzJd6Vk7LgBEuQ,1040
+aoalabcode/templates/MaxMin.txt,sha256=21SzcLY5QxPpOEj8HOdeFeMyGQGxNalbHZKIorkQaKU,557
+aoalabcode/templates/MergeSort.txt,sha256=-KAeyZmH0FNpBs8rr6rA9zNidLZmesZibOfnyoXYk-E,697
+aoalabcode/templates/NQueen.txt,sha256=qhm-jvvbmMRnjYFbZiJuL6kCqjJhDyk3PxY1P_EX8M0,436
+aoalabcode/templates/Prims.txt,sha256=oiWlwnYLA5hP8fij09SVI64-zVRBHpG5zfEa4ZoYfpE,564
+aoalabcode/templates/QuickSort.txt,sha256=ORroAla6mfnig3W5NsDECcv5EXVIErPjhGWnus4lRok,539
+aoalabcode/templates/Rabin_Karp_Matcher.txt,sha256=daG8MC005EHwRhRfU2IOF5IQZhTHXIdVEeu9to_szUc,676
+aoalabcode/templates/SelectionSort.txt,sha256=AuLz9v0PAei-BwrkVwQbPyBeT-WeRH7thSnU8pSIPA4,316
+aoalabcode/templates/SumOfSubsets.txt,sha256=nQMT4nOpr1h2H5xV0RB92Zzz7Yc6r4Vm7RNvJS5p7HU,658
+aoalabcode/templates/naive_string_matches.txt,sha256=0n4UKr_E65omemL9wSO8vpSUqoFlYvROxkU6Ufl7lUI,267
+aoalabcode-1.0.0.dist-info/METADATA,sha256=nMNaSAP-ngA3I-ygfVLLw7vJEOsQWxQSniox0Z8Gr0g,114
+aoalabcode-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+aoalabcode-1.0.0.dist-info/entry_points.txt,sha256=Bk2hgwGFoITfZsUITGZknQDi9xWHGFW3Yj2e51nabC4,51
+aoalabcode-1.0.0.dist-info/top_level.txt,sha256=J_QFY2Y9cx6Ok9myhHn6D2Cr0_GPVCRbmgFrgptRvEw,11
+aoalabcode-1.0.0.dist-info/RECORD,,

aoalabcode-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aoalabcode-1.0.0.dist-info/entry_points.txt

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

aoalabcode-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aoalabcode