initial commit

.gitignore

@@ -0,0 +1,32 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+.idea/
+*.iml
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

input.txt

@@ -0,0 +1,4 @@
+3
+1 3 8
+2 3 4
+1 2 5

src/com/dsa/arrays/ArrayUnion.java

@@ -0,0 +1,78 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class ArrayUnion {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            String[] elements2 = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int numberOfElements2 = elements2.length;
+            int[] arr = new int[numberOfElements];
+            int[] arr2 = new int[numberOfElements2];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            for (int i = 0; i < numberOfElements2; i++) {
+                arr2[i] = Integer.parseInt(elements2[i].trim());
+            }
+            System.out.println("Input1: " + Arrays.toString(arr));
+            System.out.println("Input2: " + Arrays.toString(arr2));
+            ArrayUnion arrayUnion = new ArrayUnion();
+            int[] newArr = arrayUnion.union(arr, arr2);
+            System.out.println("Output: " + Arrays.toString(newArr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int[] union(int[] arr1, int[] arr2) {
+       int[] tempArray = new int[arr1.length + arr2.length];
+       int lastIndex = 0;
+
+       int i = 0;
+       int j = 0;
+
+       while (i < arr1.length && j < arr2.length) {
+        if (arr1[i] <= arr2[j]) {
+            if (lastIndex == 0 || arr1[i] != tempArray[lastIndex-1]) {
+                tempArray[lastIndex] = arr1[i];
+                lastIndex++;
+            }
+            i++;
+        } else {
+            if (lastIndex == 0 || arr2[j] != tempArray[lastIndex-1]) {
+                tempArray[lastIndex] = arr2[j];
+                lastIndex++;
+            }
+            j++;
+        }
+       }
+
+       while (i < arr1.length) {
+        if (lastIndex == 0 || arr1[i] != tempArray[lastIndex-1]) {
+                tempArray[lastIndex] = arr1[i];
+                lastIndex++;
+            }
+            i++;
+       }
+
+       while (j < arr2.length) {
+        if (lastIndex == 0 || arr2[j] != tempArray[lastIndex-1]) {
+                tempArray[lastIndex] = arr2[j];
+                lastIndex++;
+            }
+            j++;
+       }
+
+       int[] result = new int[lastIndex];
+       for (int k=0; k < lastIndex; k++) {
+        result[k] = tempArray[k];
+       }
+       return result;
+    }
+}

src/com/dsa/arrays/ConsecutiveOnes.java

@@ -0,0 +1,40 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class ConsecutiveOnes {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            ConsecutiveOnes solution = new ConsecutiveOnes();
+            int consecutiveOnes = solution.maxConsequetive1s(arr);
+            System.out.println("Input: " + Arrays.toString(arr));
+            System.out.println("Max Consecutive 1s: " + consecutiveOnes);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int maxConsequetive1s(int[] nums) {
+        int maxCount = 0;
+        int count = 0;
+        for (int num : nums) {
+            if (num == 1) {
+                count++;
+                maxCount = Math.max(maxCount, count);
+            } else {
+                count = 0;
+            }
+        }
+        return maxCount;
+    }
+}

src/com/dsa/arrays/ConsecutiveSequence.java

@@ -0,0 +1,39 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class ConsecutiveSequence {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            ConsecutiveSequence solution = new ConsecutiveSequence();
+            System.out.println(solution.longestConsecutive(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0) return 0;
+        int count = 1;
+        int longest = 1;
+        Arrays.sort(nums);
+        for (int i = 1; i < nums.length; i++) {
+             if (nums[i] - 1 == nums[i - 1]) {
+                 count++;
+             } else if (nums[i] != nums[i - 1]) {
+                 count = 1;
+             }
+             longest = Math.max(longest, count);
+        }
+        return longest;
+    }
+}

src/com/dsa/arrays/CountInversionsAndReversePairs.java

@@ -0,0 +1,119 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class CountInversionsAndReversePairs {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            CountInversionsAndReversePairs solution = new CountInversionsAndReversePairs();
+//            int inversions = solution.getInversionsCount(arr);
+            int reversePairCount = solution.getReversePairCount(arr);
+//            System.out.println(inversions);
+            System.out.println("Reverse Pairs: " + reversePairCount);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getInversionsCount(int[] arr) {
+        return mergeSortAndCount(arr, 0, arr.length - 1);
+    }
+
+    public int mergeSortAndCount(int[] arr, int left, int right) {
+        int mid, invCount = 0;
+        if (right > left) {
+            mid = (right + left) / 2;
+            invCount += mergeSortAndCount(arr, left, mid);
+            invCount += mergeSortAndCount(arr, mid + 1, right);
+            invCount += mergeAndCount(arr, left, mid, right);
+        }
+        return invCount;
+    }
+
+    // i < j and arr[i] > arr[j] is called inversion
+    public int mergeAndCount(int[] arr, int left, int mid, int right) {
+        int[] tempArray = new int[right - left + 1];
+        int i = left, j = mid+1, k = 0, count = 0;
+
+        while (i <= mid && j <= right) {
+            if (arr[i] <= arr[j]) {
+                tempArray[k++] = arr[i++];
+            } else {
+                tempArray[k++] = arr[j++];
+                count += (mid - i + 1); // if an element on left side is greater than element on right side then all the remaining elements on left side will also be greater
+            }
+        }
+        while (i <= mid) {
+            tempArray[k++] = arr[i++];
+        }
+        while (j <= right) {
+            tempArray[k++] = arr[j++];
+        }
+        for (int low = left; low <= right; low++) {
+            arr[low] = tempArray[low - left];
+        }
+        return count;
+    }
+
+    public int getReversePairCount(int[] nums) {
+        return reversePairMergeSort(nums, 0, nums.length - 1);
+    }
+
+    public int reversePairMergeSort(int[] nums, int left, int right) {
+        int mid, reversePairCount = 0;
+        if (right > left) {
+            mid = (right + left) / 2;
+            reversePairCount += reversePairMergeSort(nums, left, mid);
+            reversePairCount += reversePairMergeSort(nums, mid + 1, right);
+            reversePairCount += reversePairMergeAndCount(nums, left, mid, right);
+        }
+        return reversePairCount;
+    }
+
+    public int reversePairMergeAndCount(int[] nums, int left, int mid, int right) {
+        int count = getPairCount(nums, left, mid, right);
+        int[] tempArray = new int[right - left + 1];
+        int i = left, j = mid + 1, k = 0;
+
+        while (i <= mid && j <= right) {
+            if (nums[i] <= nums[j]) {
+                tempArray[k++] = nums[i++];
+            } else {
+                tempArray[k++] = nums[j++];
+            }
+        }
+        while (i <= mid) {
+            tempArray[k++] = nums[i++];
+        }
+        while (j <= right) {
+            tempArray[k++] = nums[j++];
+        }
+        for (int low = left; low <= right; low++) {
+            nums[low] = tempArray[low - left];
+        }
+        return count;
+    }
+
+    public int getPairCount(int[] nums, int left, int mid, int right) {
+        int count = 0;
+        int i = left;
+        int j = mid + 1;
+        while (i <= mid && j <= right) {
+            if (nums[i] > 2L * nums[j]) {
+                count += (mid - i + 1);
+                j++;
+            } else {
+                i++;
+            }
+        }
+        return count;
+    }
+}

src/com/dsa/arrays/LeftRotateArray.java

@@ -0,0 +1,48 @@
+package com.dsa.arrays;
+
+import com.dsa.sorting.BubbleSort;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class LeftRotateArray {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            BubbleSort solution = new BubbleSort();
+            solution.sort(arr);
+            System.out.println("Input: " + Arrays.toString(arr));
+            int d = Integer.parseInt(reader.readLine().trim());
+            LeftRotateArray leftRotateArray = new LeftRotateArray();
+            leftRotateArray.leftRotate(arr, d);
+            System.out.println("Output: " + Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void leftRotate(int[] arr, int d) {
+        int n = arr.length;
+        d = d % n;
+        reverse(arr, 0, d-1);
+        reverse(arr, d, n-1);
+        reverse(arr, 0, n-1);
+    }
+
+    public void reverse(int[] arr, int start, int end) {
+        while (start < end ) {
+            int temp = arr[start];
+            arr[start] = arr[end];
+            arr[end] = temp;
+            start++;
+            end--;
+        }
+    }
+}

src/com/dsa/arrays/MajorityElement.java

@@ -0,0 +1,76 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class MajorityElement {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            MajorityElement solution = new MajorityElement();
+            int majorityElement = solution.getMajorityElement(arr);
+            int[] majorityElementsMoreThanNBy3 = solution.getMajorityElementThatRepeatsMoreThanSizeDividedBy3(arr);
+            System.out.println("Majority Element: ");
+            System.out.println(majorityElement);
+            System.out.println("Majority Elements (more than n/3 times): ");
+            for (int num : majorityElementsMoreThanNBy3) {
+                System.out.println(num);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMajorityElement(int[] nums) {
+        int count = 0;
+        int candidate = nums[0];
+
+        for (int num : nums) {
+            if (count == 0) {
+                candidate = num;
+            }
+            count += (num == candidate) ? 1 : -1;
+        }
+
+        return candidate;
+    }
+
+    public int[] getMajorityElementThatRepeatsMoreThanSizeDividedBy3(int[] nums) {
+        int nBy3 = nums.length / 3;
+        ArrayList<Integer> answer = new ArrayList<>();
+        int cnt1 = 0, cnt2 = 0;
+        int num1 = 0, num2 = 1;
+        for (int num : nums) {
+            if (num1 == num) {
+                cnt1++;
+            } else if (num2 == num) {
+                cnt2++;
+            } else if (cnt1 == 0) {
+                num1 = num;
+                cnt1 = 1;
+            } else if (cnt2 == 0) {
+                num2 = num;
+                cnt2 = 1;
+            } else {
+                cnt1--;
+                cnt2--;
+            }
+        }
+        cnt1 = 0;
+        cnt2 = 0;
+        for (int num : nums) {
+            if (num1 == num) cnt1++;
+            else if (num2 == num) cnt2++;
+        }
+        if (cnt1 > nBy3) answer.add(num1);
+        if (cnt2 > nBy3) answer.add(num2);
+        return answer.stream().mapToInt(Integer::intValue).toArray();
+    }
+}

src/com/dsa/arrays/MaxFrequencyKOperations.java

@@ -0,0 +1,43 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MaxFrequencyKOperations {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            int k = Integer.parseInt(reader.readLine().trim());
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            MaxFrequencyKOperations solution = new MaxFrequencyKOperations();
+            System.out.println(solution.maxFrequency(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    //Notes can be found in DSA Notes on OneNote
+    public int maxFrequency(int[] nums, int k) {
+        Arrays.sort(nums);
+        int left = 0;
+        long total = 0;
+        int maxFreq = 1;
+
+        for (int right = 0; right < nums.length; right++) {
+            total += nums[right];
+
+            while ((total + k) < (long) nums[right] * (right - left + 1)) {
+                total -= nums[left];
+                left++;
+            }
+            maxFreq = Math.max(maxFreq, right - left + 1);
+        }
+        return maxFreq;
+    }
+}

src/com/dsa/arrays/MaxSubArraySumAndProduct.java

@@ -0,0 +1,51 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class MaxSubArraySumAndProduct {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            MaxSubArraySumAndProduct solution = new MaxSubArraySumAndProduct();
+            int maxSubArraySum = solution.getMaxSubArraySum(arr);
+            int maxSubArrayProduct = solution.getMaxSubArrayProduct(arr);
+            System.out.println("Max Sub Array Product: " + maxSubArrayProduct);
+            System.out.println(maxSubArraySum);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMaxSubArraySum(int[] nums) {
+        int max = Integer.MIN_VALUE;
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+            max = Math.max(sum, max);
+            if (sum < 0) sum = 0;
+        }
+        return max;
+    }
+
+    public int getMaxSubArrayProduct(int[] nums) {
+        int max = Integer.MIN_VALUE;
+        int product = 1;
+        int reverseProduct = 1;
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            reverseProduct *= nums[nums.length - 1 - i];
+            product *= num;
+            max = Math.max(product, Math.max(max, reverseProduct));
+            if (product == 0) product = 1;
+            if (reverseProduct == 0) reverseProduct = 1;
+        }
+        return max;
+    }
+}

src/com/dsa/arrays/MergeTwoSortedArrays.java

@@ -0,0 +1,87 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MergeTwoSortedArrays {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            String[] elements2 = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int numElementsWithoutZero = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements2 = elements2.length;
+            int[] arr = new int[numberOfElements];
+            int[] arr2 = new int[numberOfElements2];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            for (int i = 0; i < numberOfElements2; i++) {
+                arr2[i] = Integer.parseInt(elements2[i].trim());
+            }
+            System.out.println("Input1: " + Arrays.toString(arr));
+            System.out.println("Input2: " + Arrays.toString(arr2));
+            MergeTwoSortedArrays solution = new MergeTwoSortedArrays();
+            solution.mergeWithoutExtraSpaceOptimized(arr, numElementsWithoutZero, arr2, numberOfElements2);
+            System.out.println("Output: " + Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void mergeWithoutExtraSpace(int[] nums1, int m, int[] nums2, int n) {
+        if (n < 1) {
+            return;
+        }
+        for (int i=0; i<m; i++) {
+            if (nums1[i] > nums2[0]) {
+                // swap
+                int temp = nums1[i];
+                nums1[i] = nums2[0];
+                nums2[0] = temp;
+
+                // place nums2[0] at its correct position to maintain sorted order of nums2
+                int first = nums2[0];
+                int k;
+                for (k = 1; k < n && nums2[k] < first; k++) {
+                    nums2[k - 1] = nums2[k];
+                }
+                nums2[k - 1] = first;
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            nums1[m + i] = nums2[i];
+        }
+    }
+
+    public void mergeWithoutExtraSpaceOptimized(int[] nums1, int m, int[] nums2, int n) {
+        if (n < 1) {
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            nums1[m + i] = nums2[i];
+        }
+        //GAP Method
+        int gap = Math.ceilDiv(m + n, 2);
+        while (gap >= 1) {
+            int left = 0;
+            int right = left + gap;
+            if (gap == 1) {
+                gap = 0;
+            }
+            while (right < (m + n)) {
+                if (nums1[left] >= nums1[right]) {
+                    //swap
+                    int temp = nums1[left];
+                    nums1[left] = nums1[right];
+                    nums1[right] = temp;
+                }
+                left++;
+                right++;
+            }
+            gap = Math.ceilDiv(gap, 2);
+        }
+    }
+}

src/com/dsa/arrays/MissingNumberInArray.java

@@ -0,0 +1,40 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MissingNumberInArray {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            MissingNumberInArray solution = new MissingNumberInArray();
+            int missingNumber = solution.findMissingNumber(arr);
+            System.out.println("Input: " + Arrays.toString(arr));
+            System.out.println("Missing Number: " + missingNumber);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int findMissingNumber(int[] arr) {
+        int[] tempArr = new int[arr.length+1];
+        Arrays.fill(tempArr, -1);
+        for (int j : arr) {
+            tempArr[j] = 1;
+        }
+        for (int i=0; i<tempArr.length; i++) {
+            if (tempArr[i] == -1) {
+                return i;
+            }
+        }
+        return arr.length;
+    }
+}

src/com/dsa/arrays/MoveZeroToEnd.java

@@ -0,0 +1,42 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MoveZeroToEnd {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            System.out.println("Input: " + Arrays.toString(arr));
+            MoveZeroToEnd moveZeroToEnd = new MoveZeroToEnd();
+            moveZeroToEnd.moveZeroToEnd(arr);
+            System.out.println("Output: " + Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void moveZeroToEnd(int[] arr) {
+        int n = arr.length;
+        int zeroIndex = 0;
+
+        for (int i = 0; i < n && zeroIndex < n; i++) {
+            if (arr[i] == 0 && arr[zeroIndex] != 0) {
+                zeroIndex = i;
+            } else if (arr[zeroIndex] == 0) {
+                arr[zeroIndex] = arr[i];
+                arr[i] = 0;
+                while (zeroIndex < n && arr[zeroIndex] != 0) {
+                    zeroIndex++;
+                }
+            }
+        }
+    }
+}

src/com/dsa/arrays/NumberThatRepeatsOnceAndOthersTwice.java

@@ -0,0 +1,33 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class NumberThatRepeatsOnceAndOthersTwice {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            var solution = new NumberThatRepeatsOnceAndOthersTwice();
+            int appearsOnce = solution.numberThatAppearsOnlyOnce(arr);
+            System.out.println("Input: " + Arrays.toString(arr));
+            System.out.println("Appears Only Once: " + appearsOnce);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int numberThatAppearsOnlyOnce(int[] arr) {
+        int result = 0;
+        for (int num : arr) {
+            result ^= num;
+        }
+        return result;
+    }
+}

src/com/dsa/arrays/OverlappingSubIntervals.java

@@ -0,0 +1,7 @@
+package com.dsa.arrays;
+
+public class OverlappingSubIntervals {
+    public static void main(String[] args) {
+
+    }
+}

src/com/dsa/arrays/PascalTriangle.java

@@ -0,0 +1,70 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class PascalTriangle {
+
+    public static void main(String[] args) {
+        try(BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int rows = Integer.parseInt(reader.readLine());
+            PascalTriangle solution = new PascalTriangle();
+            int[][] pascalTriangleArray = solution.getPascalTriangleOptimized(rows);
+            for (int[] row: pascalTriangleArray) {
+                System.out.println(Arrays.toString(row));
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int[][] getPascalTriangle(int rows) {
+        int[][] result = new int[rows][];
+        for (int i=0; i<rows; i++) {
+            int[] row = new int[i+1];
+            for (int j = 0; j<row.length; j++) {
+                if (i == 0) {
+                    row[j] = 1;
+                } else {
+                    int val1 = getValAtIndex(result[i-1], j);
+                    int val2 = getValAtIndex(result[i-1], j-1);
+                    row[j] = val1 + val2;
+                }
+            }
+            result[i] = row;
+        }
+        return result;
+    }
+
+    private int getValAtIndex(int[] arr, int index) {
+        if (index < 0 || index >= arr.length) {
+            return 0;
+        }
+        return arr[index];
+    }
+
+    public int[][] getPascalTriangleOptimized(int rows) {
+        int[][] result = new int[rows][];
+        for (int i=0; i<rows; i++) {
+            result[i] = getRow(i+1);
+        }
+        return result;
+    }
+
+    private static int[] getRow(int row){
+        int temp = row-1;
+        int[] rowArr = new int[row];
+        int val = 1;
+        rowArr[0]= val;
+        //to get value of any position in pascal triangle we will use the formula NcR "(n!)/(r!)*(n-r)!"
+        for(int i=1; i<row; i++,temp--){
+            val *= temp;
+            val /= i;
+            rowArr[i] = val;
+        }
+        return rowArr;
+    }
+
+}

src/com/dsa/arrays/RemoveDuplicatesInSortedArray.java

@@ -0,0 +1,39 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+import com.dsa.sorting.QuickSort;
+
+public class RemoveDuplicatesInSortedArray {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            var solution = new RemoveDuplicatesInSortedArray();
+            var quickSort = new QuickSort();
+            quickSort.sort(arr, 0, numberOfElements - 1);
+            solution.removeDuplicates(arr);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void removeDuplicates(int[] arr) {
+        int replaceIdx = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[replaceIdx] != arr[i]) {
+                arr[replaceIdx + 1] = arr[i];
+                replaceIdx++;
+            }
+        }
+    }
+}

src/com/dsa/arrays/RepeatingAndMissing.java

@@ -0,0 +1,52 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class RepeatingAndMissing {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            RepeatingAndMissing solution = new RepeatingAndMissing();
+            int[] maxSubArraySum = solution.getMissingAndRepeatingNumbers(arr);
+            System.out.println(Arrays.toString(maxSubArraySum));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int[] getMissingAndRepeatingNumbers(int[] arr) {
+        int sumN = 0;
+        int sumNsq = 0;
+        int sumArr = 0;
+        int sumArrSq = 0;
+        for (int i = 0; i < arr.length; i++) {
+            sumArr += arr[i];
+            sumArrSq += arr[i] * arr[i];
+            sumN += (i + 1);
+            sumNsq += (i + 1) * (i + 1);
+        }
+        int xMinusY = sumN - sumArr; // x - y
+        int xSqMinusYSq = sumNsq - sumArrSq; // x^2 - y^2
+        int xPlusY = xSqMinusYSq / xMinusY; // x + y => (x+y)(x-y) = x^2 - y^2 hence (x+y) = (x^2 - y^2)/(x-y)
+        int x = (xMinusY + xPlusY) / 2; // (x+y + x-y) => 2x hence x = (x+y + x-y)/2
+        int y = xPlusY - x; // y = (x+y) - x
+        int count = 0;
+        for (int value : arr) {
+            if (value == y) {
+                count++;
+            }
+        }
+        if (count == 2) {
+            return new int[]{y, x};
+        }
+        return new int[]{x, y};
+    }
+}

src/com/dsa/arrays/SecondLargestAndSecondSmallest.java

@@ -0,0 +1,44 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class SecondLargestAndSecondSmallest {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            var solution = new SecondLargestAndSecondSmallest();
+            solution.findSecondSmallAndSecondLargest(arr);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void findSecondSmallAndSecondLargest(int[] arr) {
+        int small, secondSmall, large, secondLarge;
+        small = secondSmall = Integer.MAX_VALUE;
+        large = secondLarge = Integer.MIN_VALUE;
+
+        for (int num : arr) {
+            if (small > num) {
+                secondSmall = small;
+                small = num;
+            }
+
+            if (large < num) {
+                secondLarge = large;
+                large = num;
+            }
+        }
+
+        System.out.println("Second Small: " + secondSmall + " Second Large: " + secondLarge);
+    }
+
+}

src/com/dsa/arrays/SetMatricZeroes.java

@@ -0,0 +1,59 @@
+package com.dsa.arrays;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+
+public class SetMatricZeroes {
+    public static void main(String[] args) {
+        try {
+            int[][] matrix = Files.readAllLines(Path.of("input.txt"))
+                    .stream()
+                    .map(line -> {
+                        String[] elements = line.trim().split(",");
+                        int[] row = new int[elements.length];
+                        for (int i = 0; i < elements.length; i++) {
+                            row[i] = Integer.parseInt(elements[i].trim());
+                        }
+                        return row;
+                    })
+                    .toArray(int[][]::new);
+            SetMatricZeroes solution = new SetMatricZeroes();
+            solution.setZeroes(matrix);
+            for (int[] row : matrix) {
+                System.out.println(Arrays.toString(row));
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void setZeroes(int[][] matrix) {
+        int col0 = 1;
+        for(int i=0; i<matrix.length; i++){
+            for(int j = 0; j<matrix[i].length; j++){
+                if(matrix[i][j] == 0){
+                    if(j == 0) col0 = 0;
+                    else matrix[0][j] = 0;
+                    matrix[i][0] = 0;
+                }
+            }
+        }
+        for(int i=1; i<matrix.length; i++){
+            for(int j=1; j<matrix[i].length; j++){
+                if(matrix[i][0] == 0 || matrix[0][j] == 0) matrix[i][j] = 0;
+            }
+        }
+        if(matrix[0][0] == 0){
+            for(int i=0; i<matrix[0].length; i++){
+                matrix[0][i] = 0;
+            }
+        }
+        if(col0 == 0){
+            for(int i=0; i<matrix.length; i++){
+                matrix[i][0] = 0;
+            }
+        }
+    }
+}

src/com/dsa/arrays/SortZeroOneTwo.java

@@ -0,0 +1,47 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SortZeroOneTwo {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SortZeroOneTwo solution = new SortZeroOneTwo();
+            solution.sort(arr);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    public void sort(int[] nums) {
+        int low = 0;
+        int mid = 0;
+        int high = nums.length - 1;
+
+        while (mid <= high) {
+            if (nums[mid] == 1) {
+                mid++;
+            } else if (nums[mid] == 0) {
+                int temp = nums[low];
+                nums[low] = nums[mid];
+                nums[mid] = temp;
+                low++;
+                mid++;
+            } else if (nums[mid] == 2) {
+                int temp = nums[high];
+                nums[high] = nums[mid];
+                nums[mid] = temp;
+                high--;
+            }
+        }
+    }
+}

src/com/dsa/arrays/SpiralMatrixTraversal.java

@@ -0,0 +1,59 @@
+package com.dsa.arrays;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+
+public class SpiralMatrixTraversal {
+
+    public static void main(String[] args) {
+        try {
+            int[][] matrix = Files.readAllLines(Path.of("input.txt"))
+                    .stream()
+                    .map(line -> {
+                        String[] elements = line.trim().split(",");
+                        int[] row = new int[elements.length];
+                        for (int i = 0; i < elements.length; i++) {
+                            row[i] = Integer.parseInt(elements[i].trim());
+                        }
+                        return row;
+                    })
+                    .toArray(int[][]::new);
+            System.out.println("Input Matrix: ");
+            for (int[] row : matrix) {
+                System.out.println(Arrays.toString(row));
+            }
+            SpiralMatrixTraversal solution = new SpiralMatrixTraversal();
+            solution.printInSpiral(matrix);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void printInSpiral(int[][] matrix) {
+        int top = 0;
+        int bottom = matrix.length - 1;
+        int left = 0;
+        int right = matrix[0].length - 1;
+        while (top < bottom && left < right) {
+            for (int i = left; i <= right; i++) {
+                System.out.println(matrix[top][i]);
+            }
+            top++;
+            for (int i = top; i <= bottom; i++) {
+                System.out.println(matrix[i][right]);
+            }
+            right--;
+            for (int i = right; i >= left; i--) {
+                System.out.println(matrix[bottom][i]);
+            }
+            bottom--;
+            for (int i=bottom; i >= top; i--) {
+                System.out.println(matrix[i][left]);
+            }
+            left++;
+        }
+    }
+
+}

src/com/dsa/arrays/StockBuySell.java

@@ -0,0 +1,38 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class StockBuySell {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            StockBuySell solution = new StockBuySell();
+            int maxProfit = solution.getMaxProfit(arr);
+            System.out.println(maxProfit);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMaxProfit(int[] prices) {
+        int minPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+
+        for (int price : prices) {
+            if (price < minPrice) {
+                minPrice = price;
+            } else if (price - minPrice > maxProfit) {
+                maxProfit = price - minPrice;
+            }
+        }
+
+        return maxProfit;
+    }
+}

src/com/dsa/arrays/SubArrayWithSumK.java

@@ -0,0 +1,80 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SubArrayWithSumK {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            int k = Integer.parseInt(reader.readLine().trim());
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SubArrayWithSumK solution = new SubArrayWithSumK();
+            System.out.println(solution.maxSubArrayLengthWithSumKUsingHashMap(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int maxSubArrayLengthWithSumK(int[] arr, int k) {
+        int i = 0;
+        int j = 0;
+        int subArrayLength = 0;
+
+        int sum = 0;
+        while( i <= j && j < arr.length) {
+            if(sum < k) {
+                sum += arr[j];
+                j++;
+            } else if (sum > k && i < arr.length) {
+                sum -= arr[i];
+                i++;
+            } else {
+                int tempLength = j - i;
+                subArrayLength = Math.max(tempLength, subArrayLength);
+                if (++j < arr.length) {
+                    sum += arr[j];
+                }
+            }
+        }
+        if (sum == k) {
+            subArrayLength = Math.max(j - i, subArrayLength);
+        }
+
+        return subArrayLength;
+    }
+
+    public int maxSubArrayLengthWithSumKUsingHashMap(int[] arr, int k) {
+        Map<Integer, Integer> sumIndexMap = new HashMap<>();
+        int sum = 0;
+        int maxLength = 0;
+
+        for (int i = 0; i < arr.length; i++) {
+            sum += arr[i];
+
+            if (sum == k) {
+                maxLength = i + 1;
+            }
+
+            if (!sumIndexMap.containsKey(sum)) {
+                sumIndexMap.put(sum, i);
+            }
+
+            if (sumIndexMap.containsKey(sum - k)) {
+                int prevIndex = sumIndexMap.get(sum - k);
+                maxLength = Math.max(maxLength, i - prevIndex);
+            }
+        }
+
+        return maxLength;
+    }
+    
+}

src/com/dsa/arrays/SubArrayWithXorK.java

@@ -0,0 +1,38 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.HashMap;
+
+public class SubArrayWithXorK {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            int k = Integer.parseInt(reader.readLine().trim());
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SubArrayWithXorK solution = new SubArrayWithXorK();
+            System.out.println(solution.subArrayCountWithXorK(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int subArrayCountWithXorK(int[] arr, int k) {
+        int count = 0;
+        HashMap<Integer, Integer> prefixXorFreq = new HashMap<>();
+        prefixXorFreq.put(0, 1); // Base case: prefix XOR of 0 occurs once
+        int prefixXor = 0;
+        for (int num : arr) {
+            prefixXor ^= num;
+            int requiredXor = prefixXor ^ k;
+            count += prefixXorFreq.getOrDefault(requiredXor, 0);
+            prefixXorFreq.put(prefixXor, prefixXorFreq.getOrDefault(prefixXor, 0) + 1);
+        }
+        return count;
+    }
+}

src/com/dsa/arrays/SubSetArraySum.java

@@ -0,0 +1,104 @@
+package com.dsa.arrays;
+
+import com.dsa.sorting.QuickSort;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SubSetArraySum {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int targetSum = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SubSetArraySum solution = new SubSetArraySum();
+            List<List<Integer>> triplets = solution.getTripletsWithSumZero(arr);
+            List<List<Integer>> quadruplets = solution.getQuadrupletsWithSumTarget(arr, targetSum);
+            System.out.println("Triplets with sum zero: ");
+            for (List<Integer> triplet : triplets) {
+                System.out.println(triplet);
+            }
+            System.out.println("Quadruplets with sum target: ");
+            for (List<Integer> quadruplet : quadruplets) {
+                System.out.println(quadruplet);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public List<List<Integer>> getTripletsWithSumZero(int[] nums) {
+        QuickSort quickSort = new QuickSort();
+        quickSort.sort(nums, 0, nums.length - 1);
+        List<List<Integer>> result = new ArrayList<>();
+        int n = nums.length;
+
+        for (int i = 0; i < n - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue; // Skip duplicates
+
+            int left = i + 1;
+            int right = n - 1;
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum < 0) {
+                    left++;
+                }
+                else if (sum > 0) {
+                    right--;
+                }
+                else {
+                    result.add(List.of(nums[i], nums[left], nums[right]));
+                    left++;
+                    right--;
+                    while (left < right && nums[right] == nums[right + 1]) right--; // Skip duplicates
+                    while (left < right && nums[left] == nums[left - 1]) left++; // Skip duplicates
+                }
+            }
+        }
+        return result;
+    }
+
+    public List<List<Integer>> getQuadrupletsWithSumTarget(int[] nums, int target) {
+        QuickSort quickSort = new QuickSort();
+        quickSort.sort(nums, 0, nums.length - 1);
+        List<List<Integer>> result = new ArrayList<>();
+        int n = nums.length;
+
+        for (int i = 0; i < n - 3; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue; // Skip duplicates
+            for (int j = i+1; j < n - 2; j++) {
+                if (j > i+1 && nums[j] == nums[j-1]) continue;
+                int left = j + 1;
+                int right = n - 1;
+
+                while (left < right) {
+                    long sum = safeAdd(nums[i], nums[j], nums[left], nums[right]);
+                    if (sum < target) {
+                        left++;
+                    } else if (sum > target) {
+                        right--;
+                    } else {
+                        result.add(List.of(nums[i], nums[j], nums[left], nums[right]));
+                        left++;
+                        right--;
+                        while (left < right && nums[right] == nums[right + 1]) right--; // Skip duplicates
+                        while (left < right && nums[left] == nums[left - 1]) left++; // Skip duplicates
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private long safeAdd(long a, long b, long c, long d) {
+        return a + b + c + d;
+    }
+}

src/com/dsa/arrays/TwoSumProblem.java

@@ -0,0 +1,86 @@
+package com.dsa.arrays;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class TwoSumProblem {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            int k = Integer.parseInt(reader.readLine().trim());
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            TwoSumProblem solution = new TwoSumProblem();
+            System.out.println(Arrays.toString(solution.twoSumOptimized(arr, k)));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int[] twoSum(int[] nums, int target) {
+        int[] answer = {-1, -1};
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int reqNum = target - nums[i];
+            int index = map.getOrDefault(reqNum, -1);
+            if (index != -1) {
+                answer[0] = index;
+                answer[1] = i;
+                return answer;
+            }
+            map.put(nums[i],i);
+        }
+        return answer;
+    }
+
+    public int[] twoSumOptimized(int[] nums, int target) {
+        int[][] sorted2dArr = new int[nums.length][2];
+        for (int i=0; i<nums.length; i++) {
+            sorted2dArr[i][0] = nums[i];
+            sorted2dArr[i][1] = i;
+        }
+        sort(sorted2dArr, 0, sorted2dArr.length-1);
+        int i = 0; 
+        int j = sorted2dArr.length - 1;
+        while (i < j) {
+            int sum = sorted2dArr[i][0] + sorted2dArr[j][0];
+            if (sum < target) i++;
+            else if (sum > target) j--;
+            else {
+                return new int[] {sorted2dArr[i][1], sorted2dArr[j][1]};
+            }
+        }
+        return new int[]{-1, -1};
+    }
+
+    public void sort(int[][] arr, int low, int high) {
+        if (low >= high) return;
+        int i = low;
+        int j = high;
+        int[] pivot = arr[low];
+
+        while (i < j) {
+            while (i <= high && arr[i][0] <= pivot[0]) i++;
+            while (j >= low && arr[j][0] > pivot[0]) j--;
+            if (i < j) {
+                int[] temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+            }
+        }
+
+        if (j != low) {
+            arr[low] = arr[j];
+            arr[j] = pivot;
+        }
+        sort(arr, low, j-1);
+        sort(arr, j+1, high);
+    }
+}

src/com/dsa/binarysearch/AggressiveCows.java

@@ -0,0 +1,57 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class AggressiveCows {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] stallsPositions = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(stallsPositions[i].trim());
+            }
+            AggressiveCows solution = new AggressiveCows();
+            System.out.println("Stall Positions: " + Arrays.toString(arr) + ", Aggressive Cows: " + k);
+            System.out.println("Maximum Possible Minimum Distance: " + solution.getMaxOfMinDistance(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMaxOfMinDistance(int[] stalls, int cows) {
+        Arrays.sort(stalls);
+        int left = 1;
+        int right = stalls[stalls.length - 1] - stalls[0];
+
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (canPlaceCows(stalls, cows, mid)){
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return right;
+    }
+
+    private boolean canPlaceCows(int[] stalls, int cows, int minDist) {
+        int count = 1;
+        int lastPosition = stalls[0];
+
+        for (int i = 1; i< stalls.length; i++) {
+            if (stalls[i] - lastPosition >= minDist) {
+                count ++;
+                lastPosition = stalls[i];
+                if (count >= cows) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/com/dsa/binarysearch/BookAllocation.java

@@ -0,0 +1,68 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class BookAllocation {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] stallsPositions = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(stallsPositions[i].trim());
+            }
+            BookAllocation solution = new BookAllocation();
+            System.out.println("Book Pages: " + Arrays.toString(arr) + ", Students: " + k);
+            System.out.println("Minimum Possible maximum pages for a student: " + solution.getMinOfMaxPages(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMinOfMaxPages(int[] pages, int students) {
+        int[] maxAndSum = getMaxAndSumOfArray(pages);
+        int left = maxAndSum[0];
+        int right = maxAndSum[1];
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (canAllocateBooks(pages, students, mid)){
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean canAllocateBooks(int[] pages, int students, int maxPages) {
+        int count = 1;
+        int currentSum = 0;
+
+        for (int page : pages) {
+            if (currentSum + page > maxPages) {
+                count++;
+                currentSum = page;
+                if (count > students) {
+                    return false;
+                }
+            } else {
+                currentSum += page;
+            }
+        }
+        return true;
+    }
+
+    private int[] getMaxAndSumOfArray(int[] arr) {
+        int max = arr[0];
+        int sum = 0;
+        for (int num : arr) {
+            max = Math.max(max, num);
+            sum += num;
+        }
+        return new int[]{max, sum};
+    }
+}

src/com/dsa/binarysearch/DaysToMakeBouque.java

@@ -0,0 +1,72 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class DaysToMakeBouque {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] pileNumbers = reader.readLine().trim().split(",");
+            int m = Integer.parseInt(reader.readLine().trim());
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] flowers = new int[n];
+            for (int i = 0; i < n; i++) {
+                flowers[i] = Integer.parseInt(pileNumbers[i].trim());
+            }
+            DaysToMakeBouque solution = new DaysToMakeBouque();
+            System.out.println("Minimum days to make bouques: " + solution.minDays(flowers, m, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int minDays(int[] bloomDays, int m, int k) {
+        long product = (long) m * k;
+        if (bloomDays.length < product) {
+            return -1;
+        }
+        int[] minMax = getMinMaxDays(bloomDays);
+        long low = minMax[0];
+        long high = minMax[1];
+        while (low <= high) {
+            long mid = (low + high) / 2;
+            if (canMakeBouques(bloomDays, m, k, Math.toIntExact(mid))) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return Math.toIntExact(low);
+    }
+
+    private int[] getMinMaxDays(int[] bloomDays) {
+        int min = bloomDays[0];
+        int max = bloomDays[0];
+        for (int day : bloomDays) {
+            if (day < min) {
+                min = day;
+            }
+            if (day > max) {
+                max = day;
+            }
+        }
+        return new int[]{min, max};
+    }
+
+    private boolean canMakeBouques(int[] bloomDays, int m, int k, int days) {
+        int bouquesMade = 0;
+        int currentCount = 0;
+        for (int day : bloomDays ) {
+            if (day <= days) {
+                currentCount++;
+            } else {
+                bouquesMade += currentCount/k;
+                currentCount = 0;
+            }
+        }
+        bouquesMade += currentCount/k;
+        return bouquesMade >= m;
+    }
+}

src/com/dsa/binarysearch/FindElement.java

@@ -0,0 +1,56 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class FindElement {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numToFind = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            FindElement solution = new FindElement();
+            int element = solution.getElement(arr, numToFind);
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            System.out.println(element);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getElement(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (target > nums[mid]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return -1;
+    }
+
+    public int getElementRecursive(int[] nums, int target, int left, int right) {
+        if (left > right) {
+            return -1;
+        }
+        int mid = (left + right) / 2;
+        if (nums[mid] == target) {
+            return mid;
+        } else if (target > nums[mid]) {
+            return getElementRecursive(nums, target, mid+1, right);
+        } else {
+            return getElementRecursive(nums, target, left, mid-1);
+        }
+    }
+}

src/com/dsa/binarysearch/FirstAndLastOccurrence.java

@@ -0,0 +1,65 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class FirstAndLastOccurrence {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numToFind = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            FirstAndLastOccurrence solution = new FirstAndLastOccurrence();
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            int[] occurrences = solution.getFirstAndLastOccurrence(arr, numToFind);
+            System.out.println("First and Last Occurrence: " + Arrays.toString(occurrences));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int[] getFirstAndLastOccurrence(int[] nums, int target) {
+        int[] result = new int[]{-1, -1};
+        int index = getElement(nums, target);
+        if (index == -1) {
+            return result;
+        }
+        int count = 1;
+        int left = index - 1;
+        int right = index + 1;
+        while (left >= 0 && nums[left] == target) {
+            count++;
+            left--;
+        }
+        while (right < nums.length && nums[right] == target) {
+            count++;
+            right++;
+        }
+        result[0] = left + 1;
+        result[1] = right - 1;
+        System.out.println("Count of occurrences: " + count);
+        return result;
+    }
+
+    private int getElement(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (target > nums[mid]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return -1;
+    }
+}

src/com/dsa/binarysearch/KokoEatingBananas.java

@@ -0,0 +1,59 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class KokoEatingBananas {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] pileNumbers = reader.readLine().trim().split(",");
+            int hours = Integer.parseInt(reader.readLine().trim());
+            int[] piles = new int[n];
+            for (int i = 0; i < n; i++) {
+                piles[i] = Integer.parseInt(pileNumbers[i].trim());
+            }
+            KokoEatingBananas solution = new KokoEatingBananas();
+            System.out.println("Minimum eating speed: " + solution.minEatingSpeed(piles, hours));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int minEatingSpeed(int[] piles, int h) {
+        long left = 1;
+        long right = getMaxPile(piles);
+        long result = right;
+
+        while (left <= right) {
+            long mid = (left + right) / 2L;
+            if (canFinish(piles, h, Math.toIntExact(mid))) {
+                result = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return Math.toIntExact(result);
+    }
+
+    private int getMaxPile(int[] piles) {
+        int max = piles[0];
+        for (int pile : piles) {
+            max = Math.max(max, pile);
+        }
+        return max;
+    }
+
+    private boolean canFinish(int[] piles, int h, int speed) {
+        int hoursNeeded = 0;
+        for (int pile : piles) {
+            hoursNeeded += (pile + speed - 1) / speed; // Ceiling division
+            if (hoursNeeded > h) {
+                return false;
+            }
+        }
+        return hoursNeeded <= h;
+    }
+}

src/com/dsa/binarysearch/KthMissingNumber.java

@@ -0,0 +1,58 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class KthMissingNumber {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] numbers = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(numbers[i].trim());
+            }
+            KthMissingNumber solution = new KthMissingNumber();
+            System.out.println("Input Array: " + Arrays.toString(arr) + ", K: " + k);
+            System.out.println("Kth Missing Number: " + solution.getMissingNumber(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMissingNumber(int[] nums, int k) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            int missingCount = nums[mid] - mid - 1;
+            if (missingCount < k) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        /*
+        After the loop, the left pointer indicates the position where the kth missing number would fit.
+        Eg: 2, 3, 4, 7, 11 and k = 5
+        Missing numbers are 1, 5, 6, 8, 9, 10, ...
+        At the end of the loop, left = 4 (pointing to 11)
+        and right = 3 (pointing to 7)
+        The missing number would be between 7 and 11.
+        So to get the 5th missing number, we calculate it as:
+        nums[high] + k - missingCount at high
+        missingCount at index 3 (value 7) = 7 - 3 - 1 = 3
+        So, 7 + 5 - 3 = 9
+        we can rewrite nums[high] + k - (nums[high] - high - 1)
+        which simplifies to nums[high] + k - nums[high] + high + 1
+        which further simplifies to high + k + 1
+        Since high = left - 1, we can rewrite it as:
+        (left - 1) + k + 1 = left + k
+         */
+        return left + k;
+    }
+}

src/com/dsa/binarysearch/LargestMinimizedSumSubArray.java

@@ -0,0 +1,68 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class LargestMinimizedSumSubArray {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] stallsPositions = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(stallsPositions[i].trim());
+            }
+            var solution = new LargestMinimizedSumSubArray();
+            System.out.println("Array: " + Arrays.toString(arr) + ", SubArrays Length: " + k);
+            System.out.println("Minimum Possible maximum sum in a sub array: " + solution.getMaxSumMinimized(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMaxSumMinimized(int[] nums, int k) {
+        int[] maxAndSum = getMaxAndSumOfArray(nums);
+        int left = maxAndSum[0];
+        int right = maxAndSum[1];
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (canSplitArray(nums, k, mid)){
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean canSplitArray(int[] nums, int k, int maxSum) {
+        int count = 1;
+        int currentSum = 0;
+
+        for (int page : nums) {
+            if (currentSum + page > maxSum) {
+                count++;
+                currentSum = page;
+                if (count > k) {
+                    return false;
+                }
+            } else {
+                currentSum += page;
+            }
+        }
+        return true;
+    }
+
+    private int[] getMaxAndSumOfArray(int[] arr) {
+        int max = arr[0];
+        int sum = 0;
+        for (int num : arr) {
+            max = Math.max(max, num);
+            sum += num;
+        }
+        return new int[]{max, sum};
+    }
+}

src/com/dsa/binarysearch/LowerAndUpperBound.java

@@ -0,0 +1,90 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class LowerAndUpperBound {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numToFind = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            LowerAndUpperBound solution = new LowerAndUpperBound();
+            int lowerBound = solution.getLowerBound(arr, numToFind);
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            System.out.println("Lower Bound: " + lowerBound);
+            int upperBound = solution.getUpperBound(arr, numToFind);
+            System.out.println("Upper Bound: " + upperBound);
+            int floor = solution.getFloor(arr, numToFind);
+            System.out.println("Floor: " + floor);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getLowerBound(int[] nums, int target) {
+        int ans = nums.length;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] > target) {
+                ans = mid;
+                right = mid - 1;
+            } else if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                ans = mid;
+                break;
+            }
+        }
+        while (ans - 1 >= 0 && nums[ans - 1] == target) {
+            ans--;
+        }
+        return ans;
+    }
+
+    public int getUpperBound(int[] nums, int target) {
+        int ans = nums.length;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] > target) {
+                ans = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return ans;
+    }
+
+    public int getFloor(int[] nums, int target) {
+        int ans = -1;
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] > target) {
+                right = mid - 1;
+            } else if (nums[mid] < target) {
+                ans = mid;
+                left = mid + 1;
+            } else {
+                ans = mid;
+                break;
+            }
+        }
+        while (ans - 1 >= 0 && nums[ans - 1] == target) {
+            ans--;
+        }
+        return ans;
+    }
+}

src/com/dsa/binarysearch/MatrixMedian.java

@@ -0,0 +1,66 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MatrixMedian {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int rows = Integer.parseInt(reader.readLine().trim());
+            int[][] matrix = new int[rows][];
+            for (int i = 0; i < rows; i++) {
+                String[] line = reader.readLine().split(" ");
+                matrix[i] = new int[line.length];
+                for (int j = 0; j < line.length; j++) {
+                    matrix[i][j] = Integer.parseInt(line[j].trim());
+                }
+            }
+            var solution = new MatrixMedian();
+            System.out.println("Matrix:");
+            for (int[] row : matrix) {
+                System.out.println(Arrays.toString(row));
+            }
+            System.out.println("Median: " + solution.getMedian(matrix));
+        } catch (IOException ioe) {
+            throw new RuntimeException(ioe);
+        }
+    }
+
+    public int getMedian(int[][] mat) {
+        var lowerUpperBound = new LowerAndUpperBound();
+        int[] minMax = getMinMaxNumbers(mat);
+        int low = minMax[0];
+        int high = minMax[1];
+        int desiredCount = (mat.length * mat[0].length) / 2;
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            for (int[] arr : mat) {
+                int count = lowerUpperBound.getUpperBound(arr, mid); //technically gives count of numbers <= mid in BiSe way
+                desiredCount -= count;
+            }
+            if (desiredCount >= 0) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+            desiredCount = (mat.length * mat[0].length) / 2;
+        }
+        return low;
+    }
+
+    public int[] getMinMaxNumbers(int[][] mat) {
+        int min = mat[0][0];
+        int max = mat[0][mat[0].length - 1];
+        for (int i = 1; i < mat.length; i++) {
+            if (mat[i][0] < min) {
+                min = mat[i][0];
+            }
+            if (mat[i][mat[i].length - 1] > max) {
+                max = mat[i][mat[i].length - 1];
+            }
+        }
+        return new int[]{min, max};
+    }
+}

src/com/dsa/binarysearch/MedianAndKthElementOfTwoSortedArrays.java

@@ -0,0 +1,94 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MedianAndKthElementOfTwoSortedArrays {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] line1 = reader.readLine().trim().split(",");
+            String[] line2 = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr1 = new int[line1.length];
+            int[] arr2 = new int[line2.length];
+            for (int i = 0; i < line1.length; i++) {
+                arr1[i] = Integer.parseInt(line1[i].trim());
+            }
+            for (int i = 0; i < line2.length; i++) {
+                arr2[i] = Integer.parseInt(line2[i].trim());
+            }
+            var solution = new MedianAndKthElementOfTwoSortedArrays();
+            System.out.println("Array 1: " + Arrays.toString(arr1));
+            System.out.println("Array 2: " + Arrays.toString(arr2));
+            System.out.println("Median of Two Sorted Arrays: " + solution.findMedianSortedArrays(arr1, arr2));
+            System.out.println("-------------------------------------");
+            System.out.println("Kth Element of Two Sorted Arrays: " + solution.findKthElementOfTwoSortedArrays(arr1, arr2, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        if ((nums1.length > nums2.length && nums2.length != 0) || nums1.length == 0) {
+            return findMedianSortedArrays(nums2, nums1);
+        }
+        int requiredNumsOnLeft = ((nums1.length + nums2.length + 1) / 2);
+        int left = 0;
+        int right = nums1.length - 1;
+        while (left <= right) {
+            int partitionNums1 = (left + right) / 2;
+            int partitionNums2 = requiredNumsOnLeft - partitionNums1 - 1;
+            int l1 = partitionNums1 >= 0 ? nums1[partitionNums1] : Integer.MIN_VALUE;
+            int l2 = partitionNums2 - 1 >= 0 ? nums2[partitionNums2 - 1] : Integer.MIN_VALUE;
+            int r1 = partitionNums1 + 1 < nums1.length ? nums1[partitionNums1 + 1] : Integer.MAX_VALUE;
+            int r2 = partitionNums2 < nums2.length ? nums2[partitionNums2] : Integer.MAX_VALUE;
+            if (l1 <= r2 && l2 <= r1) {
+                if ((nums1.length + nums2.length) % 2 == 0) {
+                    return (double) (Math.max(l1, l2) + Math.min(r1, r2)) / 2.0;
+                }
+                return Math.max(l1,l2);
+            } else if (l1 > r2) {
+                right = partitionNums1 - 1;
+            } else {
+                left = partitionNums1 + 1;
+            }
+        }
+        int l2 = requiredNumsOnLeft - 1 >= 0 ? nums2[requiredNumsOnLeft - 1] : Integer.MIN_VALUE;
+        int r1 = nums1[0];
+        int r2 = requiredNumsOnLeft < nums2.length ? nums2[requiredNumsOnLeft] : Integer.MAX_VALUE;
+        if ((nums1.length + nums2.length) % 2 == 0) {
+            return (double) (l2 + Math.min(r1, r2)) / 2.0;
+        }
+        return l2;
+    }
+
+    public int findKthElementOfTwoSortedArrays(int[] nums1, int[] nums2, int k) {
+        if ((nums1.length > nums2.length && nums2.length != 0) || nums1.length == 0) {
+            return findKthElementOfTwoSortedArrays(nums2, nums1, k);
+        }
+        int left = Math.max(0, k - nums2.length);
+        int right = Math.min(nums1.length - 1, k);
+        while (left <= right) {
+            int partitionNums1 = (left + right) / 2;
+            int partitionNums2 = k - partitionNums1 - 1;
+            int l1 = partitionNums1 >= 0 ? nums1[partitionNums1] : Integer.MIN_VALUE;
+            if (partitionNums2 - 1 >= nums2.length) {
+                left = partitionNums1 + 1;
+                continue;
+            }
+            int l2 = partitionNums2 - 1 >= 0 ? nums2[partitionNums2 - 1] : Integer.MIN_VALUE;
+            int r1 = partitionNums1 + 1 < nums1.length ? nums1[partitionNums1 + 1] : Integer.MAX_VALUE;
+            int r2 = partitionNums2 < nums2.length ? nums2[partitionNums2] : Integer.MAX_VALUE;
+            if (l1 <= r2 && l2 <= r1) {
+                return Math.max(l1, l2);
+            } else if (l1 > r2) {
+                right = partitionNums1 - 1;
+            } else {
+                left = partitionNums1 + 1;
+            }
+        }
+        return nums2[k - 1];
+    }
+}

src/com/dsa/binarysearch/MinCapacityToShipInDDays.java

@@ -0,0 +1,55 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.IntSummaryStatistics;
+
+public class MinCapacityToShipInDDays {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] numbers = reader.readLine().trim().split(",");
+            int days = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(numbers[i].trim());
+            }
+            MinCapacityToShipInDDays solution = new MinCapacityToShipInDDays();
+            System.out.println("Input Array: " + Arrays.toString(arr) + ", Days: " + days);
+            System.out.println("Min capacity of the Ship: " + solution.getMinCapacity(arr, days));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMinCapacity(int[] nums, int days) {
+        IntSummaryStatistics stats = Arrays.stream(nums).summaryStatistics();
+        long left = stats.getMax();
+        long right = stats.getSum();
+
+        while (left <= right) {
+            long mid = (left + right) / 2;
+            if (getRequiredDays(nums, Math.toIntExact(mid)) <= days) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return Math.toIntExact(left);
+    }
+
+    private int getRequiredDays(int[] nums, int capacity) {
+        int dayCount = 1;
+        int currentLoad = 0;
+        for (int num : nums) {
+            currentLoad += num;
+            if (currentLoad > capacity) {
+                dayCount++;
+                currentLoad = num;
+            }
+        }
+        return dayCount;
+    }
+}

src/com/dsa/binarysearch/MinimizeDistanceGasStations.java

@@ -0,0 +1,103 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.PriorityQueue;
+
+public class MinimizeDistanceGasStations {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] stallsPositions = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(stallsPositions[i].trim());
+            }
+            var solution = new MinimizeDistanceGasStations();
+            System.out.println("Gas Station Positions: " + Arrays.toString(arr) + ", New Gas Stations to Place: " + k);
+            System.out.println("Minimum Possible maximum distance: " + solution.getMaxDistanceAfterPlacing(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public double getMaxDistanceAfterPlacing(int[] positions, int k) {
+        PriorityQueue<Pair<Double, Integer>> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
+        for (int i = 0, j = 0; i < positions.length - 1; i++, j++) {
+            double gap = positions[i + 1] - positions[i];
+            maxHeap.offer(new Pair<>(gap, j));
+        }
+
+        int[] gapsBetweenStations = new int[positions.length - 1];
+
+        for (int i = 1; i <= k; i++) {
+            Pair<Double, Integer> largestGapPair = Optional.ofNullable(maxHeap.poll()).orElse(new Pair<>(0.0,0));;
+            int index = largestGapPair.second;
+            double gap = positions[index + 1] - positions[index];
+            gapsBetweenStations[index]++;
+            double newGap = gap / (gapsBetweenStations[index] + 1);
+            maxHeap.offer(new Pair<>(newGap, index));
+        }
+
+        return Optional.ofNullable(maxHeap.poll()).orElse(new Pair<>(0.0,0)).first;
+    }
+
+    public double getMaxDistanceAfterPlacingOptimal(int[] positions, int k) {
+        int maxDistance = getMaxDistance(positions);
+        double left = 0;
+        double right = maxDistance;
+        while ((right - left) > 1e-6) {
+            double mid = (left + right) / 2.0;
+            if (getRequiredStations(positions, k, mid) <= k){
+                right = mid;
+            } else {
+                left = mid;
+            }
+        }
+        return right;
+    }
+
+    private int getRequiredStations(int[] positions, int k, double distance) {
+        int count = 0;
+        for (int i = 0;  i < positions.length - 1; i++) {
+            int gap = positions[i + 1] - positions[i];
+            count += (int)(gap / distance);
+            if (gap % distance == 0) {
+                count--;
+            }
+            if (count > k) {
+                return count;
+            }
+        }
+        return count;
+    }
+
+    private int getMaxDistance(int[] arr) {
+        int max = 0;
+        for (int i = 0; i < arr.length - 1; i++) {
+            max = Math.max(max, arr[i + 1] - arr[i]);
+        }
+        return max;
+    }
+
+    private static class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>> {
+        S first;
+        T second;
+
+        Pair(S first, T second) {
+            this.first = first;
+            this.second = second;
+        }
+
+        @Override
+        public int compareTo(Pair<S, T> stPair) {
+            int firstComp = this.first.compareTo(stPair.first);
+            return firstComp == 0 ? this.second.compareTo(stPair.second) : firstComp;
+        }
+    }
+}

src/com/dsa/binarysearch/NthRoot.java

@@ -0,0 +1,43 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class NthRoot {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            int m = Integer.parseInt(reader.readLine().trim());
+            NthRoot solution = new NthRoot();
+            System.out.println(n + " root of " + m + " is: " + solution.nthRoot(n, m));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int nthRoot(int n, int m) {
+        if (m == 1) return 1;
+        int low = 1;
+        int high = m/n;
+        while (low <= high) {
+            long mid = (low + high) / 2;
+            long power = 1;
+            for (int i = 0; i < n; i++) {
+                power *= mid;
+                if (power > m) {
+                    break;
+                }
+            }
+            if (power == m) {
+                return Math.toIntExact(mid);
+            } else if (power < m) {
+                low = Math.toIntExact(mid) + 1;
+            } else {
+                high = Math.toIntExact(mid) - 1;
+            }
+        }
+        return -1;
+
+    }
+}

src/com/dsa/binarysearch/PainterPartition.java

@@ -0,0 +1,67 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class PainterPartition {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] stallsPositions = reader.readLine().trim().split(",");
+            int k = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(stallsPositions[i].trim());
+            }
+            var solution = new PainterPartition();
+            System.out.println("Board Lengths: " + Arrays.toString(arr) + ", Painters: " + k);
+            System.out.println("Minimum Possible maximum time to complete: " + solution.getMaxSumMinimized(arr, k));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getMaxSumMinimized(int[] boardLengths, int painters) {
+        int[] maxAndSum = getMaxAndSumOfArray(boardLengths);
+        int left = maxAndSum[0];
+        int right = maxAndSum[1];
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (canSplitArray(boardLengths, painters, mid)){
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean canSplitArray(int[] boardLengths, int painters, int maxSum) {
+        int currentSum = 0;
+        int count = 1;
+        for (int page : boardLengths) {
+            if (currentSum + page > maxSum) {
+                count++;
+                currentSum = page;
+                if (count > painters) {
+                    return false;
+                }
+            } else {
+                currentSum += page;
+            }
+        }
+        return true;
+    }
+
+    private int[] getMaxAndSumOfArray(int[] arr) {
+        int max = arr[0];
+        int sum = 0;
+        for (int num : arr) {
+            max = Math.max(max, num);
+            sum += num;
+        }
+        return new int[]{max, sum};
+    }
+}

src/com/dsa/binarysearch/PeakElement.java

@@ -0,0 +1,45 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class PeakElement {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            PeakElement solution = new PeakElement();
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            int singleElement = solution.getPeakElement(arr);
+            System.out.println("Peak Element in array: " + singleElement);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getPeakElement(int[] nums) {
+        if (nums.length == 1) return 0;
+        if (nums[0] > nums[1]) return 0;
+        if (nums[nums.length - 1] > nums[nums.length - 2]) return nums.length - 1;
+        int left = 1;
+        int right = nums.length - 2;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] > nums[mid - 1] && nums[mid] > nums[mid + 1]) {
+                return mid;
+            } else if (nums[mid] < nums[mid + 1]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return -1;
+    }
+
+}

src/com/dsa/binarysearch/PeakElementMatrix.java

@@ -0,0 +1,97 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class PeakElementMatrix {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int rows = Integer.parseInt(reader.readLine().trim());
+            int[][] matrix = new int[rows][];
+            for (int i = 0; i < rows; i++) {
+                String[] line = reader.readLine().split(",");
+                matrix[i] = new int[line.length];
+                for (int j = 0; j < line.length; j++) {
+                    matrix[i][j] = Integer.parseInt(line[j].trim());
+                }
+            }
+            var solution = new PeakElementMatrix();
+            System.out.println("Matrix:");
+            for (int[] row : matrix) {
+                System.out.println(Arrays.toString(row));
+            }
+            System.out.println("Peak element indices: " + Arrays.toString(solution.getPeakIndices(matrix)));
+        } catch (IOException ioe) {
+            throw new RuntimeException(ioe);
+        }
+    }
+
+    public int[] getPeakIndices(int[][] mat) {
+        int rows = mat.length;
+        int cols = mat[0].length;
+        if (rows > cols) {
+            return solveByRow(mat, rows, cols);
+        }
+        return solveByColumn(mat, rows, cols);
+    }
+
+    private int[] solveByRow(int[][] mat, int rows, int cols) {
+        int top = 0;
+        int bottom = rows - 1;
+        while (top <= bottom) {
+            int midRow = (top + bottom) / 2;
+            int maxColIndex = getMaxColIndex(mat, midRow, cols);
+            int upVal = (midRow - 1 >= 0) ? mat[midRow - 1][maxColIndex] : -1;
+            int downVal = (midRow + 1 < rows) ? mat[midRow + 1][maxColIndex] : -1;
+            if(mat[midRow][maxColIndex] > upVal && mat[midRow][maxColIndex] > downVal) {
+                return new int[]{midRow, maxColIndex};
+            } else if (downVal > mat[midRow][maxColIndex]) {
+                top = midRow + 1;
+            } else {
+                bottom = midRow - 1;
+            }
+        }
+        return new int[]{-1, -1};
+    }
+
+    private int getMaxColIndex(int[][] mat, int row, int cols) {
+        int maxColIndex = 0;
+        for (int col = 1; col < cols; col++) {
+            if (mat[row][col] > mat[row][maxColIndex]) {
+                maxColIndex = col;
+            }
+        }
+        return maxColIndex;
+    }
+
+    private int[] solveByColumn(int[][] mat, int rows, int cols) {
+        int left = 0;
+        int right = cols - 1;
+        while (left <= right) {
+            int midCol = (left + right) / 2;
+            int maxRowIndex = getMaxRowIndex(mat, midCol, rows);
+            int leftVal = (midCol - 1 >= 0) ? mat[maxRowIndex][midCol - 1] : -1;
+            int rightVal = (midCol + 1 < cols) ? mat[maxRowIndex][midCol + 1] : -1;
+            if(mat[maxRowIndex][midCol] > leftVal && mat[maxRowIndex][midCol] > rightVal) {
+                return new int[]{maxRowIndex, midCol};
+            } else if (rightVal >  mat[maxRowIndex][midCol]) {
+                left = midCol + 1;
+            } else {
+                right = midCol - 1;
+            }
+        }
+        return new int[]{-1, -1};
+    }
+
+    private int getMaxRowIndex(int[][] mat, int col, int rows) {
+        int maxRowIndex = 0;
+        for (int row = 1; row < rows; row++) {
+            if (mat[row][col] > mat[maxRowIndex][col]) {
+                maxRowIndex = row;
+            }
+        }
+        return maxRowIndex;
+    }
+}

src/com/dsa/binarysearch/SearchIn2DMatrix.java

@@ -0,0 +1,66 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SearchIn2DMatrix {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int rows = Integer.parseInt(reader.readLine().trim());
+            int[][] matrix = new int[rows][];
+            for (int i = 0; i < rows; i++) {
+                String[] line = reader.readLine().split(",");
+                matrix[i] = new int[line.length];
+                for (int j = 0; j < line.length; j++) {
+                    matrix[i][j] = Integer.parseInt(line[j].trim());
+                }
+            }
+            int target = Integer.parseInt(reader.readLine().trim());
+            var solution = new SearchIn2DMatrix();
+            System.out.println("Matrix:");
+            for (int[] row : matrix) {
+                System.out.println(Arrays.toString(row));
+            }
+            System.out.println("Target to Search: " + target);
+//            System.out.println("Is Target Present: " + solution.searchMatrix(matrix, target));
+            System.out.println("Is Target Present: " + solution.searchInRowAndColumnWiseSortedMatrix(matrix, target));
+        } catch (IOException ioe) {
+            throw new RuntimeException(ioe);
+        }
+    }
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int left = 0;
+        int right = matrix.length * matrix[0].length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            int row = mid/matrix[0].length;
+            int col = mid % matrix[0].length;
+            if (matrix[row][col] == target) {
+                return true;
+            } else if (matrix[row][col] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return false;
+    }
+
+    public boolean searchInRowAndColumnWiseSortedMatrix(int[][] matrix, int target) {
+        int row = 0;
+        int col = matrix[0].length - 1;
+        while (row < matrix.length && col >= 0) {
+            if (matrix[row][col] < target) {
+                row++;
+            } else if (matrix[row][col] > target) {
+                col--;
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/com/dsa/binarysearch/SearchInRotatedSortedArray.java

@@ -0,0 +1,83 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SearchInRotatedSortedArray {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numToFind = Integer.parseInt(reader.readLine().trim());
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SearchInRotatedSortedArray solution = new SearchInRotatedSortedArray();
+            int element = solution.getElement(arr, numToFind);
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            System.out.println("Element Index: " + element);
+            System.out.println("No. of Rotations: " + solution.countRotations(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private int getPivot(int[] nums) { //minimum element's index
+        if (nums.length == 1) return nums[0];
+        int index = 0;
+        int left = 0;
+        int right = nums.length - 1;
+        int ans = Integer.MAX_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[left] <= nums[mid] && nums[mid] <= nums[right]) {
+                left++;
+                right--;
+                continue;
+            }
+            if (nums[mid] >= nums[left]) {
+                if (nums[left] <= ans) {
+                    ans = nums[left];
+                    index = left;
+                }
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+                if (nums[mid] <= ans) {
+                    ans = nums[mid];
+                    index = mid;
+                }
+            }
+        }
+        return index;
+    }
+
+    public int getElement(int[] nums, int target) {
+        int pivot = getPivot(nums);
+        if (target >= nums[pivot] && target <= nums[nums.length - 1]) {
+            return binarySearch(nums, target, pivot, nums.length - 1);
+        }
+        return binarySearch(nums, target, 0, pivot - 1);
+    }
+
+    private int binarySearch(int[] nums, int target, int left, int right) {
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (target > nums[mid]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return -1;
+    }
+
+    public int countRotations(int[] nums) {
+        return getPivot(nums);
+    }
+}

src/com/dsa/binarysearch/SingleElement.java

@@ -0,0 +1,42 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SingleElement {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SingleElement solution = new SingleElement();
+            System.out.println("Input Array: " + Arrays.toString(arr));
+            int singleElement = solution.getSingleElement(arr);
+            System.out.println("Single Element in array: " + singleElement);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getSingleElement(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (mid % 2 == 1) {
+                mid--; // make mid even
+            }
+            if (nums[mid] == nums[mid + 1]) {
+                left = mid + 2;
+            } else {
+                right = mid;
+            }
+        }
+        return nums[left];
+    }
+}

src/com/dsa/binarysearch/SmallestDivisor.java

@@ -0,0 +1,61 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SmallestDivisor {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int n = Integer.parseInt(reader.readLine().trim());
+            String[] pileNumbers = reader.readLine().trim().split(",");
+            int limit = Integer.parseInt(reader.readLine().trim());
+            int[] arr = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(pileNumbers[i].trim());
+            }
+            SmallestDivisor solution = new SmallestDivisor();
+            System.out.println("Input Array: " + Arrays.toString(arr) + ", Limit: " + limit);
+            System.out.println("Smallest Divisor: " + solution.getSmallestDivisor(arr, limit));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getSmallestDivisor(int[] nums, int threshold) {
+        int max = getMax(nums);
+        long left = 1;
+        long right = max;
+        while (left <= right) {
+            long mid = (left + right) / 2;
+            if (canDivide(nums, Math.toIntExact(mid), threshold)) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return Math.toIntExact(left);
+    }
+
+    private int getMax(int[] nums) {
+        int max = nums[0];
+        for (int num : nums) {
+            if (num > max) {
+                max = num;
+            }
+        }
+        return max;
+    }
+
+    private boolean canDivide(int[] nums, int divisor, int threshold) {
+        long total = 0;
+        for (int num : nums) {
+            total += (num + divisor - 1) / divisor; // Ceiling division
+            if (total > threshold) {
+                return false;
+            }
+        }
+        return total <= threshold;
+    }
+}

src/com/dsa/binarysearch/SquareRoot.java

@@ -0,0 +1,35 @@
+package com.dsa.binarysearch;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class SquareRoot {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            int number = Integer.parseInt(reader.readLine().trim());
+            SquareRoot solution = new SquareRoot();
+            System.out.println("Square root or Nearest Square root of " + number + " is: " + solution.sqrt(number));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int sqrt(int x) {
+        if (x == 1 || x == 2) return 1;
+        int low = 1;
+        int high = x / 2;
+        while (low <= high) {
+            long mid = (low + high) / 2;
+            long sqr = mid * mid;
+            if (sqr == x) {
+                return Math.toIntExact(mid);
+            } else if (sqr < x) {
+                low = Math.toIntExact(mid) + 1;
+            } else {
+                high = Math.toIntExact(mid) - 1;
+            }
+        }
+        return high;
+    }
+}

src/com/dsa/sorting/BubbleSort.java

@@ -0,0 +1,61 @@
+package com.dsa.sorting;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class BubbleSort {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            BubbleSort solution = new BubbleSort();
+            // solution.sort(arr);
+            solution.recursiveSort(arr, numberOfElements - 1);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void sort(int[] arr) {
+        int n = arr.length;
+        for (int i = n - 1; i > 0; i--) {
+            boolean swapped = false;
+            for (int j = 0; j < i; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    arr[j] = arr[j] + arr[j + 1];
+                    arr[j + 1] = arr[j] - arr[j + 1];
+                    arr[j] = arr[j] - arr[j + 1];
+                    swapped = true;
+                }
+            }
+            if (!swapped) {
+                break;
+            }
+        }
+    }
+
+    public void recursiveSort(int[] arr, int rightIndex) {
+        if (rightIndex <= 0) {
+            return;
+        }
+        boolean swapped = false;
+        for (int i = 0; i < rightIndex; i++) {
+            if (arr[i] > arr[i + 1]) {
+                int temp = arr[i];
+                arr[i] = arr[i + 1];
+                arr[i + 1] = temp;
+                swapped = true;
+            }
+        }
+        if (!swapped)
+            return;
+        recursiveSort(arr, rightIndex - 1);
+    }
+}

src/com/dsa/sorting/InsertionSort.java

@@ -0,0 +1,51 @@
+package com.dsa.sorting;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class InsertionSort {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            InsertionSort solution = new InsertionSort();
+            // solution.sort(arr);
+            solution.recursiveSort(arr, 1);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void sort(int[] arr) {
+        int n = arr.length;
+        for (int i = 1; i < n; i++) {
+            int j = i - 1;
+            while (j >= 0 && arr[j] > arr[j + 1]) {
+                int temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+                j--;
+            }
+        }
+    }
+
+    public void recursiveSort(int[] arr, int index) {
+        if (index >= arr.length)
+            return;
+        int i = index - 1;
+        while (i >= 0 && arr[i] > arr[i + 1]) {
+            int temp = arr[i];
+            arr[i] = arr[i + 1];
+            arr[i + 1] = temp;
+            i--;
+        }
+        recursiveSort(arr, index + 1);
+    }
+}

src/com/dsa/sorting/MergeSort.java

@@ -0,0 +1,71 @@
+package com.dsa.sorting;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class MergeSort {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            MergeSort solution = new MergeSort();
+            solution.sort(arr, 0, numberOfElements - 1);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void sort(int[] arr, int low, int high) {
+        if (low >= high)
+            return;
+        int mid = (low + high) / 2;
+        sort(arr, low, mid);
+        sort(arr, mid + 1, high);
+        merge(arr, low, mid, high);
+
+    }
+
+    public void merge(int[] arr, int low, int mid, int high) {
+        int[] tempArr = new int[high - low + 1];
+        int left = low;
+        int right = mid + 1;
+
+        int tempArrIdx = 0;
+        while (left <= mid && right <= high) {
+            if (arr[left] <= arr[right]) {
+                tempArr[tempArrIdx] = arr[left];
+                left++;
+            } else {
+                tempArr[tempArrIdx] = arr[right];
+                right++;
+            }
+            tempArrIdx++;
+        }
+
+        while (left <= mid) {
+            tempArr[tempArrIdx] = arr[left];
+            left++;
+            tempArrIdx++;
+        }
+
+        while (right <= high) {
+            tempArr[tempArrIdx] = arr[right];
+            right++;
+            tempArrIdx++;
+        }
+
+        for (int i = low; i <= high; i++) {
+            arr[i] = tempArr[i - low];
+        }
+
+    }
+
+}

src/com/dsa/sorting/QuickSort.java

@@ -0,0 +1,50 @@
+package com.dsa.sorting;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class QuickSort {
+
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(",");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            QuickSort solution = new QuickSort();
+            solution.sort(arr, 0, numberOfElements - 1);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void sort(int[] arr, int low, int high) {
+        if (low >= high) return;
+        int i = low;
+        int j = high;
+        int pivot = arr[low];
+
+        while (i < j) {
+            while (i <= high && arr[i] <= pivot) i++;
+            while (j >= low && arr[j] > pivot) j--;
+            if (i < j) {
+                int temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+            }
+        }
+
+        if (j != low) {
+            arr[low] = arr[j];
+            arr[j] = pivot;
+        }
+        sort(arr, low, j-1);
+        sort(arr, j+1, high);
+    }
+
+}

src/com/dsa/sorting/SelectionSort.java

@@ -0,0 +1,42 @@
+package com.dsa.sorting;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class SelectionSort {
+    public static void main(String[] args) {
+        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
+            String[] elements = reader.readLine().trim().split(" ");
+            int numberOfElements = elements.length;
+            int[] arr = new int[numberOfElements];
+            for (int i = 0; i < numberOfElements; i++) {
+                arr[i] = Integer.parseInt(elements[i].trim());
+            }
+            SelectionSort solution = new SelectionSort();
+            solution.sort(arr);
+            System.out.println(Arrays.toString(arr));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void sort(int[] arr) {
+        int n = arr.length;
+        for (int i = 0; i < n-1; i++) {
+            int minIndex = i;
+            for (int j = i+1; j < n; j++) {
+                if (arr[j] < arr[minIndex]) {
+                    minIndex = j;
+                }
+            }
+            if (minIndex != i) {
+                int temp = arr[i];
+                arr[i] = arr[minIndex];
+                arr[minIndex] = temp;
+            }
+        }
+    }
+
+}