dancealgorithm 0.1.2__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dancealgorithm
-Version: 0.1.2
+Version: 0.1.3
 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.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dancealgorithm"
-version = "0.1.2"
+version = "0.1.3"
 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.3}/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.3"
 
 # Import bundled assignments registry and sheets
 from dancealgorithm.assignments import ASSIGNMENTS_DIR, REGISTRY, SHEETS

dancealgorithm-0.1.3/src/dancealgorithm/assignments/LC - Delivery/Solution.java

@@ -0,0 +1,152 @@
+import java.util.*;
+
+public class Solution {
+    static final double INF = 1e9;
+
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        List<Integer> path;
+        double cost;
+        int city, level;
+
+        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
+            this.matrix = copy(m);
+            this.path = new ArrayList<>(p);
+            this.path.add(city);
+            this.city = city;
+            this.level = level;
+            this.cost = cost;
+        }
+
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
+        }
+    }
+
+    static double[][] copy(double[][] m) {
+        double[][] res = new double[m.length][m.length];
+        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
+        return res;
+    }
+
+    static double reduce(double[][] m) {
+        int n = m.length;
+        double reduction = 0;
+
+        // Row reduction
+        for (int i = 0; i < n; i++) {
+            double min = INF;
+            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+
+        // Column reduction
+        for (int j = 0; j < n; j++) {
+            double min = INF;
+            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+        return reduction;
+    }
+
+    static void solveTSP(double[][] graph, String[] locations) {
+        int n = graph.length;
+        double[][] initial = copy(graph);
+        double rootCost = reduce(initial);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
+
+        double bestCost = INF;
+        List<Integer> bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+            if (curr.cost >= bestCost) continue;
+
+            if (curr.level == n) {
+                int last = curr.city;
+                if (graph[last][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
+                    }
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+            for (int v = 0; v < n; v++) {
+                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
+                    double[][] child = copy(curr.matrix);
+                    double edge = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) child[u][j] = INF;
+                    for (int i = 0; i < n; i++) child[i][v] = INF;
+                    if (curr.level < n - 1) child[v][0] = INF;
+
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
+                    }
+                }
+            }
+        }
+
+        if (bestTour == null) {
+            System.out.println("\nNo complete round-trip route exists.");
+            return;
+        }
+
+        System.out.printf("\nOptimal Round-Trip Delivery Cost: Rs. %.2f\n", bestCost);
+        System.out.print("Optimal Delivery Tour: ");
+        for (int i = 0; i < bestTour.size(); i++) {
+            System.out.print(locations[bestTour.get(i)] + (i < bestTour.size() - 1 ? " -> " : "\n"));
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter number of locations: ");
+        int n = sc.nextInt();
+        sc.nextLine();
+
+        String[] locations = new String[n];
+        for (int i = 0; i < n; i++) {
+            System.out.print("Enter location " + (i + 1) + ": ");
+            locations[i] = sc.nextLine().trim();
+        }
+
+        double[][] graph = new double[n][n];
+        System.out.println("\nEnter travel cost matrix:");
+        System.out.println("Enter -1 if there is no direct route.");
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    graph[i][j] = INF;
+                } else {
+                    System.out.print("Cost from " + locations[i] + " to " + locations[j] + ": ");
+                    double val = sc.nextDouble();
+                    graph[i][j] = (val == -1) ? INF : val;
+                }
+            }
+        }
+
+        solveTSP(graph, locations);
+        sc.close();
+    }
+}

dancealgorithm-0.1.3/src/dancealgorithm/assignments/LC - Drilling/Solution.java

@@ -0,0 +1,164 @@
+import java.util.*;
+
+public class Solution {
+    static final double INF = 1e9;
+
+    static class Hole {
+        String name;
+        double x, y;
+        Hole(String name, double x, double y) {
+            this.name = name;
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        List<Integer> path;
+        double cost;
+        int city, level;
+
+        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
+            this.matrix = copy(m);
+            this.path = new ArrayList<>(p);
+            this.path.add(city);
+            this.city = city;
+            this.level = level;
+            this.cost = cost;
+        }
+
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
+        }
+    }
+
+    static double[][] copy(double[][] m) {
+        double[][] res = new double[m.length][m.length];
+        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
+        return res;
+    }
+
+    static double reduce(double[][] m) {
+        int n = m.length;
+        double reduction = 0;
+
+        // Row reduction
+        for (int i = 0; i < n; i++) {
+            double min = INF;
+            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+
+        // Column reduction
+        for (int j = 0; j < n; j++) {
+            double min = INF;
+            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+        return reduction;
+    }
+
+    static void solveTSP(double[][] graph, Hole[] holes) {
+        int n = graph.length;
+        double[][] initial = copy(graph);
+        double rootCost = reduce(initial);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
+
+        double bestCost = INF;
+        List<Integer> bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+            if (curr.cost >= bestCost) continue;
+
+            if (curr.level == n) {
+                int last = curr.city;
+                if (graph[last][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
+                    }
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+            for (int v = 0; v < n; v++) {
+                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
+                    double[][] child = copy(curr.matrix);
+                    double edge = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) child[u][j] = INF;
+                    for (int i = 0; i < n; i++) child[i][v] = INF;
+                    if (curr.level < n - 1) child[v][0] = INF;
+
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
+                    }
+                }
+            }
+        }
+
+        if (bestTour == null) {
+            System.out.println("\nNo complete drilling tour exists.");
+            return;
+        }
+
+        System.out.printf("\nTotal Drill Head Travel Distance: %.2f mm\n", bestCost);
+        System.out.print("Optimal Drilling Toolpath: ");
+        for (int i = 0; i < bestTour.size(); i++) {
+            System.out.print(holes[bestTour.get(i)].name + (i < bestTour.size() - 1 ? " -> " : "\n"));
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter number of drilling points (including Home): ");
+        int n = sc.nextInt();
+        sc.nextLine();
+
+        Hole[] holes = new Hole[n];
+        for (int i = 0; i < n; i++) {
+            System.out.println("\nEnter details for Point " + i);
+            System.out.print("Point Name: ");
+            String name = sc.nextLine().trim();
+            System.out.print("X Coordinate: ");
+            double x = sc.nextDouble();
+            System.out.print("Y Coordinate: ");
+            double y = sc.nextDouble();
+            sc.nextLine();
+            holes[i] = new Hole(name, x, y);
+        }
+
+        double[][] graph = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    graph[i][j] = INF;
+                } else {
+                    graph[i][j] = Math.hypot(holes[i].x - holes[j].x, holes[i].y - holes[j].y);
+                }
+            }
+        }
+
+        solveTSP(graph, holes);
+        sc.close();
+    }
+}

dancealgorithm-0.1.3/src/dancealgorithm/assignments/LC - Flight/Solution.java

@@ -0,0 +1,152 @@
+import java.util.*;
+
+public class Solution {
+    static final double INF = 1e9;
+
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        List<Integer> path;
+        double cost;
+        int city, level;
+
+        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
+            this.matrix = copy(m);
+            this.path = new ArrayList<>(p);
+            this.path.add(city);
+            this.city = city;
+            this.level = level;
+            this.cost = cost;
+        }
+
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
+        }
+    }
+
+    static double[][] copy(double[][] m) {
+        double[][] res = new double[m.length][m.length];
+        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
+        return res;
+    }
+
+    static double reduce(double[][] m) {
+        int n = m.length;
+        double reduction = 0;
+
+        // Row reduction
+        for (int i = 0; i < n; i++) {
+            double min = INF;
+            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+
+        // Column reduction
+        for (int j = 0; j < n; j++) {
+            double min = INF;
+            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
+            if (min > 0 && min < INF) {
+                reduction += min;
+                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
+            }
+        }
+        return reduction;
+    }
+
+    static void solveTSP(double[][] graph, String[] airports) {
+        int n = graph.length;
+        double[][] initial = copy(graph);
+        double rootCost = reduce(initial);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
+
+        double bestCost = INF;
+        List<Integer> bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+            if (curr.cost >= bestCost) continue;
+
+            if (curr.level == n) {
+                int last = curr.city;
+                if (graph[last][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
+                    }
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+            for (int v = 0; v < n; v++) {
+                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
+                    double[][] child = copy(curr.matrix);
+                    double edge = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) child[u][j] = INF;
+                    for (int i = 0; i < n; i++) child[i][v] = INF;
+                    if (curr.level < n - 1) child[v][0] = INF;
+
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
+                    }
+                }
+            }
+        }
+
+        if (bestTour == null) {
+            System.out.println("\nNo complete round-trip flight route exists.");
+            return;
+        }
+
+        System.out.printf("\nMinimum Total Aircraft Operational Cost: Rs. %.2f Lakhs\n", bestCost);
+        System.out.print("Optimal Flight Tour: ");
+        for (int i = 0; i < bestTour.size(); i++) {
+            System.out.print(airports[bestTour.get(i)] + (i < bestTour.size() - 1 ? " -> " : "\n"));
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter number of airports: ");
+        int n = sc.nextInt();
+        sc.nextLine();
+
+        String[] airports = new String[n];
+        for (int i = 0; i < n; i++) {
+            System.out.print("Enter airport " + (i + 1) + ": ");
+            airports[i] = sc.nextLine().trim();
+        }
+
+        double[][] graph = new double[n][n];
+        System.out.println("\nEnter flight operational cost matrix:");
+        System.out.println("Enter -1 if no direct flight exists.");
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    graph[i][j] = INF;
+                } else {
+                    System.out.print("Cost from " + airports[i] + " to " + airports[j] + ": ");
+                    double val = sc.nextDouble();
+                    graph[i][j] = (val == -1) ? INF : val;
+                }
+            }
+        }
+
+        solveTSP(graph, airports);
+        sc.close();
+    }
+}

{dancealgorithm-0.1.2 → dancealgorithm-0.1.3}/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.3"
 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.3/src/dancealgorithm.egg-info}/PKG-INFO

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