dancealgorithm 0.1.0__py3-none-any.whl

dancealgorithm/assignments/LC - Delivery/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+import sys
+from pathlib import Path
+from typing import Optional
+
+PATH = Path(__file__).resolve().parent
+DIR = PATH
+JAVA_SOLUTION = PATH / "Solution.java"
+DATASET_PATH = PATH / "dataset.csv"
+TITLE = "LC - Delivery"
+
+def get_code() -> str:
+    if JAVA_SOLUTION.exists():
+        return JAVA_SOLUTION.read_text(encoding="utf-8")
+    return ""
+
+def extract(destination: Optional[str | Path] = None, overwrite: bool = True) -> Path:
+    from dancealgorithm.downloader import extract_bundled
+    from dancealgorithm.config import get_destination
+    target = Path(destination) if destination else get_destination()
+    extract_bundled(target, subject_filter=TITLE, overwrite=overwrite)
+    return target / PATH.name
+
+def open_folder() -> None:
+    import os
+    if sys.platform == "win32":
+        os.system(f'explorer "{PATH}"')
+
+def __getattr__(name: str):
+    if name in ("code", "java_code", "solution_code"):
+        return get_code()
+    if name in ("path", "folder", "dir"):
+        return PATH
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

dancealgorithm/assignments/LC - Drilling/Solution.java

@@ -0,0 +1,197 @@
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// Main solution
+public class Solution {
+    // O(n! * n^2)
+    static final double INF = 1e9;
+
+    static class Hole {
+        double x, y;
+        String label;
+
+        Hole(double x, double y, String label) {
+            this.x = x;
+            this.y = y;
+            this.label = label;
+        }
+    }
+
+    // Search node
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        int[] path;
+        int level;
+        double cost;
+        int city;
+
+        Node(double[][] mat, int[] path, int level, double cost, int city) {
+            int n = mat.length;
+            this.matrix = new double[n][n];
+            for (int i = 0; i < n; i++) {
+                System.arraycopy(mat[i], 0, this.matrix[i], 0, n);
+            }
+            this.path = Arrays.copyOf(path, path.length);
+            this.level = level;
+            this.cost = cost;
+            this.city = city;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Double.compare(this.cost, other.cost);
+        }
+    }
+
+    // Matrix reduction
+    public static double reduceMatrix(double[][] mat, int n) {
+        double reduction = 0;
+
+        for (int i = 0; i < n; i++) {
+            double rmin = INF;
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] < rmin) rmin = mat[i][j];
+            }
+            if (rmin > 0 && rmin < INF) {
+                reduction += rmin;
+                for (int j = 0; j < n; j++) {
+                    if (mat[i][j] < INF) mat[i][j] -= rmin;
+                }
+            }
+        }
+
+        for (int j = 0; j < n; j++) {
+            double cmin = INF;
+            for (int i = 0; i < n; i++) {
+                if (mat[i][j] < cmin) cmin = mat[i][j];
+            }
+            if (cmin > 0 && cmin < INF) {
+                reduction += cmin;
+                for (int i = 0; i < n; i++) {
+                    if (mat[i][j] < INF) mat[i][j] -= cmin;
+                }
+            }
+        }
+
+        return reduction;
+    }
+
+    // Branch and bound TSP
+    public static void solveLCBB_TSP(double[][] costMatrix, Hole[] holes) {
+        int n = costMatrix.length;
+
+        double[][] initialMat = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            System.arraycopy(costMatrix[i], 0, initialMat[i], 0, n);
+        }
+
+        double rootCost = reduceMatrix(initialMat, n);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        int[] rootPath = {0};
+        pq.add(new Node(initialMat, rootPath, 1, rootCost, 0));
+
+        double bestCost = INF;
+        int[] bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+
+            if (curr.cost >= bestCost) {
+                continue;
+            }
+
+            if (curr.level == n) {
+                int lastCity = curr.city;
+                if (costMatrix[lastCity][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += costMatrix[curr.path[i]][curr.path[i + 1]];
+                    }
+                    tourCost += costMatrix[lastCity][0];
+
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new int[n + 1];
+                        System.arraycopy(curr.path, 0, bestTour, 0, n);
+                        bestTour[n] = 0;
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+
+            for (int v = 0; v < n; v++) {
+                boolean visited = false;
+                for (int p : curr.path) {
+                    if (p == v) { visited = true; break; }
+                }
+
+                if (!visited && curr.matrix[u][v] < INF) {
+                    double[][] childMat = new double[n][n];
+                    for (int i = 0; i < n; i++) {
+                        System.arraycopy(curr.matrix[i], 0, childMat[i], 0, n);
+                    }
+                    double edgeVal = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) childMat[u][j] = INF;
+                    for (int i = 0; i < n; i++) childMat[i][v] = INF;
+                    if (curr.level < n - 1) {
+                        childMat[v][0] = INF;
+                    }
+
+                    double reduction = reduceMatrix(childMat, n);
+                    double childCost = curr.cost + edgeVal + reduction;
+
+                    if (childCost < bestCost) {
+                        int[] childPath = Arrays.copyOf(curr.path, curr.path.length + 1);
+                        childPath[childPath.length - 1] = v;
+                        pq.add(new Node(childMat, childPath, curr.level + 1, childCost, v));
+                    }
+                }
+            }
+        }
+
+        System.out.printf("%nTotal Drill Head Travel Distance : %.2f mm%n", bestCost);
+        System.out.print("Optimal Drilling Toolpath Sequence : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(holes[bestTour[i]].label);
+                if (i < n) System.out.print(" -> ");
+            }
+        }
+        System.out.println();
+    }
+
+    // Driver code
+    public static void main(String args[]) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 24: CircuitPro PCB CNC Drilling - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        Hole holes[] = {
+            new Hole(0.0,  0.0,  "Home (0,0)"),
+            new Hole(10.0, 45.0, "Hole-1 (10,45)"),
+            new Hole(25.0, 80.0, "Hole-2 (25,80)"),
+            new Hole(60.0, 75.0, "Hole-3 (60,75)"),
+            new Hole(85.0, 30.0, "Hole-4 (85,30)"),
+            new Hole(40.0, 10.0, "Hole-5 (40,10)")
+        };
+
+        int n = holes.length;
+        double costMatrix[][] = new double[n][n];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    costMatrix[i][j] = INF;
+                } else {
+                    costMatrix[i][j] = Math.hypot(holes[i].x - holes[j].x, holes[i].y - holes[j].y);
+                }
+            }
+        }
+
+        solveLCBB_TSP(costMatrix, holes);
+    }
+}

dancealgorithm/assignments/LC - Drilling/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+import sys
+from pathlib import Path
+from typing import Optional
+
+PATH = Path(__file__).resolve().parent
+DIR = PATH
+JAVA_SOLUTION = PATH / "Solution.java"
+DATASET_PATH = PATH / "dataset.csv"
+TITLE = "LC - Drilling"
+
+def get_code() -> str:
+    if JAVA_SOLUTION.exists():
+        return JAVA_SOLUTION.read_text(encoding="utf-8")
+    return ""
+
+def extract(destination: Optional[str | Path] = None, overwrite: bool = True) -> Path:
+    from dancealgorithm.downloader import extract_bundled
+    from dancealgorithm.config import get_destination
+    target = Path(destination) if destination else get_destination()
+    extract_bundled(target, subject_filter=TITLE, overwrite=overwrite)
+    return target / PATH.name
+
+def open_folder() -> None:
+    import os
+    if sys.platform == "win32":
+        os.system(f'explorer "{PATH}"')
+
+def __getattr__(name: str):
+    if name in ("code", "java_code", "solution_code"):
+        return get_code()
+    if name in ("path", "folder", "dir"):
+        return PATH
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

dancealgorithm/assignments/LC - Flight/Solution.java

@@ -0,0 +1,180 @@
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// Main solution
+public class Solution {
+    // O(n! * n^2)
+    static final double INF = 1e9;
+
+    // Search node
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        int[] path;
+        int level;
+        double cost;
+        int city;
+
+        Node(double[][] mat, int[] path, int level, double cost, int city) {
+            int n = mat.length;
+            this.matrix = new double[n][n];
+            for (int i = 0; i < n; i++) {
+                System.arraycopy(mat[i], 0, this.matrix[i], 0, n);
+            }
+            this.path = Arrays.copyOf(path, path.length);
+            this.level = level;
+            this.cost = cost;
+            this.city = city;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Double.compare(this.cost, other.cost);
+        }
+    }
+
+    // Matrix reduction
+    public static double reduceMatrix(double[][] mat, int n) {
+        double reduction = 0;
+
+        for (int i = 0; i < n; i++) {
+            double rmin = INF;
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] < rmin) rmin = mat[i][j];
+            }
+            if (rmin > 0 && rmin < INF) {
+                reduction += rmin;
+                for (int j = 0; j < n; j++) {
+                    if (mat[i][j] < INF) mat[i][j] -= rmin;
+                }
+            }
+        }
+
+        for (int j = 0; j < n; j++) {
+            double cmin = INF;
+            for (int i = 0; i < n; i++) {
+                if (mat[i][j] < cmin) cmin = mat[i][j];
+            }
+            if (cmin > 0 && cmin < INF) {
+                reduction += cmin;
+                for (int i = 0; i < n; i++) {
+                    if (mat[i][j] < INF) mat[i][j] -= cmin;
+                }
+            }
+        }
+
+        return reduction;
+    }
+
+    // Branch and bound TSP
+    public static void solveLCBB_TSP(double[][] costMatrix, String[] airports) {
+        int n = costMatrix.length;
+
+        double[][] initialMat = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            System.arraycopy(costMatrix[i], 0, initialMat[i], 0, n);
+        }
+
+        double rootCost = reduceMatrix(initialMat, n);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        int[] rootPath = {0};
+        pq.add(new Node(initialMat, rootPath, 1, rootCost, 0));
+
+        double bestCost = INF;
+        int[] bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+
+            if (curr.cost >= bestCost) {
+                continue;
+            }
+
+            if (curr.level == n) {
+                int lastCity = curr.city;
+                if (costMatrix[lastCity][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += costMatrix[curr.path[i]][curr.path[i + 1]];
+                    }
+                    tourCost += costMatrix[lastCity][0];
+
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new int[n + 1];
+                        System.arraycopy(curr.path, 0, bestTour, 0, n);
+                        bestTour[n] = 0;
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+
+            for (int v = 0; v < n; v++) {
+                boolean visited = false;
+                for (int p : curr.path) {
+                    if (p == v) { visited = true; break; }
+                }
+
+                if (!visited && curr.matrix[u][v] < INF) {
+                    double[][] childMat = new double[n][n];
+                    for (int i = 0; i < n; i++) {
+                        System.arraycopy(curr.matrix[i], 0, childMat[i], 0, n);
+                    }
+                    double edgeVal = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) childMat[u][j] = INF;
+                    for (int i = 0; i < n; i++) childMat[i][v] = INF;
+                    if (curr.level < n - 1) {
+                        childMat[v][0] = INF;
+                    }
+
+                    double reduction = reduceMatrix(childMat, n);
+                    double childCost = curr.cost + edgeVal + reduction;
+
+                    if (childCost < bestCost) {
+                        int[] childPath = Arrays.copyOf(curr.path, curr.path.length + 1);
+                        childPath[childPath.length - 1] = v;
+                        pq.add(new Node(childMat, childPath, curr.level + 1, childCost, v));
+                    }
+                }
+            }
+        }
+
+        System.out.printf("%nTotal Operational Aircraft Fuel & Gate Cost: Rs. %.2f (Lakhs)%n", bestCost);
+        System.out.print("Optimal Aircraft Tour Circuit              : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(airports[bestTour[i]]);
+                if (i < n) System.out.print(" -> ");
+            }
+        }
+        System.out.println();
+    }
+
+    // Driver code
+    public static void main(String args[]) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 23: AeroConnect Aircraft Circuit Tour - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        String airports[] = {
+            "Delhi (DL)",
+            "Mumbai (MH)",
+            "Pune (MH)",
+            "Ahmedabad (GJ)",
+            "Bengaluru (KA)"
+        };
+
+        double costMatrix[][] = {
+            {INF, 12, 29, 45, 38},
+            {14, INF, 19, 36, 42},
+            {30, 21, INF, 18, 55},
+            {48, 38, 17, INF, 50},
+            {39, 40, 52, 49, INF}
+        };
+
+        solveLCBB_TSP(costMatrix, airports);
+    }
+}

dancealgorithm/assignments/LC - Flight/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+import sys
+from pathlib import Path
+from typing import Optional
+
+PATH = Path(__file__).resolve().parent
+DIR = PATH
+JAVA_SOLUTION = PATH / "Solution.java"
+DATASET_PATH = PATH / "dataset.csv"
+TITLE = "LC - Flight"
+
+def get_code() -> str:
+    if JAVA_SOLUTION.exists():
+        return JAVA_SOLUTION.read_text(encoding="utf-8")
+    return ""
+
+def extract(destination: Optional[str | Path] = None, overwrite: bool = True) -> Path:
+    from dancealgorithm.downloader import extract_bundled
+    from dancealgorithm.config import get_destination
+    target = Path(destination) if destination else get_destination()
+    extract_bundled(target, subject_filter=TITLE, overwrite=overwrite)
+    return target / PATH.name
+
+def open_folder() -> None:
+    import os
+    if sys.platform == "win32":
+        os.system(f'explorer "{PATH}"')
+
+def __getattr__(name: str):
+    if name in ("code", "java_code", "solution_code"):
+        return get_code()
+    if name in ("path", "folder", "dir"):
+        return PATH
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

dancealgorithm/assignments/LC.txt

@@ -0,0 +1,31 @@
+==================================================
+8. TSP – LEAST COST BRANCH AND BOUND
+==================================================
+
+ALGORITHM:
+1. Create the cost matrix and mark unavailable edges as INF.
+2. Perform row and column reduction.
+3. Calculate the initial lower bound.
+4. Insert the root node into a min-priority queue.
+5. Remove the node with minimum cost.
+6. Generate child nodes for unvisited cities.
+7. Set visited row and column values to INF.
+8. Reduce the child matrix and calculate its lower bound.
+9. Prune nodes that cannot improve the best tour.
+10. When all cities are visited, add the return cost.
+11. Display the minimum-cost tour.
+
+FORMULA:
+Child Cost = Parent Cost + Edge Cost + Reduction
+
+RECURRENCE:
+No standard recurrence. Uses state-space tree search.
+
+TIME COMPLEXITY:
+Best Case    : Depends on pruning.
+Average Case : Input-dependent.
+Worst Case   : O(n! * n^2)
+Space        : O(n! * n^2)
+
+IMPORTANT:
+1. LC Branch and Bound uses a priority queue and pruning.

dancealgorithm/assignments/MS - Commerce/Solution.java

@@ -0,0 +1,162 @@
+
+import java.util.*;
+import java.io.*;
+
+public class Solution {
+    // 1. Main Function
+    // Initially created the main function as the entry point.
+
+    public static void main(String A[]) {
+        int iSize = 0;
+
+        // 7. Main Logic
+        // Read the dataset, sort transactions and display results.
+
+        try {
+            // 7.1 Count Number of Transactions
+
+            BufferedReader bobj = new BufferedReader(new FileReader("dataset.csv"));
+
+            bobj.readLine(); // Skip header
+
+            while (bobj.readLine() != null) {
+                iSize++;
+            }
+
+            bobj.close();
+
+            // 7.2 Create Transaction Array
+
+            Transaction Arr[] = new Transaction[iSize];
+
+            // 7.3 Read Transaction Details
+
+            bobj = new BufferedReader(new FileReader("dataset.csv"));
+
+            bobj.readLine(); // Skip header
+
+            for (int iCnt = 0; iCnt < iSize; iCnt++) {
+                String sLine = bobj.readLine();
+                String sData[] = sLine.split(",", -1);
+
+                String sID = sData[0].trim().replace("\"", "");
+                String sName = sData[1].trim().replace("\"", "");
+                String sTimestamp = sData[3].trim().replace("\"", "");
+
+                Arr[iCnt] = new Transaction(sID, sName, sTimestamp);
+            }
+
+            bobj.close();
+
+            System.out.println("Loaded " + iSize + " transactions.");
+
+            // 7.4 Call Merge Sort
+
+            MergeSort(Arr, 0, iSize - 1);
+
+            // 7.5 Display Top 10 Transactions
+
+            System.out.println("\nTransactions Sorted by Purchase Timestamp:");
+
+            DisplayTop10(Arr);
+        } catch (Exception e) {
+            System.out.println("Error: " + e.getMessage());
+        }
+    }
+
+    // 2. Transaction Entity
+    // Stores transaction ID, description and purchase timestamp.
+
+    static class Transaction {
+        String sTransactionID;
+        String sDescription;
+        String sTimestamp;
+
+        Transaction(String sTransactionID, String sDescription, String sTimestamp) {
+            this.sTransactionID = sTransactionID;
+            this.sDescription = sDescription;
+            this.sTimestamp = sTimestamp;
+        }
+    }
+
+    // 3. Merge Function
+    // Combines two sorted subarrays into one sorted array.
+
+    public static void Merge(Transaction Arr[], int iStart, int iMid, int iEnd) {
+        int iSize1 = iMid - iStart + 1;
+        int iSize2 = iEnd - iMid;
+
+        Transaction LeftArr[] = new Transaction[iSize1];
+        Transaction RightArr[] = new Transaction[iSize2];
+
+        for (int iCnt = 0; iCnt < iSize1; iCnt++) {
+            LeftArr[iCnt] = Arr[iStart + iCnt];
+        }
+
+        for (int iCnt = 0; iCnt < iSize2; iCnt++) {
+            RightArr[iCnt] = Arr[iMid + 1 + iCnt];
+        }
+
+        int i = 0;
+        int j = 0;
+        int k = iStart;
+
+        while (i < iSize1 && j < iSize2) {
+            if (LeftArr[i].sTimestamp.compareTo(RightArr[j].sTimestamp) <= 0) {
+                Arr[k] = LeftArr[i];
+                i++;
+            } else {
+                Arr[k] = RightArr[j];
+                j++;
+            }
+
+            k++;
+        }
+
+        while (i < iSize1) {
+            Arr[k] = LeftArr[i];
+            i++;
+            k++;
+        }
+
+        while (j < iSize2) {
+            Arr[k] = RightArr[j];
+            j++;
+            k++;
+        }
+    }
+
+    // 4. Merge Sort Function
+    // Recursively divides the array and sorts transactions.
+
+    public static void MergeSort(Transaction Arr[], int iStart, int iEnd) {
+        if (iStart < iEnd) {
+            int iMid = iStart + (iEnd - iStart) / 2;
+
+            MergeSort(Arr, iStart, iMid);
+
+            MergeSort(Arr, iMid + 1, iEnd);
+
+            Merge(Arr, iStart, iMid, iEnd);
+        }
+    }
+
+    // 5. Display Function
+    // Displays the first 10 transactions after sorting.
+
+    public static void DisplayTop10(Transaction Arr[]) {
+        System.out.printf("%-15s %-35s %-25s%n",
+                "TX_ID", "DESCRIPTION", "TIMESTAMP");
+
+        System.out.println("--------------------------------------------------------------------------");
+
+        int iLimit = Math.min(Arr.length, 10);
+
+        for (int iCnt = 0; iCnt < iLimit; iCnt++) {
+            System.out.printf("%-15s %-35s %-25s%n",
+                    Arr[iCnt].sTransactionID,
+                    Arr[iCnt].sDescription,
+                    Arr[iCnt].sTimestamp);
+        }
+    }
+}