File - C:\Users\USER\IdeaProjects\Arrays\src\LCS.

java
import java.util.HashSet;

public class LCS {

public static int longestConsecutive(int[] nums) {
HashSet<Integer> set = new HashSet<>();
for (int num : nums) set.add(num);

int maxLength = 0;
for (int num : nums) {
if (!set.contains(num - 1)) {
int current = num;
int count = 1;

while (set.contains(current + 1)) {

current++;
count++;
}
maxLength = Math.max(maxLength, count);
}
}
return maxLength;
}

public static void main(String[] args) {

int[] nums = {100, 4,5,6,7, 200, 1, 3, 2};
System.out.println(longestConsecutive(nums)); // Output: 4
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\twoSum.java
import java.util.HashMap;
import java.util.Map;

public class twoSum {

public static int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> m = new HashMap<>();

for (int i = 0; i < nums.length; i++) {

int num = nums[i];
if (m.containsKey(target - num)) {
return new int[]{i, m.get(target - num)};
}
m.put(num, i);
}

return new int[]{}; // Return an empty array if no solution exists

}

public static void main(String[] args) {

int[] nums = {2, 7, 11, 15};
int target = 9;

int[] result = twoSum(nums, target);

if (result.length == 2) {
// Print the indices
System.out.println("Indices: " + result[0] + " and " + result[1]);

// Print the elements

System.out.println("Elements: " + nums[result[0]] + " and " + nums[result[1]]);
} else {
System.out.println("No solution found.");
}
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\RangeSum.java
public class RangeSum {
public static int rangeSum(int[] prefix, int l, int r){
if(l==0)
return prefix[r];

return prefix[r]-prefix[l-1];

public static void main(String[] args) {

int[] nums={1,2,3,4,5};
int[] prefix=PrefixSumArray.prefixSum(nums);
System.out.println(rangeSum(prefix,0,3));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\ThreeSum.java
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.List;
//
//public class ThreeSum {
// public static List<List<Integer>> threeSum(int[] nums) {
// List<List<Integer>> result = new ArrayList<>();
// Arrays.sort(nums); // Sort the array to handle duplicates easily
//
// int n = nums.length;
// for (int i = 0; i < n - 2; i++) {
// // Skip duplicates for the first number
// if (i > 0 && nums[i] == nums[i - 1]) continue;
//
// for (int j = i + 1; j < n - 1; j++) {
// // Skip duplicates for the second number
// if (j > i + 1 && nums[j] == nums[j - 1]) continue;
//
// for (int k = j + 1; k < n; k++) {
// // Skip duplicates for the third number
// if (k > j + 1 && nums[k] == nums[k - 1]) continue;
//
// if (nums[i] + nums[j] + nums[k] == 0) {
// result.add(Arrays.asList(nums[i], nums[j], nums[k]));
// }
// }
// }
// }
//
// return result;
// }
//
// public static void main(String[] args) {
// int[] nums = {-1, 0, 1, 2, -1, -4};
// List<List<Integer>> triplets = threeSum(nums);
//
// System.out.println("Triplets:");
// for (List<Integer> triplet : triplets) {
// System.out.print(triplet+" ");
// }
// }
//}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ThreeSum {

public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums); // Sort the array

for (int i = 0; i < nums.length - 2; i++) {

// Skip duplicates for the first element
if (i > 0 && nums[i] == nums[i - 1]) continue;

int left = i + 1, right = nums.length - 1;

while (left < right) {

int sum = nums[i] + nums[left] + nums[right];

if (sum == 0) {
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
left++;
right--;

Page 1 of 2
File - C:\Users\USER\IdeaProjects\Arrays\src\ThreeSum.java
// Skip duplicates for the second and third elements
while (left < right && nums[left] == nums[left - 1]) left++;
while (left < right && nums[right] == nums[right + 1]) right--;
} else if (sum < 0) {
left++; // Increase the sum
} else {
right--; // Decrease the sum
}
}
}

return result;
}

public static void main(String[] args) {

int[] nums = {-1, 0, 1, 2, -1, -4};
List<List<Integer>> triplets = threeSum(nums);

System.out.println("Triplets:");
for (List<Integer> triplet : triplets) {
System.out.println(triplet);
}
}
}

Page 2 of 2
File - C:\Users\USER\IdeaProjects\Arrays\src\KthLargest.java
import java.util.PriorityQueue;

public class KthLargest {

public static int findKthLargest(int[] nums, int k) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int num : nums) {
minHeap.add(num);
if (minHeap.size() > k) {
minHeap.poll();
}
}
return minHeap.peek();
}
public static void main(String[] args) {
int[] nums = {3, 2, 1, 5, 6, 4};
int k = 2;
System.out.println(findKthLargest(nums, k)); // Output: 5
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Palindrome.java
public class Palindrome {
public static boolean isPal(int[] nums){
int l=0,r=nums.length-1;
while(l<r){
if(nums[l]!=nums[r]){
return false;
}
l++;
r--;

}
return true;
}

public static void main(String[] args) {

int[] nums={1,2,3,2,1};
System.out.println(isPal(nums));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\KthSmallest.java
//Kth Smallest Code
import java.util.PriorityQueue;

public class KthSmallest{

public static int findKthSmallest(int[] nums, int k) {
// Max-heap to store k smallest elements
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

for (int num : nums) {

maxHeap.add(num);
if (maxHeap.size() > k) {
maxHeap.poll(); // Remove the largest element when the heap exceeds size k
}
}
return maxHeap.peek(); // The root of the max-heap will be the kth smallest element
}

public static void main(String[] args) {

int[] nums = {3, 2, 1,0, 5, 6, 4};
int k = 2;
System.out.println(findKthSmallest(nums, k)); // Output: 2
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\TwoSumSorted.java
public class TwoSumSorted {
public static int[] twoSum(int[] nums,int target){
int l=0,r=nums.length-1;
while (l<r){
int sum=nums[l]+nums[r];
if(sum==target){
return new int[]{l,r};

}
else if(sum<target){
l++;
}
else{
r--;
}

}
return new int[]{-1,-1};//no solution

public static void main(String[] args) {

int[] nums={2,7,11,15};
int t=9;
int[] result=twoSum(nums,t);
// System.out.println(result[0]+" "+result[1]);
if (result[0] != -1 && result[1] != -1) {
// Print the elements rather than their indices
System.out.println("Elements: " + nums[result[0]] + " and " + nums[result[1]]);
} else {
System.out.println("No solution found.");
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MissingNumber.java
public class MissingNumber {
public static int findMissing(int[] nums){
int n=nums.length+1;
int total=n*(n+1)/2;
for(int num:nums){
total-=num;
}
return total;
}

public static void main(String[] args) {

int[] nums={1,2,4,6,3,7,8};
System.out.println(findMissing(nums));
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\FrequencyCount.java
import java.util.HashMap;
import java.util.Map;

public class FrequencyCount {

public static void countFrequencies(int[] arr) {
// Create a HashMap to store element frequencies
Map<Integer, Integer> frequencyMap = new HashMap<>();

// Iterate through the array

for (int num : arr) {
// Update the frequency count
frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
}

// Print the frequency of each element

for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
System.out.println("Element: " + entry.getKey() + ", Frequency: " + entry.getValue());
}
}

public static void main(String[] args) {

int[] arr = {1, 2, 2, 3, 4, 4, 4, 5, 1};
countFrequencies(arr);
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\InsertInterval.java
import java.util.*;

public class InsertInterval {

public static int[][] insert(int[][] intervals, int[] newInterval) {
List<int[]> result = new ArrayList<>();
int i = 0;

// Add all intervals before the new interval

while (i < intervals.length && intervals[i][1] < newInterval[0]) {
result.add(intervals[i++]);
}

// Merge overlapping intervals

while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
i++;
}
result.add(newInterval);

// Add remaining intervals

while (i < intervals.length) {
result.add(intervals[i++]);
}

return result.toArray(new int[result.size()][]);

}

public static void main(String[] args) {

int[][] intervals = {{1, 3},{4,5}, {6, 9}};
int[] newInterval = {2, 5};
int[][] result = insert(intervals, newInterval);
for (int[] interval : result) {
System.out.print(Arrays.toString(interval)+" ");
}
// Output: [1, 5], [6, 9]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxSubarraySum.java
public class MaxSubarraySum {
public static int maxsubarray(int[] nums){
int maxi=nums[0];
int curr=nums[0];
for (int i = 1; i < nums.length; i++) {
curr=Math.max(nums[i],curr+nums[i]);

maxi=Math.max(maxi,curr);
}
return maxi;
}

public static void main(String[] args) {

int[] nums={-2,1,-3,4,-1,2,1,-5,4};
System.out.println(maxsubarray(nums));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxSumSubarray.java
public class MaxSumSubarray {
public static int maxSum(int[] nums,int k){
int maxSum=0,windowSum=0;
for (int i = 0; i < k; i++) {
windowSum+=nums[i];
}
maxSum=windowSum;

for (int i = k; i < nums.length; i++) {

windowSum+=nums[i]-nums[i-k];
maxSum=Math.max(maxSum,windowSum);
}
return maxSum;

public static void main(String[] args) {

int[] nums={2,1,5,1,3,2};
int k=4;
System.out.println(maxSum(nums,k));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MergeIntervals.java
import java.util.*;

public class MergeIntervals {

public static int[][] merge(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
List<int[]> result = new ArrayList<>();

int[] current = intervals[0];

for (int i = 1; i < intervals.length; i++) {
if (current[1] >= intervals[i][0]) {
current[1] = Math.max(current[1], intervals[i][1]);
} else {
result.add(current);
current = intervals[i];
}
}
result.add(current);

return result.toArray(new int[result.size()][]);

}

public static void main(String[] args) {

int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};
int[][] merged = merge(intervals);
for (int[] interval : merged) {
System.out.print(Arrays.toString(interval));
}
// Output: [1, 6], [8, 10], [15, 18]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\PrefixSumArray.java
public class PrefixSumArray {
public static int[] prefixSum(int[] nums){
int n=nums.length;
int[] prefix=new int[n];
prefix[0]=nums[0];
for (int i = 1; i <n; i++) {
prefix[i]=prefix[i-1]+nums[i];

}
return prefix;

}
public static void main(String[] args) {
int[] nums={1,2,3,4,5};
int[] result=prefixSum(nums);
for(int sum:result){
System.out.print(sum+" ");
}
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\ArrayDuplicates.java
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeMap;

public class ArrayDuplicates {

public static List<Integer> findDuplicates(int[] nums) {
// Create a HashMap to store the frequency of each number
TreeMap<Integer, Integer> countMap = new TreeMap<>();
List<Integer> result = new ArrayList<>();

// Iterate over the array and update counts in the HashMap

for (int num : nums) {
// If num already exists in the map, increase its count
countMap.put(num, countMap.getOrDefault(num, 0) + 1);
}

// Check for numbers whose count is more than 1 (duplicates)

for (int num : countMap.keySet()) {
if (countMap.get(num) >=1) {
result.add(num); // Add the duplicate to the result list
}
}

return result; // Return the list of duplicates

}

public static void main(String[] args) {

int[] nums = {4, 3, 2, 7, 8, 2, 3, 1, 1, 20, 20};
System.out.println(findDuplicates(nums)); // Output: [2, 3, 1, 20]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\AverageSubarray.java
import java.lang.reflect.Array;
import java.util.Arrays;

public class AverageSubarray {

public static double[] findAverages(int[] nums,int k){
double[] result=new double[nums.length-k+1];
double windowSum=0;
int start=0;
for (int end = 0; end < nums.length; end++) {
windowSum+=nums[end];
if(end>=k-1){
result[start]=windowSum/k;
windowSum-=nums[start];
start++;

}
}
return result;

public static void main(String[] args) {

int[] nums={1,3,2,6,-1,4,1,8,2};
int k=5;
System.out.println(Arrays.toString(findAverages(nums,k)));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MajorityElement.java
public class MajorityElement {
public static int majorityElement(int[] nums) {
int candidate = nums[0], count = 0;
for (int num : nums) {
if (count == 0) {
candidate = num;
}
count += (num == candidate) ? 1 : -1;
}
return candidate;
}

public static void main(String[] args) {

int[] nums = {2, 2, 1, 1, 1, 2, 2};
System.out.println(majorityElement(nums)); // Output: 2
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\NextPermutation.java
import java.util.Arrays;

public class NextPermutation {

public static void nextPermutation(int[] nums) {
int n = nums.length;
int i = n - 2;

// Step 1: Find the first decreasing element from the right

while (i >= 0 && nums[i] >= nums[i + 1]) {
i--;
}

// Step 2: If a decreasing element is found, find the element to swap

if (i >= 0) {
int j = n - 1;
while (nums[j] <= nums[i]) {
j--;
}
// Swap the two elements
swap(nums, i, j);
}

// Step 3: Reverse the elements to the right of the found index

reverse(nums, i + 1);
}

private static void swap(int[] nums, int i, int j) {

int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}

private static void reverse(int[] nums, int start) {

int end = nums.length - 1;
while (start < end) {
swap(nums, start, end);
start++;
end--;
}
}

public static void main(String[] args) {

int[] nums = {1, 2, 3,5,4};
nextPermutation(nums);
System.out.println(Arrays.toString(nums)); // Output: [1, 3, 2]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\EmployeeFreeTime.java
import java.util.*;

public class EmployeeFreeTime {

public static List<int[]> findFreeTime(List<List<int[]>> schedules) {
List<int[]> allIntervals = new ArrayList<>();
for (List<int[]> schedule : schedules) {
allIntervals.addAll(schedule);
}
allIntervals.sort(Comparator.comparingInt(a -> a[0]));

List<int[]> freeTime = new ArrayList<>();

int end = allIntervals.get(0)[1];

for (int i = 1; i < allIntervals.size(); i++) {

if (allIntervals.get(i)[0] > end) {
freeTime.add(new int[]{end, allIntervals.get(i)[0]});
}
end = Math.max(end, allIntervals.get(i)[1]);
}

return freeTime;
}

public static void main(String[] args) {

List<List<int[]>> schedules = new ArrayList<>();
schedules.add(Arrays.asList(new int[]{1, 3}, new int[]{6, 7}));
schedules.add(Arrays.asList(new int[]{2, 4}));
schedules.add(Arrays.asList(new int[]{2, 5}, new int[]{9, 12}));

List<int[]> freeTime = findFreeTime(schedules);

for (int[] interval : freeTime) {
System.out.println(Arrays.toString(interval));
}
// Output: [5, 6], [7, 9]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MergeSortedArray.java
import java.util.Arrays;

public class MergeSortedArray {

public static int[] merge(int[] arr1,int[] arr2){
int n=arr1.length;
int m=arr2.length;
int[] result=new int[n+m];
int i=0,j=0,k=0;
while(i<n && j<m){
if (arr1[i]<arr2[j]){
result[k++]=arr1[i++];
}
else{
result[k++]=arr2[j++];
}
}
while(i<n){
result[k++]=arr1[i++];
}
while(j<m){
result[k++]=arr2[j++];
}
return result;
}

public static void main(String[] args) {

int[] arr1={1,3,5};
int[] arr2={2,4,6};
System.out.println(Arrays.toString(merge(arr1,arr2)));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\PositiveNegative.java
import java.util.*;

public class PositiveNegative{

public static void rearrange(int[] arr) {
List<Integer> positive = new ArrayList<>();
List<Integer> negative = new ArrayList<>();

// Separate positive and negative numbers

for (int num : arr) {
if (num >= 0) {
positive.add(num);
} else {
negative.add(num);
}
}

int posIndex = 0, negIndex = 0, i = 0;

// Merge positive and negative numbers alternately

while (posIndex < positive.size() && negIndex < negative.size()) {
if (i % 2 == 0) {
arr[i++] = positive.get(posIndex++);
} else {
arr[i++] = negative.get(negIndex++);
}
}

// Add remaining positive numbers

while (posIndex < positive.size()) {
arr[i++] = positive.get(posIndex++);
}

// Add remaining negative numbers

while (negIndex < negative.size()) {
arr[i++] = negative.get(negIndex++);
}
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, -4, -1, 4, -6, -7};
rearrange(arr);
System.out.println(Arrays.toString(arr));
// Output: [1, -4, 2, -1, 3, -6, 4, -7]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\RemoveDuplicates.java
public class RemoveDuplicates {
public static int removeDuplicates(int[] nums){
if(nums.length==0)
return 0;

int unique=0;
for (int i = 1; i <nums.length ; i++) {
if(nums[i]!=nums[unique]){
unique++;
nums[unique]=nums[i];

}
}
return unique+1;
}

public static void main(String[] args) {

int[] nums={1,1,2,2,3};
int newLength=removeDuplicates(nums);
for (int i = 0; i < newLength; i++) {
System.out.print(nums[i]+" ");
}
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\StringDuplicates.java
import java.util.*;

public class StringDuplicates {

public static List<Character> findDuplicates(String str) {
// Create a HashMap to store the frequency of each character
TreeMap<Character, Integer> countMap = new TreeMap<>();
List<Character> duplicates = new ArrayList<>();

// Iterate over the string and update the counts in the HashMap
for (char ch : str.toCharArray()) {
// If the character already exists in the map, increment its count
countMap.put(ch, countMap.getOrDefault(ch, 0) + 1);
}

// Check for characters whose count is more than 1 (duplicates)

for (char ch : countMap.keySet()) {
if (countMap.get(ch) >=1) {
duplicates.add(ch); // Add the duplicate character to the set
}
}

return duplicates; // Return the set of duplicates

}

public static void main(String[] args) {

String str = "programming";
System.out.println(findDuplicates(str)); // Output: [r, g,m]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\RearrangeElements.java
import java.util.Arrays;

public class RearrangeElements {

public static void rearrange(int[] arr) {
for (int i = 1; i < arr.length; i += 2) {
// If current element is smaller than the previous element, swap them
if (i > 0 && arr[i] < arr[i - 1]) {
swap(arr, i, i - 1);
}
// If current element is smaller than the next element, swap them
if (i < arr.length - 1 && arr[i] < arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}

// Helper method to swap two elements in the array

private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

public static void main(String[] args) {

int[] arr = {5,7,6,4,3,1,2};
rearrange(arr);
System.out.println(Arrays.toString(arr));
// Output: [1, 3, 2, 4, 5, 6] (or any array where every second element is greater than its neig
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\TrappingRainWater.java
public class TrappingRainWater {
public static int trap(int[] height) {
int left = 0, right = height.length - 1;
int leftMax = 0, rightMax = 0;
int waterTrapped = 0;

while (left < right) {

if (height[left] < height[right]) {
if (height[left] >= leftMax) {
leftMax = height[left];
} else {
waterTrapped += leftMax - height[left];
}
left++;
} else {
if (height[right] >= rightMax) {
rightMax = height[right];
} else {
waterTrapped += rightMax - height[right];
}
right--;
}
}

return waterTrapped;
}

public static void main(String[] args) {

int[] height = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
System.out.println("Trapped Rain Water: " + trap(height));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\UnionIntersection.java
import java.util.*;

public class UnionIntersection {

public static List<Integer> findIntersection(int[] arr1, int[] arr2) {
Set<Integer> set1 = new HashSet<>();
Set<Integer> resultSet = new HashSet<>();
for (int num : arr1) {
set1.add(num);
}
for (int num : arr2) {
if (set1.contains(num)) {
resultSet.add(num);
}
}
return new ArrayList<>(resultSet);
}

public static List<Integer> findUnion(int[] arr1, int[] arr2) {

Set<Integer> resultSet = new HashSet<>();
for (int num : arr1) {
resultSet.add(num);
}
for (int num : arr2) {
resultSet.add(num);
}
return new ArrayList<>(resultSet);
}

public static void main(String[] args) {

int[] arr1 = {1, 2, 2, 3, 4};
int[] arr2 = {2, 3, 5, 6};
System.out.println("Intersection: " + findIntersection(arr1, arr2)); // Output: [2, 3]
// System.out.println("Union: " + findUnion(arr1, arr2)); // Output: [1, 2, 3, 4, 5, 6]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaximumSubarraySum.java
public class MaximumSubarraySum {
public static int maxSubarraySum(int[] nums){
int maxSum=Integer.MIN_VALUE,cursum=0;
for(int num:nums){
cursum=Math.max(num,cursum+num);

maxSum=Math.max(maxSum,cursum);

}
return maxSum;
}

public static void main(String[] args) {

int[] nums={-2,1,-3,4,-1,2,1,-5,4};
System.out.println(maxSubarraySum(nums));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxProductSubarray.java
public class MaxProductSubarray {
public static int maxProduct(int[] nums) {
int max = nums[0], min = nums[0], result = nums[0];
for (int i = 1; i < nums.length; i++) {
if (nums[i] < 0) {
int temp = max;
max = min;
min = temp;
}
max = Math.max(nums[i], max * nums[i]);
min = Math.min(nums[i], min * nums[i]);
result = Math.max(result, max);
}
return result;
}

public static void main(String[] args) {

int[] nums = {2, 3, -2, 4};
System.out.println(maxProduct(nums)); // Output: 6
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MinSizeSubarraySum.java
public class MinSizeSubarraySum {
public static int minSubarrayLen(int s,int[] nums){
int n=nums.length;
int l=0,sum=0,minLen=Integer.MAX_VALUE;
for (int r = 0; r < n; r++) {
sum+=nums[r];
while(sum>=s){
minLen=Math.min(minLen,r-l+1);
sum-=nums[l++];

}
return minLen==Integer.MIN_VALUE? 0: minLen;

public static void main(String[] args) {

int[] nums={2,3,1,2,4,3};
int s=7;
System.out.println(minSubarrayLen(s,nums));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\PairWithDifference.java
//import java.util.Arrays;
//
//public class PairWithDifference {
// public static int[] hasPairWithDiff(int[] nums, int k) {
// Arrays.sort(nums); // Sort the array
// int left = 0, right = 1;
//
// while (right < nums.length) {
// int diff = nums[right] - nums[left];
//
// if (diff == k && left != right) {
// return new int[] {nums[left],nums[right]};
// } else if (diff < k) {
// right++; // Increase the larger number
// } else {
// left++; // Increase the smaller number
// }
// }
//
// return new int[]{};
// }
//
// public static void main(String[] args) {
// int[] nums = {5, 20, 3, 2, 50, 80};
// int k = 454;
//
// int[] result=hasPairWithDiff(nums, k); // Output: true
// if (result.length > 0) {
// System.out.println("Pair with given difference: " + result[0] + ", " + result[1]);
// } else {
// System.out.println("No valid pair found.");
// }
// }
//}
import java.util.HashSet;
public class PairWithDifference {
public static int[] findPairWithDiff(int[] nums, int k) {
HashSet<Integer> set = new HashSet<>();

for (int num : nums) {

if (set.contains(num - k)) {
return new int[] { num, num - k };
}
if (set.contains(num + k)) {
return new int[] { num, num + k };
}
set.add(num);
}

return new int[] {}; // No valid pair found

}

public static void main(String[] args) {

int[] nums = {5, 20, 3, 2, 50, 80};
int k = 78;

int[] result = findPairWithDiff(nums, k);

if (result.length > 0) {
System.out.println("Pair with given difference: " + result[0] + ", " + result[
} else {
System.out.println("No valid pair found.");
}
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\SearchRotatedArray.java
public class SearchRotatedArray {
public static int search(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) return mid;

if (nums[left] <= nums[mid]) {

if (target >= nums[left] && target < nums[mid]) right = mid - 1;
else left = mid + 1;
} else {
if (target > nums[mid] && target <= nums[right]) left = mid + 1;
else right = mid - 1;
}
}
return -1;
}

public static void main(String[] args) {

int[] nums = {4, 5, 6, 7, 0, 1, 2};
int target = 4;
System.out.println(search(nums, target)); // Output: 4
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\SubarraySumEqualsK.java
import java.util.HashMap;

public class SubarraySumEqualsK {

public static int subarraySum(int[] nums, int k){
HashMap <Integer,Integer> map=new HashMap<>();
map.put(0,1);//necessary if subarray starts from index 0
int c=0,sum=0;
for (int num:nums){
sum+=num;
if(map.containsKey(sum-k)){
c+=map.get(sum-k);
}
map.put(sum,map.getOrDefault(sum,0)+1);
}
return c;
}

public static void main(String[] args) {

int[] nums={1,1,1};
int k=2;
System.out.println(subarraySum(nums,k));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\FindMaxRotatedArray.java
public class FindMaxRotatedArray {
public static int findMax(int[] nums) {
int left = 0, right = nums.length - 1;

while (left < right) {

int mid = left + (right - left) / 2;

// If mid element is greater than or equal to the rightmost element,

// the maximum is in the right half or at mid itself.
if (nums[mid] > nums[right]) {
left = mid + 1;
} else {
right = mid; // Maximum is in the left half
}
}
// After the loop, right will be at the rotation pivot, which is the minimum.
// The maximum is at right - 1 in a rotated sorted array.
return nums[(right - 1 + nums.length) % nums.length];
}

public static void main(String[] args) {

int[] nums = {3, 4, 5, 6, 7, 1, 2};
System.out.println(findMax(nums)); // Output: 7
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\FindMinRotatedArray.java
public class FindMinRotatedArray {
public static int findMin(int[] nums) {
int left = 0, right = nums.length - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] > nums[right]) {
left = mid + 1;
} else {
right = mid;
}
}
return nums[left];
}

public static void main(String[] args) {

int[] nums = {3, 4, 5,0,1, 2};
System.out.println(findMin(nums)); // Output: 1
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\IntervalIntersection.java
import java.util.*;

public class IntervalIntersection {

public static int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
List<int[]> result = new ArrayList<>();
int i = 0, j = 0;

while (i < firstList.length && j < secondList.length) {

int start = Math.max(firstList[i][0], secondList[j][0]);
int end = Math.min(firstList[i][1], secondList[j][1]);

if (start <= end) {

result.add(new int[]{start, end});
}

if (firstList[i][1] < secondList[j][1]) {

i++;
} else {
j++;
}
}
return result.toArray(new int[result.size()][]);
}

public static void main(String[] args) {

int[][] firstList = {{0, 2}, {5, 10}, {13, 23}, {24, 25}};
int[][] secondList = {{1, 5}, {8, 12}, {15, 24}, {25, 26}};
int[][] result = intervalIntersection(firstList, secondList);
for (int[] interval : result) {
System.out.println(Arrays.toString(interval));
}
// Output: [1, 2], [5, 5], [8, 10], [15, 23], [24, 24], [25, 25]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\SlidingWindowMaximum.java
import java.util.Deque;
import java.util.LinkedList;

public class SlidingWindowMaximum {

public static int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || nums.length == 0) return new int[0];
int n = nums.length;
int[] result = new int[n - k + 1];
Deque<Integer> deque = new LinkedList<>();

for (int i = 0; i < n; i++) {

// Remove elements not in the window
if (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
deque.pollFirst();
}
// Remove smaller elements in k range as they are useless
while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
deque.pollLast();
}
deque.offerLast(i);

// Add the maximum of current window to the result

if (i >= k - 1) {
result[i - k + 1] = nums[deque.peekFirst()];
}
}
return result;
}

public static void main(String[] args) {

int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
int k = 3;
int[] result = maxSlidingWindow(nums, k);
for (int num : result) {
System.out.print(num + " ");
}
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\SubarrayWithGivenSum.java
import java.util.Arrays;
import java.util.HashMap;

public class SubarrayWithGivenSum {

public static int[] findSubarray(int[] arr, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
if (sum == target) return new int[]{0, i};
if (map.containsKey(sum - target)) return new int[]{map.get(sum - target) + 1, i};
map.put(sum, i);
}
return new int[]{-1, -1}; // No subarray found
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 7, 5};
int target = 12;
System.out.println(Arrays.toString(findSubarray(arr, target)));
// Output: [1, 3]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\LargestNonAdjacentSum.java
public class LargestNonAdjacentSum {
public static int maxNonAdjacentSum(int[] nums) {
int include = nums[0], exclude = 0;

for (int i = 1; i < nums.length; i++) {

int newInclude = exclude + nums[i];
exclude = Math.max(include, exclude);
include = newInclude;
}

return Math.max(include, exclude);

}

public static void main(String[] args) {

int[] nums = {3, 2, 7, 10};
System.out.println(maxNonAdjacentSum(nums)); // Output: 13
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\ContainerWithMostWater.java
public class ContainerWithMostWater {
public static int maxArea(int[] height) {
int left = 0, right = height.length - 1;
int maxArea = 0;

while (left < right) {

// Calculate the area
int area = Math.min(height[left], height[right]) * (right - left);
maxArea = Math.max(maxArea, area);

// Move the pointer pointing to the shorter line

if (height[left] < height[right]) {
left++;
} else {
right--;
}
}

return maxArea;
}

public static void main(String[] args) {

int[] height = {1, 8, 6, 2, 5, 4, 8, 3, 7};
System.out.println("Maximum Area: " + maxArea(height));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\LargestSubarrayEqual01.java
import java.util.HashMap;

public class LargestSubarrayEqual01 {

public static int findMaxLength(int[] nums){
HashMap<Integer,Integer> map=new HashMap<>();
map.put(0,-1);
int maxLen=0,c=0;
for (int i = 0; i < nums.length; i++) {
c+=(nums[i]==1)?1:-1;
if(map.containsKey(c)){
maxLen=Math.max(maxLen,i-map.get(c));

}
else{
map.put(c,i);
}

}
return maxLen;
}

public static void main(String[] args) {

int[] nums={0,1,0,1,0,1,1};
System.out.println(findMaxLength(nums));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\LongestUniqueSubstring.java
import java.util.HashSet;

public class LongestUniqueSubstring {

public static int lengthOfLongestSubstring(String s){
HashSet<Character> set =new HashSet<>();
int maxi=0,start=0;
for (int end = 0; end < s.length(); end++) {
while (set.contains(s.charAt(end))){
set.remove(s.charAt(start));
start++;

}
set.add(s.charAt(end));
maxi=Math.max(maxi,end-start+1);

}
return maxi;
}

public static void main(String[] args) {

String s="abcdabcbb";
System.out.println(lengthOfLongestSubstring(s));
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxCircularSumSubArray.java
//public class MaxCircularSumSubArray {
//
// static int maxCircularSum(int arr[], int n)
// {
// int res = arr[0];
//
// for(int i = 0; i < n; i++)
// {
// int curr_max = arr[i];
// int curr_sum = arr[i];
//
// for(int j = 1; j < n; j++)
// {
// int index = (i + j) % n;
//
// curr_sum += arr[index];
//
// curr_max = Math.max(curr_max, curr_sum);
// }
//
// res = Math.max(res, curr_max);
// }
// return res;
// }
//
//
// public static void main(String args[])
// {
// int arr[] = {5, -2, 3, 4}, n = 4;
//
// System.out.println(maxCircularSum(arr, n));
//
// }
//
//}
//public class MaxCircularSumSubArray {
//
// // Kadane's algorithm to find the maximum subarray sum
// public static int kadane(int[] nums) {
// int maxSoFar = nums[0];
// int currentMax = nums[0];
//
// for (int i = 1; i < nums.length; i++) {
// currentMax = Math.max(nums[i], currentMax + nums[i]);
// maxSoFar = Math.max(maxSoFar, currentMax);
// }
//
// return maxSoFar;
// }
//
// public static int maxCircularSubarraySum(int[] nums) {
// int totalSum = 0;
// int n = nums.length;
//
// // Step 1: Find the normal maximum subarray sum using Kadane's algorithm
// int maxSubarraySum = kadane(nums);
//
// // Step 2: Find the total sum of the array and the minimum subarray sum
// for (int i = 0; i < n; i++) {
// totalSum += nums[i];
// nums[i] = -nums[i]; // Invert the array to find minimum subarray sum
// }
//
// // Step 3: Find the minimum subarray sum using Kadane's algorithm on the negated array
// int minSubarraySum = kadane(nums);
Page 1 of 2
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxCircularSumSubArray.java
//
// // Step 4: Calculate the maximum circular subarray sum
// // If the total sum minus the minimum sum equals 0, it means all numbers are negative.
// if (totalSum == -minSubarraySum) {
// return maxSubarraySum; // No valid circular sum, return max subarray sum
// }
//
// // Return the maximum of normal max subarray and circular max subarray
// return Math.max(maxSubarraySum, totalSum + minSubarraySum);
// }
//
// public static void main(String[] args) {
// int[] nums = {8, -8, 9, -9, 10, -11, 12};
// System.out.println("Maximum Circular Subarray Sum: " + maxCircularSubarraySum(nums)); // Outp
// }
//}

public class MaxCircularSumSubArray {

public static int maxCircularSubarraySum(int[] nums) {
int maxKadane = kadane(nums);

int totalSum = 0;
for (int i = 0; i < nums.length; i++) {
totalSum += nums[i];
nums[i] = -nums[i];
}

int maxWrap = totalSum + kadane(nums);

return maxWrap == 0 ? maxKadane : Math.max(maxKadane, maxWrap);

}

private static int kadane(int[] nums) {

int maxSoFar = nums[0], currentMax = nums[0];
for (int i = 1; i < nums.length; i++) {
currentMax = Math.max(nums[i], currentMax + nums[i]);
maxSoFar = Math.max(maxSoFar, currentMax);
}
return maxSoFar;
}

public static void main(String[] args) {

int[] nums = {5, -3, 5};
System.out.println(maxCircularSubarraySum(nums)); // Output: 10
}
}

Page 2 of 2
File - C:\Users\USER\IdeaProjects\Arrays\src\LongestSubarrayWithSumK.java
import java.util.HashMap;

public class LongestSubarrayWithSumK {

public static int longestSubarrayWithSumK(int[] nums, int k) {
HashMap<Integer, Integer> map = new HashMap<>();
int sum = 0, maxLength = 0;

for (int i = 0; i < nums.length; i++) {

sum += nums[i];

if (sum == k) {
maxLength = i + 1;
}

if (map.containsKey(sum - k)) {
maxLength = Math.max(maxLength, i - map.get(sum - k));
}

map.putIfAbsent(sum, i);
}
return maxLength;
}

public static void main(String[] args) {

int[] nums = {1, -1, 5, -2, 3};
int k = 3;
System.out.println(longestSubarrayWithSumK(nums, k)); // Output: 4
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\LongestSubstringDistinct.java
import java.util.HashMap;

public class LongestSubstringDistinct {

public static int longestSubstringKDistinct(String s,int k){
HashMap<Character,Integer> map=new HashMap<>();
int maxi=0,start=0;
for (int end = 0; end < s.length(); end++) {
map.put(s.charAt(end),map.getOrDefault(s.charAt(end),0)+1);
while (map.size()>k){
char leftChar=s.charAt(start);
map.put(leftChar, map.get(leftChar)-1);
if(map.get(leftChar)==0){
map.remove(leftChar);

}
start++;

}
maxi=Math.max(maxi,end-start+1);
}
return maxi;
}

public static void main(String[] args) {

String s="araaci";
int k=2;
System.out.println(longestSubstringKDistinct(s,k));
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MaxLengthPositiveProduct.java
public class MaxLengthPositiveProduct {
public static int getMaxLen(int[] nums) {
int positive = 0, negative = 0, maxLength = 0;

for (int num : nums) {

if (num > 0) {
positive++;
negative = (negative == 0) ? 0 : negative + 1;
} else if (num < 0) {
int temp = positive;
positive = (negative == 0) ? 0 : negative + 1;
negative = temp + 1;
} else {
positive = 0;
negative = 0;
}
maxLength = Math.max(maxLength, positive);
}
return maxLength;
}

public static void main(String[] args) {

int[] nums = {1, -2, -3, 4};
System.out.println(getMaxLen(nums)); // Output: 4
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\MinArrowsToBurstBalloons.java
import java.util.*;

public class MinArrowsToBurstBalloons {

public static int findMinArrowShots(int[][] points) {
Arrays.sort(points, Comparator.comparingInt(a -> a[1]));
int arrows = 1, end = points[0][1];

for (int i = 1; i < points.length; i++) {

if (points[i][0] > end) {
arrows++;
end = points[i][1];
}
}
return arrows;
}

public static void main(String[] args) {

int[][] points = {{10, 16}, {2, 8}, {1, 6}, {7, 12}};
System.out.println(findMinArrowShots(points)); // Output: 2
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\CountNonOverlappingIntervals.java
import java.util.*;

public class CountNonOverlappingIntervals {

public static int countNonOverlapping(int[][] intervals) {
Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
int count = 0, end = Integer.MIN_VALUE;

for (int[] interval : intervals) {

if (interval[0] >= end) {
count++;
end = interval[1];
}
}
return intervals.length-count;
}

public static void main(String[] args) {

int[][] intervals = {{1, 2}, {2, 3}};
System.out.println(countNonOverlapping(intervals));
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\Delete.java
package Array_Basic;
import java.util.Arrays;

public class Delete{

public static int[] deleteElement(int[] arr, int index) {
if (index < 0 || index >= arr.length) return arr;

// Shift elements left to fill the gap

for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}

// Resize the array by excluding the last element

return Arrays.copyOf(arr, arr.length - 1);
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4,5,6,7,8,9,10};
int index = 6;
System.out.println(Arrays.toString(deleteElement(arr, index)));
// Output: [1, 2, 4]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\Insert.java
package Array_Basic;

import java.util.Arrays;

public class Insert {

public static int[] insertElement(int[] arr, int index, int value) {
int[] result = new int[arr.length + 1];
for (int i = 0; i < index; i++) {
result[i] = arr[i];
}
result[index] = value;
for (int i = index; i < arr.length; i++) {
result[i + 1] = arr[i];
}
return result;
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4};
int index = 2, value = 5;
System.out.println(Arrays.toString(insertElement(arr, index, value)));
// Output: [1, 2, 5, 3, 4]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\MaxMin.java
package Array_Basic;

public class MaxMin {

public static int[] findMinMax(int[] arr) {
int min = arr[0], max = arr[0];
for (int num : arr) {
if (num < min) min = num;
if (num > max) max = num;
}
return new int[]{min, max};
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 5};
int[] result = findMinMax(arr);
System.out.println("Min: " + result[0] + ", Max: " + result[1]);
// Output: Min: 1, Max: 5
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\Reverse.java
package Array_Basic;
import java.util.Arrays;

public class Reverse {

public static void reverseArray(int[] arr) {
int start = 0, end = arr.length - 1;
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 5};
reverseArray(arr);
System.out.println(Arrays.toString(arr));
// Output: [5, 4, 3, 2, 1]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\BubbleSort.java
package Array_Basic;
import java.util.Arrays;

public class BubbleSort {

public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

public static void main(String[] args) {

int[] arr = {5, 3, 1, 4, 2};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
// Output: [1, 2, 3, 4, 5]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\RotateArray.java
package Array_Basic;

import java.util.Arrays;

public class RotateArray {

// Method to rotate array to the right by k steps

public static void rotateRight(int[] nums, int k) {
k = k % nums.length; // To handle cases where k > nums.length
reverse(nums, 0, nums.length - 1); // Reverse the entire array
reverse(nums, 0, k - 1); // Reverse the first k elements
reverse(nums, k, nums.length - 1); // Reverse the remaining elements
}

// Method to rotate array to the left by k steps

public static void rotateLeft(int[] nums, int k) {
k = k % nums.length; // To handle cases where k > nums.length
reverse(nums, 0, k - 1); // Reverse the first k elements
reverse(nums, k, nums.length - 1); // Reverse the remaining elements
reverse(nums, 0, nums.length - 1); // Reverse the entire array
}

// Helper method to reverse elements of the array between start and end indices
private static void reverse(int[] nums, int start, int end) {
while (start < end) {
int temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}

public static void main(String[] args) {

// int[] arrRight = {1, 2, 3, 4, 5, 6, 7};
// rotateRight(arrRight, 3);
// System.out.println("Right rotation by 3: " + Arrays.toString(arrRight));
// // Output: [5, 6, 7, 1, 2, 3, 4]

int[] arrLeft = {1, 2, 3, 4, 5, 6, 7};

rotateLeft(arrLeft, 3);
System.out.println("Left rotation by 3: " + Arrays.toString(arrLeft));
// Output: [4, 5, 6, 7, 1, 2, 3]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\BinarySearch.java
package Array_Basic;

public class BinarySearch {

public static int binarySearch(int[] arr, int target) {
int left = 0, right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) return mid;
if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 5,6,7,8,9,10,11,12};
System.out.println(binarySearch(arr, 5)); // Output: 2
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\KLargestElements.java
package Array_Basic;
import java.util.Arrays;
import java.util.PriorityQueue;

public class KLargestElements {

public static int[] findKLargest(int[] arr, int k) {
PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int num : arr) {
pq.add(num);
if (pq.size() > k) {
pq.poll();
}
}
return pq.stream().mapToInt(i -> i).toArray();
}

public static void main(String[] args) {

int[] arr = {3, 2, 1, 5, 6, 4};
int k = 2;
System.out.println(Arrays.toString(findKLargest(arr, k)));
// Output: [5, 6]
}
}

Page 1 of 1
File - C:\Users\USER\IdeaProjects\Arrays\src\Array_Basic\KSmallestElements.java
package Array_Basic;
import java.util.Arrays;
import java.util.PriorityQueue;

public class KSmallestElements {

public static int[] findKSmallest(int[] arr, int k) {
// Max-heap: PriorityQueue with reverse order
PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a); // Max-heap

for (int num : arr) {

pq.add(num);
if (pq.size() > k) {
pq.poll(); // Remove the largest element if the heap exceeds size k
}
}

// Convert the heap to an array

int[] result=pq.stream().mapToInt(i -> i).toArray();
Arrays.sort(result);
return result;
}

public static void main(String[] args) {

int[] arr = {3, 2, 1, 5, 6, 4};
int k = 2;
System.out.println(Arrays.toString(findKSmallest(arr, k)));
// Output: [1, 2]
}
}

Page 1 of 1