dancealgorithm 0.1.2__tar.gz → 0.1.4__tar.gz

{dancealgorithm-0.1.2/src/dancealgorithm.egg-info → dancealgorithm-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dancealgorithm
-Version: 0.1.2
+Version: 0.1.4
 Summary: DanceAlgorithm: Instant DAA Algorithms, Lab Problem Sheets, Datasets, and Code Vault.
 Author: DanceAlgorithm Maintainer
 License-Expression: MIT

{dancealgorithm-0.1.2 → dancealgorithm-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dancealgorithm"
-version = "0.1.2"
+version = "0.1.4"
 description = "DanceAlgorithm: Instant DAA Algorithms, Lab Problem Sheets, Datasets, and Code Vault."
 readme = "README.md"
 requires-python = ">=3.9"

{dancealgorithm-0.1.2 → dancealgorithm-0.1.4}/src/dancealgorithm/__init__.py

@@ -9,7 +9,7 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 # Import bundled assignments registry and sheets
 from dancealgorithm.assignments import ASSIGNMENTS_DIR, REGISTRY, SHEETS

dancealgorithm-0.1.4/src/dancealgorithm/assignments/LC - Delivery/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[] locations) {
+        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("%nOptimal Round-Trip Delivery Cost: Rs. %.2f%n", bestCost);
+        System.out.print("Optimal Delivery Tour Sequence  : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(locations[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 22: SwiftShip Delivery Route TSP - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        String locations[] = {
+            "Central Depot (Connaught Place)",
+            "East Hub (Anand Vihar)",
+            "North Hub (Rohini)",
+            "West Hub (Dwarka)",
+            "South Hub (Saket)"
+        };
+
+        double costMatrix[][] = {
+            {INF, 20, 30, 10, 11},
+            {15, INF, 16, 4,  2},
+            {3,  5,  INF, 2,  4},
+            {19, 6,  18, INF, 3},
+            {16, 4,  7,  16, INF}
+        };
+
+        solveLCBB_TSP(costMatrix, locations);
+    }
+}

dancealgorithm-0.1.4/src/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-0.1.4/src/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-0.1.2 → dancealgorithm-0.1.4}/src/dancealgorithm/downloader.py

@@ -15,7 +15,7 @@ import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-USER_AGENT = "DanceAlgorithm-CLI/0.1.2"
+USER_AGENT = "DanceAlgorithm-CLI/0.1.4"
 MAX_ARCHIVE_SIZE_BYTES = 300 * 1024 * 1024  # 300 MB limit
 MAX_FILE_COUNT = 10000                      # 10,000 files limit
 

{dancealgorithm-0.1.2 → dancealgorithm-0.1.4/src/dancealgorithm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dancealgorithm
-Version: 0.1.2
+Version: 0.1.4
 Summary: DanceAlgorithm: Instant DAA Algorithms, Lab Problem Sheets, Datasets, and Code Vault.
 Author: DanceAlgorithm Maintainer
 License-Expression: MIT