dancealgorithm 0.1.0__py3-none-any.whl

dancealgorithm/assignments/FK - Emergency/Solution.java

@@ -0,0 +1,159 @@
+
+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 Boat Capacity
+
+        System.out.print("Enter boat capacity (kg): ");
+        dCapacity = sobj.nextDouble();
+
+        // 7. Accept Number of Relief Items
+
+        System.out.print("Enter number of relief items: ");
+        iSize = sobj.nextInt();
+
+        ReliefItem Arr[] = new ReliefItem[iSize];
+
+        // 8. Accept Relief Item Details
+
+        for (int iCnt = 0; iCnt < iSize; iCnt++) {
+            String sName;
+            double dWeight;
+            double dValue;
+
+            System.out.println("\nEnter details of item " + (iCnt + 1));
+
+            System.out.print("Item name: ");
+            sName = sobj.next();
+
+            System.out.print("Weight (kg): ");
+            dWeight = sobj.nextDouble();
+
+            System.out.print("Utility value: ");
+            dValue = sobj.nextDouble();
+
+            Arr[iCnt] = new ReliefItem(sName, dWeight, dValue);
+        }
+
+        // 9. Call Fractional Knapsack
+
+        FractionalKnapsack(Arr, dCapacity);
+
+        sobj.close();
+    }
+
+    // 3. Relief Item Entity
+    // Stores item name, weight, utility value and ratio.
+
+    static class ReliefItem {
+        String sName;
+        double dWeight;
+        double dValue;
+        double dRatio;
+
+        ReliefItem(String sName, double dWeight, double dValue) {
+            this.sName = sName;
+            this.dWeight = dWeight;
+            this.dValue = dValue;
+            this.dRatio = dValue / dWeight;
+        }
+    }
+
+    // 4. Swap Function
+    // Exchanges two relief items.
+
+    public static void Swap(ReliefItem Arr[], int iFirst, int iSecond) {
+        ReliefItem temp = Arr[iFirst];
+
+        Arr[iFirst] = Arr[iSecond];
+
+        Arr[iSecond] = temp;
+    }
+
+    // 5. Sort Function
+    // Sorts relief items in descending order of utility-to-weight ratio.
+
+    public static void Sort(ReliefItem 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. Fractional Knapsack Function
+    // Selects items to maximize total utility within boat capacity.
+
+    public static void FractionalKnapsack(ReliefItem Arr[], double dCapacity) {
+        double dTotalValue = 0;
+        double dTotalWeight = 0;
+
+        // 10.1 Sort Items by Ratio
+
+        Sort(Arr, Arr.length);
+
+        // 10.2 Select Relief Items
+
+        System.out.println("\nRelief Supply Allocation:");
+
+        System.out.printf("%-20s %-12s %-12s %-12s%n",
+                "Item", "Weight", "Value", "Taken");
+
+        System.out.println("------------------------------------------------------------");
+
+        for (int iCnt = 0; iCnt < Arr.length; iCnt++) {
+            if (dCapacity <= 0) {
+                break;
+            }
+
+            if (Arr[iCnt].dWeight <= dCapacity) {
+                dCapacity = dCapacity - Arr[iCnt].dWeight;
+
+                dTotalWeight = dTotalWeight + Arr[iCnt].dWeight;
+
+                dTotalValue = dTotalValue + Arr[iCnt].dValue;
+
+                System.out.printf("%-20s %-12.2f %-12.2f 100%%%n",
+                        Arr[iCnt].sName,
+                        Arr[iCnt].dWeight,
+                        Arr[iCnt].dValue);
+            } else {
+                double dFraction = dCapacity / Arr[iCnt].dWeight;
+
+                double dTakenValue = dFraction * Arr[iCnt].dValue;
+
+                dTotalWeight = dTotalWeight + dCapacity;
+
+                dTotalValue = dTotalValue + dTakenValue;
+
+                System.out.printf("%-20s %-12.2f %-12.2f %.2f%%%n",
+                        Arr[iCnt].sName,
+                        dCapacity,
+                        dTakenValue,
+                        dFraction * 100);
+
+                dCapacity = 0;
+            }
+        }
+
+        // 10.3 Display Final Result
+
+        System.out.println("------------------------------------------------------------");
+
+        System.out.printf("Total Weight    : %.2f kg%n", dTotalWeight);
+
+        System.out.printf("Maximum Utility : %.2f%n", dTotalValue);
+    }
+}

dancealgorithm/assignments/FK - Emergency/__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 - Emergency"
+
+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.txt

@@ -0,0 +1,26 @@
+==================================================
+3. FRACTIONAL KNAPSACK (GREEDY)
+==================================================
+
+ALGORITHM:
+1. Calculate value/weight ratio for every item.
+2. Sort items in decreasing order of ratio.
+3. Initialize the remaining knapsack capacity.
+4. Select the item with the highest ratio.
+5. If the item fits, take it completely.
+6. Otherwise, take the fraction that fits.
+7. Calculate the total maximum value.
+
+FORMULA:
+Ratio = Value / Weight
+
+Total Value = Sum(Value[i] * Fraction[i])
+
+RECURRENCE:
+Not recursive. Uses Greedy technique.
+
+TIME COMPLEXITY:
+Sorting   : O(n log n)
+Selection : O(n)
+Overall   : O(n log n)
+Space     : O(n)

dancealgorithm/assignments/GC - Classroom/Solution.java

@@ -0,0 +1,87 @@
+import java.util.Arrays;
+
+// Main solution
+public class Solution {
+    // O(V * m^V)
+
+    // Safety check
+    public static boolean isSafe(int v, int[][] graph, int[] color, int c, int V) {
+        for (int i = 0; i < V; i++) {
+            if (graph[v][i] == 1 && color[i] == c) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Backtracking search
+    public static boolean graphColoringUtil(int[][] graph, int m, int[] color, int v, int V) {
+        if (v == V) {
+            return true;
+        }
+
+        for (int c = 1; c <= m; c++) {
+            if (isSafe(v, graph, color, c, V)) {
+                color[v] = c;
+
+                if (graphColoringUtil(graph, m, color, v + 1, V)) {
+                    return true;
+                }
+
+                // Backtrack
+                color[v] = 0;
+            }
+        }
+        return false;
+    }
+
+    public static void classroomScheduler(int[][] graph, int m, String[] lectures) {
+        int V = lectures.length;
+        int[] color = new int[V];
+        Arrays.fill(color, 0);
+
+        System.out.println("\nAcademic Classroom Allocation (Conflict-Free Scheduling):");
+        System.out.println("------------------------------------------------------------------");
+
+        if (!graphColoringUtil(graph, m, color, 0, V)) {
+            System.out.println("Cannot schedule all lectures with " + m + " classrooms without conflicts.");
+        } else {
+            System.out.printf("%-30s %-20s%n", "Lecture Session", "Allocated Classroom");
+            System.out.println("------------------------------------------------------------------");
+            for (int i = 0; i < V; i++) {
+                System.out.printf("%-30s Room Hall %d%n", lectures[i], color[i]);
+            }
+            System.out.println("------------------------------------------------------------------");
+            System.out.println("Status: All lectures scheduled with zero room booking collisions.");
+        }
+    }
+
+    // Driver code
+    public static void main(String[] args) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 20: Classroom Scheduling Without Conflicts (Graph Coloring - Java)");
+        System.out.println("=======================================================================");
+
+        String[] lectures = {
+            "Physics 101 (9:00 - 10:00 AM)", // 0
+            "Chemistry 101 (9:30 - 10:30 AM)", // 1
+            "Math 201 (10:00 - 11:00 AM)", // 2
+            "Biology 101 (10:30 - 11:30 AM)", // 3
+            "English 102 (9:00 - 10:30 AM)", // 4
+            "History 101 (11:00 - 12:00 PM)" // 5
+        };
+        int V = lectures.length;
+
+        int[][] conflictGraph = {
+            {0, 1, 0, 0, 1, 0},
+            {1, 0, 1, 0, 1, 0},
+            {0, 1, 0, 1, 1, 0},
+            {0, 0, 1, 0, 0, 1},
+            {1, 1, 1, 0, 0, 0},
+            {0, 0, 0, 1, 0, 0}
+        };
+
+        int availableClassrooms = 3;
+        classroomScheduler(conflictGraph, availableClassrooms, lectures);
+    }
+}

dancealgorithm/assignments/GC - Classroom/__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 = "GC - Classroom"
+
+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/GC - Interference/Solution.java

@@ -0,0 +1,88 @@
+import java.util.Arrays;
+
+// Main solution
+public class Solution {
+    // O(V * m^V)
+
+    // Safety check
+    public static boolean isSafe(int v, int[][] graph, int[] color, int c, int V) {
+        for (int i = 0; i < V; i++) {
+            if (graph[v][i] == 1 && color[i] == c) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Backtracking search
+    public static boolean graphColoringUtil(int[][] graph, int m, int[] color, int v, int V) {
+        if (v == V) {
+            return true;
+        }
+
+        for (int c = 1; c <= m; c++) {
+            if (isSafe(v, graph, color, c, V)) {
+                color[v] = c;
+
+                if (graphColoringUtil(graph, m, color, v + 1, V)) {
+                    return true;
+                }
+
+                // Backtrack
+                color[v] = 0;
+            }
+        }
+        return false;
+    }
+
+    // Solver entry
+    public static void frequencyAllocator(int[][] graph, int m, String[] towers) {
+        int V = towers.length;
+        int[] color = new int[V];
+        Arrays.fill(color, 0);
+
+        System.out.println("\nCellular Network Interference-Free Frequency Band Allocation:");
+        System.out.println("------------------------------------------------------------------");
+
+        if (!graphColoringUtil(graph, m, color, 0, V)) {
+            System.out.println("Cannot allocate frequencies without RF interference using " + m + " channels.");
+        } else {
+            System.out.printf("%-26s %-22s%n", "Cellular Tower", "Assigned Frequency Channel");
+            System.out.println("------------------------------------------------------------------");
+            for (int i = 0; i < V; i++) {
+                System.out.printf("%-26s Channel %d (Band %d MHz)%n", towers[i], color[i], 800 + color[i] * 50);
+            }
+            System.out.println("------------------------------------------------------------------");
+            System.out.println("Status: Zero co-channel interference across neighboring base stations.");
+        }
+    }
+
+    // Driver code
+    public static void main(String[] args) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 21: Mobile Tower Frequency Allocation (Graph Coloring - Java)");
+        System.out.println("=======================================================================");
+
+        String[] towers = {
+            "Tower 1 (Marine Drive)", // 0
+            "Tower 2 (Bandra West)", // 1
+            "Tower 3 (Andheri East)", // 2
+            "Tower 4 (Kurla Junction)", // 3
+            "Tower 5 (Powai Hiranandani)", // 4
+            "Tower 6 (CSMI Airport Terminal)" // 5
+        };
+        int V = towers.length;
+
+        int[][] interferenceGraph = {
+            {0, 1, 1, 0, 0, 0},
+            {1, 0, 1, 1, 0, 0},
+            {1, 1, 0, 1, 1, 0},
+            {0, 1, 1, 0, 1, 1},
+            {0, 0, 1, 1, 0, 1},
+            {0, 0, 0, 1, 1, 0}
+        };
+
+        int availableChannels = 3;
+        frequencyAllocator(interferenceGraph, availableChannels, towers);
+    }
+}

dancealgorithm/assignments/GC - Interference/__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 = "GC - Interference"
+
+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/GC - University/Solution.java

@@ -0,0 +1,88 @@
+import java.util.Arrays;
+
+// Main solution
+public class Solution {
+    // O(V * m^V)
+
+    // Safety check
+    public static boolean isSafe(int v, int[][] graph, int[] color, int c, int V) {
+        for (int i = 0; i < V; i++) {
+            if (graph[v][i] == 1 && color[i] == c) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Backtracking search
+    public static boolean graphColoringUtil(int[][] graph, int m, int[] color, int v, int V) {
+        if (v == V) {
+            return true;
+        }
+
+        for (int c = 1; c <= m; c++) {
+            if (isSafe(v, graph, color, c, V)) {
+                color[v] = c;
+
+                if (graphColoringUtil(graph, m, color, v + 1, V)) {
+                    return true;
+                }
+
+                // Backtrack
+                color[v] = 0;
+            }
+        }
+        return false;
+    }
+
+    // Solver entry
+    public static void timetableScheduler(int[][] graph, int m, String[] courses) {
+        int V = courses.length;
+        int[] color = new int[V];
+        Arrays.fill(color, 0);
+
+        System.out.println("\nUniversity Exam Timetable Conflict-Free Scheduling:");
+        System.out.println("------------------------------------------------------------------");
+
+        if (!graphColoringUtil(graph, m, color, 0, V)) {
+            System.out.println("No conflict-free schedule possible using " + m + " time slots.");
+        } else {
+            System.out.printf("%-26s %-20s%n", "Course Name", "Assigned Exam Slot");
+            System.out.println("------------------------------------------------------------------");
+            for (int i = 0; i < V; i++) {
+                System.out.printf("%-26s Slot %d (Day %d)%n", courses[i], color[i], color[i]);
+            }
+            System.out.println("------------------------------------------------------------------");
+            System.out.println("Status: Successfully scheduled all courses with zero student clashes.");
+        }
+    }
+
+    // Driver code
+    public static void main(String[] args) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 19: University Exam Timetable (Graph Coloring Backtracking - Java)");
+        System.out.println("=======================================================================");
+
+        String[] courses = {
+            "CS-101: Data Structures", // 0
+            "CS-102: Algorithms", // 1
+            "CS-103: Operating Systems", // 2
+            "EE-201: Digital Circuits", // 3
+            "MATH-301: Discrete Math", // 4
+            "AI-401: Machine Learning" // 5
+        };
+        int V = courses.length;
+
+        int[][] conflictGraph = {
+            {0, 1, 1, 1, 0, 0}, // CS-101
+            {1, 0, 1, 0, 1, 0}, // CS-102
+            {1, 1, 0, 0, 1, 1}, // CS-103
+            {1, 0, 0, 0, 1, 0}, // EE-201
+            {0, 1, 1, 1, 0, 1}, // MATH-301
+            {0, 0, 1, 0, 1, 0} // AI-401
+        };
+
+        int availableExamSlots = 3;
+        timetableScheduler(conflictGraph, availableExamSlots, courses);
+    }
+}

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

@@ -0,0 +1,25 @@
+==================================================
+7. GRAPH COLORING (BACKTRACKING)
+==================================================
+
+ALGORITHM:
+1. Represent the graph using an adjacency matrix.
+2. Initialize all vertex colors to zero.
+3. Start coloring from vertex 0.
+4. Try every available color from 1 to m.
+5. Check whether the color is safe.
+6. If safe, assign the color and recursively color the next vertex.
+7. If unsuccessful, reset color to zero (backtracking).
+8. Continue until all vertices are colored or no solution exists.
+
+RECURRENCE RELATION:
+T(V) = mT(V-1) + O(V)
+
+TIME COMPLEXITY:
+Best Case    : Depends on early solution.
+Average Case : Input-dependent.
+Worst Case   : O(V * m^V)
+Space        : O(V) auxiliary space
+
+IMPORTANT:
+1. Graph Coloring uses Backtracking.