changes

Author: Rakesh Venkatesh

src/Arrays/MaxDistBetweenBalls.java

@@ -0,0 +1,75 @@
+package Arrays;
+
+import java.util.Arrays;
+
+/**
+ * You have “n” empty baskets, you are given the position of the empty baskets in an array called "position", where position[i] specifies the position of the ith basket. Additionally you have m balls to be distributed among the n baskets, You have to distribute the m balls into n baskets such that the minimum magnetic force between any two balls is maximum.
+ * The magnetic force between two different balls at position x and y is defined as |x-y|
+ */
+public class MaxDistBetweenBalls {
+
+    /**
+     * This is a Binary Search on Answer problem, where we aim to maximize the minimum magnetic force between any two balls while distributing them in baskets.
+     *
+     * Approach
+     * 	1.	Sort the Basket Positions
+     * Since the magnetic force is defined as the absolute difference between positions, sorting helps in placing the balls optimally.
+     * 	2.	Use Binary Search on the Minimum Magnetic Force (d)
+     * 	•	The minimum force between two balls should be as large as possible.
+     * 	•	We perform binary search on d (the minimum force between two balls).
+     * 	•	The range of d is between 1 (smallest possible gap) and max(position) - min(position) (largest possible gap).
+     * 	3.	Check Feasibility Using Greedy Algorithm
+     * 	•	We try to place m balls into the baskets such that the minimum distance is at least d.
+     * 	•	Start placing the first ball in the first basket.
+     * 	•	Place the next ball only if the gap from the last placed ball is at least d.
+     * 	•	If we can place all m balls successfully, d is feasible, and we try a larger d.
+     * @param positions
+     * @param m
+     * @return
+     */
+    public int maxDistance(int[] positions, int m) {
+        int result = 0;
+        Arrays.sort(positions);
+
+        int left = 1, right = positions[positions.length - 1];
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+
+            if (canPlaceBall(positions, m, mid)) {
+                left = mid + 1;
+                result = mid;
+            } else {
+                right = mid - 1;
+            }
+        }
+
+        return result;
+    }
+
+    private boolean canPlaceBall(int[] positions, int m, int minDistance) {
+        int prevPosition = positions[0];
+        int ballsPaced = 1;
+
+        for (var i = 1; i < positions.length; i++) {
+            if (positions[i] - prevPosition >= minDistance) {
+                ballsPaced++;
+                prevPosition = positions[i];
+            }
+            if (ballsPaced == m) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static void main(String[] args) {
+        int[] position = {5, 4, 3, 2, 1, 100}; // Basket positions
+        int m = 2; // Number of balls
+
+        MaxDistBetweenBalls solution = new MaxDistBetweenBalls();
+
+        System.out.println(solution.maxDistance(position,m));
+    }
+}

src/Collections/DatabaseSimulator.java

@@ -0,0 +1,123 @@
+package Collections;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public class DatabaseSimulator {
+
+    Map<String, String> database;
+    Deque<Map<String, String>> transactionStack;
+
+    public DatabaseSimulator() {
+        this.database = new HashMap<>();
+        this.transactionStack = new ArrayDeque<>();
+    }
+
+    public void begin() {
+        transactionStack.push(new HashMap<>());
+    }
+
+    public String get(String key) {
+        if (transactionStack.isEmpty()) {
+            return database.get(key);
+        }
+
+        for (Iterator<Map<String, String>> it = transactionStack.descendingIterator(); it.hasNext(); ) {
+            Map<String, String> map = it.next();
+            if (map.containsKey(key)) {
+                return map.get(key);
+            }
+        }
+        return database.get(key);
+    }
+
+    public void set(String key, String value) throws RuntimeException {
+        if (transactionStack.isEmpty()) {
+            throw new RuntimeException("No transaction in progress");
+        }
+
+        transactionStack.getLast().put(key, value);
+    }
+
+    public int count() {
+        return database.size();
+    }
+
+    public void clear() {
+        database.clear();
+    }
+
+    public void commit() throws RuntimeException {
+        if (transactionStack.isEmpty()) {
+            throw new RuntimeException("No transaction in progress");
+        }
+
+        Map<String, String> map = new HashMap<>();
+
+        for (Map<String, String> current : transactionStack) {
+            map.putAll(current);
+        }
+
+        database.putAll(map);
+        transactionStack.clear();
+    }
+
+    public void rollback() throws RuntimeException {
+        if (transactionStack.isEmpty()) {
+            throw new RuntimeException("No transaction in progress");
+        }
+
+        transactionStack.pop();
+    }
+
+    public static void main(String[] args) {
+        DatabaseSimulator db = new DatabaseSimulator();
+        db.begin();
+        System.out.println(db.get("a"));
+        db.set("a", "Hello A");
+        System.out.println(db.get("a")); // hello A
+        db.set("b", "Hello B");
+        System.out.println(db.count()); // 0
+        db.commit();
+        System.out.println(db.get("a")); // Hello A
+        System.out.println(db.get("b")); // Hello B
+        System.out.println(db.count()); // 2
+        db.clear();
+        System.out.println("===================");
+
+        System.out.println(db.get("b")); // null
+        System.out.println(db.count()); // 0
+        try {
+            db.set("b", "Hello B"); // No transaction in progress
+        } catch (RuntimeException e) {
+            System.out.println(e.getMessage());
+        }
+        try {
+            db.commit(); // No transaction in progress
+        } catch (RuntimeException e) {
+            System.out.println(e.getMessage());
+        }
+        try {
+            db.rollback(); // No transaction in progress
+        } catch (RuntimeException e) {
+            System.out.println(e.getMessage());
+        }
+
+        db.clear();
+
+        System.out.println("===================");
+
+        db.begin();
+        db.set("a", "Hello");
+        db.begin();
+        db.set("a", "World");
+        System.out.println(db.get("a")); // World
+        db.commit();
+        System.out.println(db.get("a")); // World
+        System.out.println(db.count()); // 1
+
+    }
+}

src/Graphs/Kahn.java

@@ -0,0 +1,83 @@
+package Graphs;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Kahn {
+
+    private int V;
+    private final List<List<Integer>> adjList;
+    private final int[] indegree;
+
+    public Kahn(int V) {
+        this.V = V;
+        adjList = new ArrayList<>();
+        for (int i = 0; i < V; i++) {
+            adjList.add(new ArrayList<>());
+        }
+        indegree = new int[V];
+    }
+
+    public void addEdge(int source, int destination) {
+        adjList.get(source).add(destination);
+        indegree[destination]++;
+    }
+
+    public List<Integer> topologicalSort() {
+        if (V == 0) {
+            return new ArrayList<>();
+        }
+
+        List<Integer> result = new ArrayList<>();
+        PriorityQueue<Integer> queue = new PriorityQueue<>();
+
+        for (int i = 0; i < V; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+
+        if (queue.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        while (!queue.isEmpty()) {
+            int current = queue.poll();
+            result.add(current);
+            for (int neighbor : adjList.get(current)) {
+                indegree[neighbor]--;
+                if (indegree[neighbor] == 0) {
+                    queue.add(neighbor);
+                }
+            }
+        }
+
+        return result;
+    }
+    public static void main(String[] args) {
+        Kahn graph = new Kahn(6);
+        graph.addEdge(5, 2);
+        graph.addEdge(5, 0);
+        graph.addEdge(4, 0);
+        graph.addEdge(4, 1);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 1);
+        List<Integer> integers = graph.topologicalSort();
+        System.out.println(integers);
+
+        int[] nums = new int[5];
+        String[] strings = new String[5];
+
+
+    }
+}
+
+/**
+ * 5 - 2
+ * 5 - 0
+ * 4 - 0
+ * 4 - 1
+ * 2 - 3
+ * 3 - 1
+ */

src/Trees/ZigZagTraversal.java

@@ -0,0 +1,70 @@
+package Trees;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+
+public class ZigZagTraversal {
+
+    public List<List<Integer>> zigzagLevelOrder(TreeNode<Integer> root) {
+        if (root == null) {
+            return null;
+        }
+
+        List<List<Integer>> result = new ArrayList<>();
+        Deque<TreeNode<Integer>> queue = new ArrayDeque<>();
+        boolean leftToRight = false;
+
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            List<Integer> list = new ArrayList<>();
+            int size = queue.size();
+
+            for (var i = 0; i < size; i++) {
+                if (leftToRight) {
+                    TreeNode<Integer> current = queue.pollFirst();
+                    list.add(current.getData());
+
+                    if (current.getLeft() != null) {
+                        queue.addLast(current.getLeft());
+                    }
+                    if (current.getRight() != null) {
+                        queue.addLast(current.getRight());
+                    }
+                } else {
+                    TreeNode<Integer> current = queue.pollLast();
+                    list.add(current.getData());
+
+                    if (current.getRight() != null) {
+                        queue.addFirst(current.getRight());
+                    }
+                    if (current.getLeft() != null) {
+                        queue.addFirst(current.getLeft());
+                    }
+                }
+            }
+
+            leftToRight = !leftToRight;
+            result.add(list);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        TreeNode<Integer> root = new TreeNode<>(1);
+        root.setLeft(new TreeNode<>(2));
+        root.setRight(new TreeNode<>(3));
+        root.getLeft().setLeft(new TreeNode<>(4));
+        root.getLeft().setRight(new TreeNode<>(5));
+        root.getRight().setLeft(new TreeNode<>(6));
+        root.getRight().setRight(new TreeNode<>(7));
+
+        ZigZagTraversal zigZagTraversal = new ZigZagTraversal();
+        List<List<Integer>> result = zigZagTraversal.zigzagLevelOrder(root);
+        System.out.println(result);
+
+    }
+
+}