dancealgorithm 0.1.0__py3-none-any.whl

dancealgorithm/assignments/K - Cloud/Solution.java

@@ -0,0 +1,115 @@
+
+import java.util.*;
+
+public class Solution {
+    // 1. Main Function
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter server RAM capacity (GB): ");
+        int iCapacity = sc.nextInt();
+
+        System.out.print("Enter number of VM requests: ");
+        int iSize = sc.nextInt();
+
+        VirtualMachine vms[] = new VirtualMachine[iSize];
+
+        // 2. Get Virtual Machine Details
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            sc.nextLine();
+
+            System.out.println("\nEnter details for VM " + (iCnt + 1));
+
+            System.out.print("Instance Type: ");
+            String sType = sc.nextLine();
+
+            System.out.print("RAM Required (GB): ");
+            int iRAM = sc.nextInt();
+
+            System.out.print("Monthly Revenue ($): ");
+            int iRevenue = sc.nextInt();
+
+            vms[iCnt] = new VirtualMachine(sType, iRAM, iRevenue);
+        }
+
+        // 3. Apply Knapsack Algorithm
+        Knapsack(vms, iCapacity);
+
+        sc.close();
+    }
+
+    // 4. Virtual Machine Entity
+    static class VirtualMachine {
+        String sType;
+        int iRAM, iRevenue;
+
+        VirtualMachine(String sType, int iRAM, int iRevenue) {
+            this.sType = sType;
+            this.iRAM = iRAM;
+            this.iRevenue = iRevenue;
+        }
+    }
+
+    // 5. Knapsack Dynamic Programming
+    static void Knapsack(VirtualMachine vms[], int iCapacity) {
+        int iSize = vms.length;
+        int iDP[][] = new int[iSize + 1][iCapacity + 1];
+
+        // 6. Calculate Maximum Revenue
+        for (int iCnt = 1; iCnt <= iSize; iCnt++) {
+            for (int iW = 1; iW <= iCapacity; iW++) {
+                if (vms[iCnt - 1].iRAM <= iW) {
+                    iDP[iCnt][iW] = Math.max(
+                            vms[iCnt - 1].iRevenue +
+                                    iDP[iCnt - 1][iW - vms[iCnt - 1].iRAM],
+
+                            iDP[iCnt - 1][iW]);
+                } else {
+                    iDP[iCnt][iW] = iDP[iCnt - 1][iW];
+                }
+            }
+        }
+
+        // 7. Find Selected Virtual Machines
+        boolean bSelected[] = new boolean[iSize];
+        int iW = iCapacity;
+
+        for (int iCnt = iSize; iCnt > 0; iCnt--) {
+            if (iDP[iCnt][iW] != iDP[iCnt - 1][iW]) {
+                bSelected[iCnt - 1] = true;
+                iW -= vms[iCnt - 1].iRAM;
+            }
+        }
+
+        // 8. Display Selected Virtual Machines
+        int iTotalRAM = 0;
+
+        System.out.println("\nCloud Server Virtual Machine Allocation:");
+        System.out.println("---------------------------------------------------------------");
+
+        System.out.printf("%-28s %-12s %-15s%n",
+                "VM Instance Type", "RAM (GB)", "Revenue ($/mo)");
+
+        System.out.println("---------------------------------------------------------------");
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            if (bSelected[iCnt]) {
+                System.out.printf("%-28s %-12d %-15d%n",
+                        vms[iCnt].sType,
+                        vms[iCnt].iRAM,
+                        vms[iCnt].iRevenue);
+
+                iTotalRAM += vms[iCnt].iRAM;
+            }
+        }
+
+        System.out.println("---------------------------------------------------------------");
+        System.out.println("Total RAM Provisioned: " +
+                iTotalRAM + " GB / " + iCapacity + " GB");
+
+        System.out.println("Maximum Monthly Revenue: $" +
+                iDP[iSize][iCapacity]);
+
+        System.out.println("---------------------------------------------------------------");
+    }
+}

dancealgorithm/assignments/K - Cloud/__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 = "K - Cloud"
+
+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/K - Disaster/Solution.java

@@ -0,0 +1,116 @@
+
+import java.util.*;
+
+// 1. Main Function
+public class Solution {
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+
+        // 2. Get Truck Capacity
+        System.out.print("Enter truck capacity (kg): ");
+        int iCapacity = sc.nextInt();
+
+        System.out.print("Enter number of relief items: ");
+        int iSize = sc.nextInt();
+
+        ReliefSupply items[] = new ReliefSupply[iSize];
+
+        // 3. Get Item Details
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            sc.nextLine();
+
+            System.out.println("\nEnter details for Item " + (iCnt + 1));
+
+            System.out.print("Item Name: ");
+            String sName = sc.nextLine();
+
+            System.out.print("Weight (kg): ");
+            int iWeight = sc.nextInt();
+
+            System.out.print("Utility Value: ");
+            int iValue = sc.nextInt();
+
+            items[iCnt] = new ReliefSupply(sName, iWeight, iValue);
+        }
+
+        // 4. Apply Knapsack Algorithm
+        Knapsack(items, iCapacity);
+
+        sc.close();
+    }
+
+    // 5. Relief Supply Entity
+    static class ReliefSupply {
+        String sName;
+        int iWeight, iValue;
+
+        ReliefSupply(String sName, int iWeight, int iValue) {
+            this.sName = sName;
+            this.iWeight = iWeight;
+            this.iValue = iValue;
+        }
+    }
+
+    // 6. Knapsack Dynamic Programming
+    static void Knapsack(ReliefSupply items[], int iCapacity) {
+        int iSize = items.length;
+        int iDP[][] = new int[iSize + 1][iCapacity + 1];
+
+        // 7. Calculate Maximum Utility
+        for (int iCnt = 1; iCnt <= iSize; iCnt++) {
+            for (int iW = 1; iW <= iCapacity; iW++) {
+                if (items[iCnt - 1].iWeight <= iW) {
+                    iDP[iCnt][iW] = Math.max(
+                            items[iCnt - 1].iValue +
+                                    iDP[iCnt - 1][iW - items[iCnt - 1].iWeight],
+
+                            iDP[iCnt - 1][iW]);
+                } else {
+                    iDP[iCnt][iW] = iDP[iCnt - 1][iW];
+                }
+            }
+        }
+
+        // 8. Find Selected Items
+        boolean bSelected[] = new boolean[iSize];
+        int iW = iCapacity;
+
+        for (int iCnt = iSize; iCnt > 0; iCnt--) {
+            if (iDP[iCnt][iW] != iDP[iCnt - 1][iW]) {
+                bSelected[iCnt - 1] = true;
+                iW -= items[iCnt - 1].iWeight;
+            }
+        }
+
+        // 9. Display Selected Supplies
+        int iTotalWeight = 0;
+
+        System.out.println("\nDisaster Relief Supply Allocation:");
+        System.out.println("-------------------------------------------------------------");
+
+        System.out.printf("%-26s %-15s %-15s%n",
+                "Supply Item", "Weight (kg)", "Utility Value");
+
+        System.out.println("-------------------------------------------------------------");
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            if (bSelected[iCnt]) {
+                System.out.printf("%-26s %-15d %-15d%n",
+                        items[iCnt].sName,
+                        items[iCnt].iWeight,
+                        items[iCnt].iValue);
+
+                iTotalWeight += items[iCnt].iWeight;
+            }
+        }
+
+        System.out.println("-------------------------------------------------------------");
+        System.out.println("Total Weight: " + iTotalWeight +
+                " kg / " + iCapacity + " kg");
+
+        System.out.println("Maximum Utility: " +
+                iDP[iSize][iCapacity] + " points");
+
+        System.out.println("-------------------------------------------------------------");
+    }
+}

dancealgorithm/assignments/K - Disaster/__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 = "K - Disaster"
+
+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/K - Hospital/Solution.java

@@ -0,0 +1,115 @@
+
+import java.util.*;
+
+public class Solution {
+    // 1. Main Function
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter backup generator capacity (Watts): ");
+        int iCapacity = sc.nextInt();
+
+        System.out.print("Enter number of medical devices: ");
+        int iSize = sc.nextInt();
+
+        MedicalDevice devices[] = new MedicalDevice[iSize];
+
+        // 2. Get Medical Device Details
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            sc.nextLine();
+
+            System.out.println("\nEnter details for Device " + (iCnt + 1));
+
+            System.out.print("Device Name: ");
+            String sName = sc.nextLine();
+
+            System.out.print("Power Requirement (Watts): ");
+            int iPower = sc.nextInt();
+
+            System.out.print("Critical Score: ");
+            int iScore = sc.nextInt();
+
+            devices[iCnt] = new MedicalDevice(sName, iPower, iScore);
+        }
+
+        // 3. Apply Knapsack Algorithm
+        Knapsack(devices, iCapacity);
+
+        sc.close();
+    }
+
+    // 4. Medical Device Entity
+    static class MedicalDevice {
+        String sName;
+        int iPower, iScore;
+
+        MedicalDevice(String sName, int iPower, int iScore) {
+            this.sName = sName;
+            this.iPower = iPower;
+            this.iScore = iScore;
+        }
+    }
+
+    // 5. Knapsack Dynamic Programming
+    static void Knapsack(MedicalDevice devices[], int iCapacity) {
+        int iSize = devices.length;
+        int iDP[][] = new int[iSize + 1][iCapacity + 1];
+
+        // 6. Calculate Maximum Critical Score
+        for (int iCnt = 1; iCnt <= iSize; iCnt++) {
+            for (int iW = 1; iW <= iCapacity; iW++) {
+                if (devices[iCnt - 1].iPower <= iW) {
+                    iDP[iCnt][iW] = Math.max(
+                            devices[iCnt - 1].iScore +
+                                    iDP[iCnt - 1][iW - devices[iCnt - 1].iPower],
+
+                            iDP[iCnt - 1][iW]);
+                } else {
+                    iDP[iCnt][iW] = iDP[iCnt - 1][iW];
+                }
+            }
+        }
+
+        // 7. Find Selected Medical Devices
+        boolean bSelected[] = new boolean[iSize];
+        int iW = iCapacity;
+
+        for (int iCnt = iSize; iCnt > 0; iCnt--) {
+            if (iDP[iCnt][iW] != iDP[iCnt - 1][iW]) {
+                bSelected[iCnt - 1] = true;
+                iW -= devices[iCnt - 1].iPower;
+            }
+        }
+
+        // 8. Display Selected Equipment
+        int iTotalPower = 0;
+
+        System.out.println("\nHospital Emergency ICU Equipment Allocation:");
+        System.out.println("---------------------------------------------------------------");
+
+        System.out.printf("%-30s %-15s %-15s%n",
+                "Medical Equipment", "Power (W)", "Critical Score");
+
+        System.out.println("---------------------------------------------------------------");
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            if (bSelected[iCnt]) {
+                System.out.printf("%-30s %-15d %-15d%n",
+                        devices[iCnt].sName,
+                        devices[iCnt].iPower,
+                        devices[iCnt].iScore);
+
+                iTotalPower += devices[iCnt].iPower;
+            }
+        }
+
+        System.out.println("---------------------------------------------------------------");
+        System.out.println("Total Power Consumed: " +
+                iTotalPower + " W / " + iCapacity + " W");
+
+        System.out.println("Maximum Critical Score: " +
+                iDP[iSize][iCapacity] + " points");
+
+        System.out.println("---------------------------------------------------------------");
+    }
+}

dancealgorithm/assignments/K - Hospital/__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 = "K - Hospital"
+
+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/K.txt

@@ -0,0 +1,38 @@
+==================================================
+6. 0/1 KNAPSACK (DYNAMIC PROGRAMMING)
+==================================================
+
+ALGORITHM:
+1. Read the weight and profit of each item.
+2. Create DP table of size (n+1) x (W+1).
+3. Initialize the first row and column with zero.
+4. Check whether the current item fits.
+5. If it fits, calculate inclusion and exclusion values.
+6. Store the maximum of both values.
+7. Otherwise, copy the previous row value.
+8. Find maximum profit from dp[n][W].
+9. Backtrack to find selected items.
+
+RECURRENCE RELATION:
+
+If w[i] <= w:
+
+V(i,w) = max { V(i-1,w),
+               V(i-1,w-w[i]) + P[i] }
+
+If w[i] > w:
+
+V(i,w) = V(i-1,w)
+
+BASE CONDITIONS:
+V(0,w) = 0
+V(i,0) = 0
+
+TIME COMPLEXITY:
+Best Case    : O(nW)
+Average Case : O(nW)
+Worst Case   : O(nW)
+Space        : O(nW)
+
+IMPORTANT:
+1. 0/1 Knapsack does not allow fractions of items.

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);
+    }
+}