dancealgorithm 0.1.0__py3-none-any.whl

dancealgorithm/assignments/DA - Smart/Solution.java

@@ -0,0 +1,220 @@
+
+import java.util.*;
+
+// 1. Main Function
+public class Solution {
+    static final double INF = 999999;
+
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+
+        int iSize = 9;
+
+        String sNames[] = {
+                "Delhi (Ambulance)",
+                "Noida",
+                "Ghaziabad",
+                "Gurugram",
+                "Faridabad",
+                "Meerut",
+                "AIIMS Hospital",
+                "Safdarjung Hospital",
+                "Apollo Hospital"
+        };
+
+        // 2. Create Adjacency Matrix
+        double dGraph[][] = new double[iSize][iSize];
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            Arrays.fill(dGraph[iCnt], INF);
+            dGraph[iCnt][iCnt] = 0;
+        }
+
+        // 3. Add Roads and Travel Times
+        dGraph[0][1] = dGraph[1][0] = 4;
+        dGraph[0][2] = dGraph[2][0] = 2;
+        dGraph[1][3] = dGraph[3][1] = 5;
+        dGraph[2][1] = dGraph[1][2] = 1;
+        dGraph[2][4] = dGraph[4][2] = 8;
+        dGraph[2][3] = dGraph[3][2] = 7;
+        dGraph[3][5] = dGraph[5][3] = 3;
+        dGraph[4][5] = dGraph[5][4] = 2;
+        dGraph[3][6] = dGraph[6][3] = 6;
+        dGraph[5][7] = dGraph[7][5] = 4;
+        dGraph[5][8] = dGraph[8][5] = 5.5;
+
+        // 4. Display Locations
+        System.out.println("\nAvailable Locations:");
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            System.out.println(iCnt + " : " + sNames[iCnt]);
+        }
+
+        // 5. Get Source and Destination
+        System.out.print("\nEnter Ambulance Location: ");
+        String sSource = sc.nextLine();
+
+        System.out.print("Enter Destination Hospital: ");
+        String sDestination = sc.nextLine();
+
+        int iSource = findLocationIndex(sSource, sNames, iSize);
+        int iDestination = findLocationIndex(sDestination, sNames, iSize);
+
+        if (iSource == -1 || iDestination == -1) {
+            System.out.println("Invalid Location!");
+            sc.close();
+            return;
+        }
+
+        // 6. Apply Dijkstra Algorithm
+        Dijkstra(dGraph, iSource, iSize, sNames);
+
+        sc.close();
+    }
+
+    // 7. Find Minimum Distance Vertex
+    static int MinDistance(double dDist[], boolean bVisited[], int iSize) {
+        double dMin = INF;
+        int iMinIndex = -1;
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            if (!bVisited[iCnt] && dDist[iCnt] < dMin) {
+                dMin = dDist[iCnt];
+                iMinIndex = iCnt;
+            }
+        }
+
+        return iMinIndex;
+    }
+
+    // 8. Print Shortest Path
+    static void PrintPath(int iPrev[], int iTarget, String sNames[]) {
+        if (iPrev[iTarget] != -1) {
+            PrintPath(iPrev, iPrev[iTarget], sNames);
+            System.out.print(" -> ");
+        }
+
+        System.out.print(sNames[iTarget]);
+    }
+
+    // 9. Dijkstra Function
+    static void Dijkstra(double dGraph[][], int iSource, int iSize, String sNames[]) {
+        double dDist[] = new double[iSize];
+        boolean bVisited[] = new boolean[iSize];
+        int iPrev[] = new int[iSize];
+
+        Arrays.fill(dDist, INF);
+        Arrays.fill(iPrev, -1);
+
+        dDist[iSource] = 0;
+
+        for (int iCnt = 0; iCnt < iSize - 1; iCnt++) {
+            int iU = MinDistance(dDist, bVisited, iSize);
+
+            if (iU == -1) {
+                break;
+            }
+
+            bVisited[iU] = true;
+
+            for (int iV = 0; iV < iSize; iV++) {
+                if (!bVisited[iV] &&
+                        dGraph[iU][iV] != INF &&
+                        dDist[iU] + dGraph[iU][iV] < dDist[iV]) {
+                    dDist[iV] = dDist[iU] + dGraph[iU][iV];
+                    iPrev[iV] = iU;
+                }
+            }
+        }
+
+        // 10. Display Shortest Routes
+        System.out.println("\nShortest Routes from Ambulance:");
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            System.out.print("\n" + sNames[iCnt] + " : ");
+
+            if (dDist[iCnt] == INF) {
+                System.out.println("Unreachable");
+            } else {
+                System.out.printf("%.2f minutes | Route: ", dDist[iCnt]);
+                PrintPath(iPrev, iCnt, sNames);
+                System.out.println();
+            }
+        }
+
+        // 11. Find Nearest Hospital
+        int iHospitals[] = { 6, 7, 8 };
+        int iBestHospital = -1;
+        double dMinTime = INF;
+
+        for (int iCnt = 0; iCnt < iHospitals.length; iCnt++) {
+            int iH = iHospitals[iCnt];
+
+            if (dDist[iH] < dMinTime) {
+                dMinTime = dDist[iH];
+                iBestHospital = iH;
+            }
+        }
+
+        System.out.println("\n--------------------------------------");
+
+        if (iBestHospital != -1) {
+            System.out.println("Nearest Hospital: " + sNames[iBestHospital]);
+            System.out.printf("Minimum Travel Time: %.2f minutes%n", dMinTime);
+        } else {
+            System.out.println("No reachable hospital found.");
+        }
+
+        System.out.println("--------------------------------------");
+    }
+
+    // Helper to resolve location by name, index, or "index : name"
+    static int findLocationIndex(String sInput, String sNames[], int iSize) {
+        if (sInput == null) {
+            return -1;
+        }
+        sInput = sInput.trim();
+        if (sInput.isEmpty()) {
+            return -1;
+        }
+
+        if (sInput.contains(":")) {
+            String parts[] = sInput.split(":", 2);
+            int idx = findLocationIndex(parts[0], sNames, iSize);
+            if (idx != -1) return idx;
+            idx = findLocationIndex(parts[1], sNames, iSize);
+            if (idx != -1) return idx;
+        }
+
+        if (sInput.contains("-")) {
+            String parts[] = sInput.split("-", 2);
+            int idx = findLocationIndex(parts[0], sNames, iSize);
+            if (idx != -1) return idx;
+            idx = findLocationIndex(parts[1], sNames, iSize);
+            if (idx != -1) return idx;
+        }
+
+        try {
+            int idx = Integer.parseInt(sInput);
+            if (idx >= 0 && idx < iSize) {
+                return idx;
+            }
+        } catch (NumberFormatException ignored) {
+        }
+
+        for (int i = 0; i < iSize; i++) {
+            if (sNames[i].equalsIgnoreCase(sInput)) {
+                return i;
+            }
+        }
+
+        for (int i = 0; i < iSize; i++) {
+            if (sInput.toLowerCase().contains(sNames[i].toLowerCase()) ||
+                sNames[i].toLowerCase().contains(sInput.toLowerCase())) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}

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

@@ -0,0 +1,29 @@
+==================================================
+4. DIJKSTRA'S ALGORITHM
+==================================================
+
+ALGORITHM:
+1. Initialize all distances to INF.
+2. Set source distance = 0.
+3. Mark all vertices as unvisited.
+4. Select the unvisited vertex with minimum distance.
+5. Mark the selected vertex as visited.
+6. Check all adjacent vertices.
+7. Update distance if a shorter path is found.
+8. Repeat until all reachable vertices are processed.
+9. Use prev[] to reconstruct the shortest path.
+
+FORMULA:
+dist[v] = min(dist[v], dist[u] + weight[u][v])
+
+RECURRENCE:
+Not recursive. Uses Greedy technique.
+
+TIME COMPLEXITY (ADJACENCY MATRIX):
+Best Case    : O(V^2)
+Average Case : O(V^2)
+Worst Case   : O(V^2)
+Space        : O(V) auxiliary space
+
+IMPORTANT:
+1. Dijkstra requires non-negative edge weights.

dancealgorithm/assignments/FK - Advertisement/Solution.java

@@ -0,0 +1,141 @@
+
+import java.util.*;
+
+// 1. Main Function
+public class Solution
+{
+    public static void main(String args[])
+    {
+        Scanner sc = new Scanner(System.in);
+
+        System.out.print("Enter total commercial airtime (minutes): ");
+        double dCapacity = sc.nextDouble();
+
+        System.out.print("Enter number of ad requests: ");
+        int iSize = sc.nextInt();
+
+        AdRequest ads[] = new AdRequest[iSize];
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++)
+        {
+            sc.nextLine();
+
+            System.out.println("\nEnter details for Ad " + (iCnt + 1));
+
+            System.out.print("Campaign Name: ");
+            String sName = sc.nextLine();
+
+            System.out.print("Duration (minutes): ");
+            double dDuration = sc.nextDouble();
+
+            System.out.print("Revenue (Rs.): ");
+            double dRevenue = sc.nextDouble();
+
+            System.out.print("Divisible? (1 = Yes, 0 = No): ");
+            int iChoice = sc.nextInt();
+
+            ads[iCnt] = new AdRequest(sName, dDuration, dRevenue, iChoice == 1);
+        }
+
+        Sort(ads, iSize);
+        AllocateAdSlots(ads, dCapacity);
+
+        sc.close();
+    }
+
+    // 2. Ad Request Entity
+    static class AdRequest
+    {
+        String sName;
+        double dDuration, dRevenue, dRatio;
+        boolean bDivisible;
+
+        AdRequest(String sName, double dDuration, double dRevenue, boolean bDivisible)
+        {
+            this.sName = sName;
+            this.dDuration = dDuration;
+            this.dRevenue = dRevenue;
+            this.dRatio = dRevenue / dDuration;
+            this.bDivisible = bDivisible;
+        }
+    }
+
+    // 3. Swap Function
+    static void Swap(AdRequest ads[], int i, int j)
+    {
+        AdRequest temp = ads[i];
+        ads[i] = ads[j];
+        ads[j] = temp;
+    }
+
+    // 4. Sort Function - Descending Order of Revenue/Duration
+    static void Sort(AdRequest ads[], int iSize)
+    {
+        for (int iCnt = 0; iCnt < iSize - 1; iCnt++)
+        {
+            for (int j = 0; j < iSize - iCnt - 1; j++)
+            {
+                if (ads[j].dRatio < ads[j + 1].dRatio)
+                {
+                    Swap(ads, j, j + 1);
+                }
+            }
+        }
+    }
+
+    // 5. Allocate Advertisement Slots
+    static void AllocateAdSlots(AdRequest ads[], double dCapacity)
+    {
+        double dTotalRevenue = 0;
+        double dAllocatedTime = 0;
+
+        System.out.println("\nAdvertisement Slot Allocation:");
+
+        System.out.printf("%-22s %-15s %-15s %-15s%n",
+                "Campaign", "Duration", "Revenue", "Airtime Taken");
+
+        for (int iCnt = 0; iCnt < ads.length; iCnt++)
+        {
+            if (dCapacity <= 0)
+            {
+                break;
+            }
+
+            if (ads[iCnt].dDuration <= dCapacity)
+            {
+                dCapacity -= ads[iCnt].dDuration;
+                dAllocatedTime += ads[iCnt].dDuration;
+                dTotalRevenue += ads[iCnt].dRevenue;
+
+                System.out.printf("%-22s %-15.2f %-15.2f 100%%%n",
+                        ads[iCnt].sName,
+                        ads[iCnt].dDuration,
+                        ads[iCnt].dRevenue);
+            }
+            else if (ads[iCnt].bDivisible)
+            {
+                double dFraction = dCapacity / ads[iCnt].dDuration;
+                double dPartialRevenue = dFraction * ads[iCnt].dRevenue;
+
+                dAllocatedTime += dCapacity;
+                dTotalRevenue += dPartialRevenue;
+
+                System.out.printf("%-22s %-15.2f %-15.2f %.2f%%%n",
+                        ads[iCnt].sName,
+                        dCapacity,
+                        dPartialRevenue,
+                        dFraction * 100);
+
+                dCapacity = 0;
+            }
+            else
+            {
+                System.out.println(ads[iCnt].sName + " skipped (Indivisible)");
+            }
+        }
+
+        System.out.println("-----------------------------------------------");
+        System.out.printf("Total Airtime Used: %.2f minutes%n", dAllocatedTime);
+        System.out.printf("Total Revenue: Rs. %.2f%n", dTotalRevenue);
+    }
+}

dancealgorithm/assignments/FK - Advertisement/__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 = "FK - Advertisement"
+
+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/FK - Electric/Solution.java

@@ -0,0 +1,168 @@
+
+import java.util.*;
+
+// 1. Main Class
+
+class Solution {
+    // 2. Main Function
+
+    public static void main(String A[]) {
+        Scanner sobj = new Scanner(System.in);
+
+        double dCapacity;
+        int iSize;
+
+        // 6. Accept Total Energy Capacity
+
+        System.out.print("Enter total grid capacity (kWh): ");
+        dCapacity = sobj.nextDouble();
+
+        // 7. Accept Number of EV Requests
+
+        System.out.print("Enter number of EV requests: ");
+        iSize = sobj.nextInt();
+
+        EVRequest Arr[] = new EVRequest[iSize];
+
+        // 8. Accept EV Request Details
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            String sVehicleID;
+            double dEnergy;
+            double dRevenue;
+            int iChoice;
+
+            System.out.println("\nEnter details of vehicle " + (iCnt + 1));
+
+            System.out.print("Vehicle ID / Model: ");
+            sVehicleID = sobj.next();
+
+            System.out.print("Energy required (kWh): ");
+            dEnergy = sobj.nextDouble();
+
+            System.out.print("Revenue (Rs.): ");
+            dRevenue = sobj.nextDouble();
+
+            System.out.print("Divisible? (1 = Yes, 0 = No): ");
+            iChoice = sobj.nextInt();
+
+            Arr[iCnt] = new EVRequest(sVehicleID, dEnergy, dRevenue, iChoice == 1);
+        }
+
+        // 9. Call Fractional Knapsack
+
+        AllocateChargingSlots(Arr, dCapacity);
+
+        sobj.close();
+    }
+
+    // 3. EV Request Entity
+    // Stores vehicle ID, energy, revenue and charging type.
+
+    static class EVRequest {
+        String sVehicleID;
+        double dEnergy;
+        double dRevenue;
+        double dRatio;
+        boolean bDivisible;
+
+        EVRequest(String sVehicleID, double dEnergy, double dRevenue, boolean bDivisible) {
+            this.sVehicleID = sVehicleID;
+            this.dEnergy = dEnergy;
+            this.dRevenue = dRevenue;
+            this.bDivisible = bDivisible;
+            this.dRatio = dRevenue / dEnergy;
+        }
+    }
+
+    // 4. Swap Function
+    // Exchanges two EV requests.
+
+    public static void Swap(EVRequest Arr[], int iFirst, int iSecond) {
+        EVRequest temp = Arr[iFirst];
+
+        Arr[iFirst] = Arr[iSecond];
+
+        Arr[iSecond] = temp;
+    }
+
+    // 5. Sort Function
+    // Sorts EV requests in descending order of revenue-to-energy ratio.
+
+    public static void Sort(EVRequest Arr[], int iSize) {
+        for (int iCnt = 0; iCnt < iSize - 1; iCnt++) {
+            for (int jCnt = 0; jCnt < iSize - iCnt - 1; jCnt++) {
+                if (Arr[jCnt].dRatio < Arr[jCnt + 1].dRatio) {
+                    Swap(Arr, jCnt, jCnt + 1);
+                }
+            }
+        }
+    }
+
+    // 10. Allocate Charging Slots
+    // Allocates available energy to maximize total revenue.
+
+    public static void AllocateChargingSlots(EVRequest Arr[], double dCapacity) {
+        double dTotalRevenue = 0;
+        double dTotalEnergy = 0;
+
+        // 10.1 Sort Requests by Ratio
+
+        Sort(Arr, Arr.length);
+
+        // 10.2 Allocate Energy
+
+        System.out.println("\nEV Charging Slot Allocation:");
+
+        System.out.printf("%-18s %-15s %-15s %-12s%n",
+                "Vehicle ID", "Energy", "Revenue", "Allocated");
+
+        System.out.println("------------------------------------------------------------");
+
+        for (int iCnt = 0; iCnt < Arr.length; iCnt++) {
+            if (dCapacity <= 0) {
+                break;
+            }
+
+            if (Arr[iCnt].dEnergy <= dCapacity) {
+                dCapacity = dCapacity - Arr[iCnt].dEnergy;
+
+                dTotalEnergy = dTotalEnergy + Arr[iCnt].dEnergy;
+
+                dTotalRevenue = dTotalRevenue + Arr[iCnt].dRevenue;
+
+                System.out.printf("%-18s %-15.2f %-15.2f 100%%%n",
+                        Arr[iCnt].sVehicleID,
+                        Arr[iCnt].dEnergy,
+                        Arr[iCnt].dRevenue);
+            } else if (Arr[iCnt].bDivisible) {
+                double dFraction = dCapacity / Arr[iCnt].dEnergy;
+
+                double dPartialRevenue = dFraction * Arr[iCnt].dRevenue;
+
+                dTotalEnergy = dTotalEnergy + dCapacity;
+
+                dTotalRevenue = dTotalRevenue + dPartialRevenue;
+
+                System.out.printf("%-18s %-15.2f %-15.2f %.2f%%%n",
+                        Arr[iCnt].sVehicleID,
+                        dCapacity,
+                        dPartialRevenue,
+                        dFraction * 100);
+
+                dCapacity = 0;
+            } else {
+                System.out.println(Arr[iCnt].sVehicleID +
+                        " - Skipped (Full charging required)");
+            }
+        }
+
+        // 10.3 Display Final Result
+
+        System.out.println("------------------------------------------------------------");
+
+        System.out.printf("Total Energy Allocated : %.2f kWh%n", dTotalEnergy);
+
+        System.out.printf("Total Revenue Earned   : Rs. %.2f%n", dTotalRevenue);
+    }
+}

dancealgorithm/assignments/FK - Electric/__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 = "FK - Electric"
+
+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}")