From a0a5a94019e4ac771b79abfda8b7ab5e25a11c94 Mon Sep 17 00:00:00 2001 From: Sri Harsha Damarla Date: Tue, 16 Jun 2026 08:04:32 +0530 Subject: [PATCH] initial commit --- .gitignore | 32 +++++ input.txt | 4 + src/com/dsa/arrays/ArrayUnion.java | 78 ++++++++++++ src/com/dsa/arrays/ConsecutiveOnes.java | 40 ++++++ src/com/dsa/arrays/ConsecutiveSequence.java | 39 ++++++ .../CountInversionsAndReversePairs.java | 119 ++++++++++++++++++ src/com/dsa/arrays/LeftRotateArray.java | 48 +++++++ src/com/dsa/arrays/MajorityElement.java | 76 +++++++++++ .../dsa/arrays/MaxFrequencyKOperations.java | 43 +++++++ .../dsa/arrays/MaxSubArraySumAndProduct.java | 51 ++++++++ src/com/dsa/arrays/MergeTwoSortedArrays.java | 87 +++++++++++++ src/com/dsa/arrays/MissingNumberInArray.java | 40 ++++++ src/com/dsa/arrays/MoveZeroToEnd.java | 42 +++++++ .../NumberThatRepeatsOnceAndOthersTwice.java | 33 +++++ .../dsa/arrays/OverlappingSubIntervals.java | 7 ++ src/com/dsa/arrays/PascalTriangle.java | 70 +++++++++++ .../arrays/RemoveDuplicatesInSortedArray.java | 39 ++++++ src/com/dsa/arrays/RepeatingAndMissing.java | 52 ++++++++ .../SecondLargestAndSecondSmallest.java | 44 +++++++ src/com/dsa/arrays/SetMatricZeroes.java | 59 +++++++++ src/com/dsa/arrays/SortZeroOneTwo.java | 47 +++++++ src/com/dsa/arrays/SpiralMatrixTraversal.java | 59 +++++++++ src/com/dsa/arrays/StockBuySell.java | 38 ++++++ src/com/dsa/arrays/SubArrayWithSumK.java | 80 ++++++++++++ src/com/dsa/arrays/SubArrayWithXorK.java | 38 ++++++ src/com/dsa/arrays/SubSetArraySum.java | 104 +++++++++++++++ src/com/dsa/arrays/TwoSumProblem.java | 86 +++++++++++++ src/com/dsa/binarysearch/AggressiveCows.java | 57 +++++++++ src/com/dsa/binarysearch/BookAllocation.java | 68 ++++++++++ .../dsa/binarysearch/DaysToMakeBouque.java | 72 +++++++++++ src/com/dsa/binarysearch/FindElement.java | 56 +++++++++ .../binarysearch/FirstAndLastOccurrence.java | 65 ++++++++++ .../dsa/binarysearch/KokoEatingBananas.java | 59 +++++++++ .../dsa/binarysearch/KthMissingNumber.java | 58 +++++++++ .../LargestMinimizedSumSubArray.java | 68 ++++++++++ .../dsa/binarysearch/LowerAndUpperBound.java | 90 +++++++++++++ src/com/dsa/binarysearch/MatrixMedian.java | 66 ++++++++++ .../MedianAndKthElementOfTwoSortedArrays.java | 94 ++++++++++++++ .../MinCapacityToShipInDDays.java | 55 ++++++++ .../MinimizeDistanceGasStations.java | 103 +++++++++++++++ src/com/dsa/binarysearch/NthRoot.java | 43 +++++++ .../dsa/binarysearch/PainterPartition.java | 67 ++++++++++ src/com/dsa/binarysearch/PeakElement.java | 45 +++++++ .../dsa/binarysearch/PeakElementMatrix.java | 97 ++++++++++++++ .../dsa/binarysearch/SearchIn2DMatrix.java | 66 ++++++++++ .../SearchInRotatedSortedArray.java | 83 ++++++++++++ src/com/dsa/binarysearch/SingleElement.java | 42 +++++++ src/com/dsa/binarysearch/SmallestDivisor.java | 61 +++++++++ src/com/dsa/binarysearch/SquareRoot.java | 35 ++++++ src/com/dsa/sorting/BubbleSort.java | 61 +++++++++ src/com/dsa/sorting/InsertionSort.java | 51 ++++++++ src/com/dsa/sorting/MergeSort.java | 71 +++++++++++ src/com/dsa/sorting/QuickSort.java | 50 ++++++++ src/com/dsa/sorting/SelectionSort.java | 42 +++++++ 54 files changed, 3180 insertions(+) create mode 100644 .gitignore create mode 100644 input.txt create mode 100644 src/com/dsa/arrays/ArrayUnion.java create mode 100644 src/com/dsa/arrays/ConsecutiveOnes.java create mode 100644 src/com/dsa/arrays/ConsecutiveSequence.java create mode 100644 src/com/dsa/arrays/CountInversionsAndReversePairs.java create mode 100644 src/com/dsa/arrays/LeftRotateArray.java create mode 100644 src/com/dsa/arrays/MajorityElement.java create mode 100644 src/com/dsa/arrays/MaxFrequencyKOperations.java create mode 100644 src/com/dsa/arrays/MaxSubArraySumAndProduct.java create mode 100644 src/com/dsa/arrays/MergeTwoSortedArrays.java create mode 100644 src/com/dsa/arrays/MissingNumberInArray.java create mode 100644 src/com/dsa/arrays/MoveZeroToEnd.java create mode 100644 src/com/dsa/arrays/NumberThatRepeatsOnceAndOthersTwice.java create mode 100644 src/com/dsa/arrays/OverlappingSubIntervals.java create mode 100644 src/com/dsa/arrays/PascalTriangle.java create mode 100644 src/com/dsa/arrays/RemoveDuplicatesInSortedArray.java create mode 100644 src/com/dsa/arrays/RepeatingAndMissing.java create mode 100644 src/com/dsa/arrays/SecondLargestAndSecondSmallest.java create mode 100644 src/com/dsa/arrays/SetMatricZeroes.java create mode 100644 src/com/dsa/arrays/SortZeroOneTwo.java create mode 100644 src/com/dsa/arrays/SpiralMatrixTraversal.java create mode 100644 src/com/dsa/arrays/StockBuySell.java create mode 100644 src/com/dsa/arrays/SubArrayWithSumK.java create mode 100644 src/com/dsa/arrays/SubArrayWithXorK.java create mode 100644 src/com/dsa/arrays/SubSetArraySum.java create mode 100644 src/com/dsa/arrays/TwoSumProblem.java create mode 100644 src/com/dsa/binarysearch/AggressiveCows.java create mode 100644 src/com/dsa/binarysearch/BookAllocation.java create mode 100644 src/com/dsa/binarysearch/DaysToMakeBouque.java create mode 100644 src/com/dsa/binarysearch/FindElement.java create mode 100644 src/com/dsa/binarysearch/FirstAndLastOccurrence.java create mode 100644 src/com/dsa/binarysearch/KokoEatingBananas.java create mode 100644 src/com/dsa/binarysearch/KthMissingNumber.java create mode 100644 src/com/dsa/binarysearch/LargestMinimizedSumSubArray.java create mode 100644 src/com/dsa/binarysearch/LowerAndUpperBound.java create mode 100644 src/com/dsa/binarysearch/MatrixMedian.java create mode 100644 src/com/dsa/binarysearch/MedianAndKthElementOfTwoSortedArrays.java create mode 100644 src/com/dsa/binarysearch/MinCapacityToShipInDDays.java create mode 100644 src/com/dsa/binarysearch/MinimizeDistanceGasStations.java create mode 100644 src/com/dsa/binarysearch/NthRoot.java create mode 100644 src/com/dsa/binarysearch/PainterPartition.java create mode 100644 src/com/dsa/binarysearch/PeakElement.java create mode 100644 src/com/dsa/binarysearch/PeakElementMatrix.java create mode 100644 src/com/dsa/binarysearch/SearchIn2DMatrix.java create mode 100644 src/com/dsa/binarysearch/SearchInRotatedSortedArray.java create mode 100644 src/com/dsa/binarysearch/SingleElement.java create mode 100644 src/com/dsa/binarysearch/SmallestDivisor.java create mode 100644 src/com/dsa/binarysearch/SquareRoot.java create mode 100644 src/com/dsa/sorting/BubbleSort.java create mode 100644 src/com/dsa/sorting/InsertionSort.java create mode 100644 src/com/dsa/sorting/MergeSort.java create mode 100644 src/com/dsa/sorting/QuickSort.java create mode 100644 src/com/dsa/sorting/SelectionSort.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..54a765f --- /dev/null +++ b/.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 \ No newline at end of file diff --git a/input.txt b/input.txt new file mode 100644 index 0000000..7e7e1e8 --- /dev/null +++ b/input.txt @@ -0,0 +1,4 @@ +3 +1 3 8 +2 3 4 +1 2 5 \ No newline at end of file diff --git a/src/com/dsa/arrays/ArrayUnion.java b/src/com/dsa/arrays/ArrayUnion.java new file mode 100644 index 0000000..313c2df --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/ConsecutiveOnes.java b/src/com/dsa/arrays/ConsecutiveOnes.java new file mode 100644 index 0000000..55068a7 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/ConsecutiveSequence.java b/src/com/dsa/arrays/ConsecutiveSequence.java new file mode 100644 index 0000000..4d95b9d --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/CountInversionsAndReversePairs.java b/src/com/dsa/arrays/CountInversionsAndReversePairs.java new file mode 100644 index 0000000..decd346 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/LeftRotateArray.java b/src/com/dsa/arrays/LeftRotateArray.java new file mode 100644 index 0000000..436e029 --- /dev/null +++ b/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--; + } + } +} diff --git a/src/com/dsa/arrays/MajorityElement.java b/src/com/dsa/arrays/MajorityElement.java new file mode 100644 index 0000000..2f9e1cf --- /dev/null +++ b/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 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(); + } +} diff --git a/src/com/dsa/arrays/MaxFrequencyKOperations.java b/src/com/dsa/arrays/MaxFrequencyKOperations.java new file mode 100644 index 0000000..f71f0ce --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/MaxSubArraySumAndProduct.java b/src/com/dsa/arrays/MaxSubArraySumAndProduct.java new file mode 100644 index 0000000..131bed0 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/MergeTwoSortedArrays.java b/src/com/dsa/arrays/MergeTwoSortedArrays.java new file mode 100644 index 0000000..a0f778d --- /dev/null +++ b/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 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); + } + } +} diff --git a/src/com/dsa/arrays/MissingNumberInArray.java b/src/com/dsa/arrays/MissingNumberInArray.java new file mode 100644 index 0000000..9a191e3 --- /dev/null +++ b/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= arr.length) { + return 0; + } + return arr[index]; + } + + public int[][] getPascalTriangleOptimized(int rows) { + int[][] result = new int[rows][]; + for (int i=0; i (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}; + } +} diff --git a/src/com/dsa/arrays/SecondLargestAndSecondSmallest.java b/src/com/dsa/arrays/SecondLargestAndSecondSmallest.java new file mode 100644 index 0000000..9adb6cf --- /dev/null +++ b/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); + } + +} diff --git a/src/com/dsa/arrays/SetMatricZeroes.java b/src/com/dsa/arrays/SetMatricZeroes.java new file mode 100644 index 0000000..f1ba054 --- /dev/null +++ b/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 { + 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++; + } + } + +} diff --git a/src/com/dsa/arrays/StockBuySell.java b/src/com/dsa/arrays/StockBuySell.java new file mode 100644 index 0000000..0a2c2f8 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/arrays/SubArrayWithSumK.java b/src/com/dsa/arrays/SubArrayWithSumK.java new file mode 100644 index 0000000..7dfa01c --- /dev/null +++ b/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 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; + } + +} diff --git a/src/com/dsa/arrays/SubArrayWithXorK.java b/src/com/dsa/arrays/SubArrayWithXorK.java new file mode 100644 index 0000000..8bc8fa0 --- /dev/null +++ b/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 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; + } +} diff --git a/src/com/dsa/arrays/SubSetArraySum.java b/src/com/dsa/arrays/SubSetArraySum.java new file mode 100644 index 0000000..994b902 --- /dev/null +++ b/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> triplets = solution.getTripletsWithSumZero(arr); + List> quadruplets = solution.getQuadrupletsWithSumTarget(arr, targetSum); + System.out.println("Triplets with sum zero: "); + for (List triplet : triplets) { + System.out.println(triplet); + } + System.out.println("Quadruplets with sum target: "); + for (List quadruplet : quadruplets) { + System.out.println(quadruplet); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public List> getTripletsWithSumZero(int[] nums) { + QuickSort quickSort = new QuickSort(); + quickSort.sort(nums, 0, nums.length - 1); + List> 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> getQuadrupletsWithSumTarget(int[] nums, int target) { + QuickSort quickSort = new QuickSort(); + quickSort.sort(nums, 0, nums.length - 1); + List> 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; + } +} diff --git a/src/com/dsa/arrays/TwoSumProblem.java b/src/com/dsa/arrays/TwoSumProblem.java new file mode 100644 index 0000000..c745d2a --- /dev/null +++ b/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 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 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); + } +} diff --git a/src/com/dsa/binarysearch/AggressiveCows.java b/src/com/dsa/binarysearch/AggressiveCows.java new file mode 100644 index 0000000..25367d6 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/BookAllocation.java b/src/com/dsa/binarysearch/BookAllocation.java new file mode 100644 index 0000000..666f68d --- /dev/null +++ b/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}; + } +} diff --git a/src/com/dsa/binarysearch/DaysToMakeBouque.java b/src/com/dsa/binarysearch/DaysToMakeBouque.java new file mode 100644 index 0000000..49d4091 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/FindElement.java b/src/com/dsa/binarysearch/FindElement.java new file mode 100644 index 0000000..93a07f0 --- /dev/null +++ b/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); + } + } +} diff --git a/src/com/dsa/binarysearch/FirstAndLastOccurrence.java b/src/com/dsa/binarysearch/FirstAndLastOccurrence.java new file mode 100644 index 0000000..c12c54c --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/KokoEatingBananas.java b/src/com/dsa/binarysearch/KokoEatingBananas.java new file mode 100644 index 0000000..a684e75 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/KthMissingNumber.java b/src/com/dsa/binarysearch/KthMissingNumber.java new file mode 100644 index 0000000..8015c58 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/LargestMinimizedSumSubArray.java b/src/com/dsa/binarysearch/LargestMinimizedSumSubArray.java new file mode 100644 index 0000000..c0ff7ec --- /dev/null +++ b/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}; + } +} diff --git a/src/com/dsa/binarysearch/LowerAndUpperBound.java b/src/com/dsa/binarysearch/LowerAndUpperBound.java new file mode 100644 index 0000000..504cc02 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/MatrixMedian.java b/src/com/dsa/binarysearch/MatrixMedian.java new file mode 100644 index 0000000..2bd8123 --- /dev/null +++ b/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}; + } +} diff --git a/src/com/dsa/binarysearch/MedianAndKthElementOfTwoSortedArrays.java b/src/com/dsa/binarysearch/MedianAndKthElementOfTwoSortedArrays.java new file mode 100644 index 0000000..db2fa67 --- /dev/null +++ b/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]; + } +} diff --git a/src/com/dsa/binarysearch/MinCapacityToShipInDDays.java b/src/com/dsa/binarysearch/MinCapacityToShipInDDays.java new file mode 100644 index 0000000..7e8bfb7 --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/MinimizeDistanceGasStations.java b/src/com/dsa/binarysearch/MinimizeDistanceGasStations.java new file mode 100644 index 0000000..c437f6e --- /dev/null +++ b/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> 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 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, T extends Comparable> implements Comparable> { + S first; + T second; + + Pair(S first, T second) { + this.first = first; + this.second = second; + } + + @Override + public int compareTo(Pair stPair) { + int firstComp = this.first.compareTo(stPair.first); + return firstComp == 0 ? this.second.compareTo(stPair.second) : firstComp; + } + } +} diff --git a/src/com/dsa/binarysearch/NthRoot.java b/src/com/dsa/binarysearch/NthRoot.java new file mode 100644 index 0000000..9c31467 --- /dev/null +++ b/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; + + } +} diff --git a/src/com/dsa/binarysearch/PainterPartition.java b/src/com/dsa/binarysearch/PainterPartition.java new file mode 100644 index 0000000..a5ea91d --- /dev/null +++ b/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}; + } +} diff --git a/src/com/dsa/binarysearch/PeakElement.java b/src/com/dsa/binarysearch/PeakElement.java new file mode 100644 index 0000000..f9cf89b --- /dev/null +++ b/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; + } + +} diff --git a/src/com/dsa/binarysearch/PeakElementMatrix.java b/src/com/dsa/binarysearch/PeakElementMatrix.java new file mode 100644 index 0000000..733bc7e --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/SearchIn2DMatrix.java b/src/com/dsa/binarysearch/SearchIn2DMatrix.java new file mode 100644 index 0000000..c76a75e --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/SearchInRotatedSortedArray.java b/src/com/dsa/binarysearch/SearchInRotatedSortedArray.java new file mode 100644 index 0000000..d935aeb --- /dev/null +++ b/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); + } +} diff --git a/src/com/dsa/binarysearch/SingleElement.java b/src/com/dsa/binarysearch/SingleElement.java new file mode 100644 index 0000000..d4036b4 --- /dev/null +++ b/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]; + } +} diff --git a/src/com/dsa/binarysearch/SmallestDivisor.java b/src/com/dsa/binarysearch/SmallestDivisor.java new file mode 100644 index 0000000..1fde18d --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/binarysearch/SquareRoot.java b/src/com/dsa/binarysearch/SquareRoot.java new file mode 100644 index 0000000..c4b906c --- /dev/null +++ b/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; + } +} diff --git a/src/com/dsa/sorting/BubbleSort.java b/src/com/dsa/sorting/BubbleSort.java new file mode 100644 index 0000000..a5ca42b --- /dev/null +++ b/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); + } +} diff --git a/src/com/dsa/sorting/InsertionSort.java b/src/com/dsa/sorting/InsertionSort.java new file mode 100644 index 0000000..99272c9 --- /dev/null +++ b/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); + } +} diff --git a/src/com/dsa/sorting/MergeSort.java b/src/com/dsa/sorting/MergeSort.java new file mode 100644 index 0000000..546db73 --- /dev/null +++ b/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]; + } + + } + +} diff --git a/src/com/dsa/sorting/QuickSort.java b/src/com/dsa/sorting/QuickSort.java new file mode 100644 index 0000000..1a55b4f --- /dev/null +++ b/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); + } + +} diff --git a/src/com/dsa/sorting/SelectionSort.java b/src/com/dsa/sorting/SelectionSort.java new file mode 100644 index 0000000..880bc96 --- /dev/null +++ b/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; + } + } + } + +}