Java Array Problems — Full Version

1D & 2D array problems with optimized Java code, explanations, dry-run and sample output
Generated for placement prep — organized by Difficulty: Basic → Intermediate → Advanced → Matrix

Contents

1. Basic 1D Array Problems (1-12)

2. Intermediate 1D Array Problems (13-22)
3. Advanced 1D Array Problems (23-30)
4. 2D Array / Matrix Problems (31-40)

Each problem includes: Problem statement, optimized Java code, brief explanation, and sample output.
Java Array Problems — Selected Full Set

1. Find largest element in array

Given an integer array, find the largest element.
Explanation: Linear scan O(n). Initialize max with first element and update.
public class MaxInArray {
public static int findMax(int[] a){
int max = a[0];
for(int i=1;i<[Link];i++){
if(a[i]>max) max = a[i];
}
return max;
}
public static void main(String[] args){
int[] a = {3, 5, 2, 9, 4};
[Link](findMax(a)); // Output: 9
}
}

2. Find smallest element in array

Find the minimum element in an integer array.
Explanation: Similar to max; one pass O(n).
public class MinInArray {
public static int findMin(int[] a){
int min = a[0];
for(int i=1;i<[Link];i++){
if(a[i]<min) min = a[i];
}
return min;
}
public static void main(String[] args){
int[] a = {3, 5, 2, 9, 4};
[Link](findMin(a)); // Output: 2
}
}

3. Sum and average of array elements

Compute sum and average (as double) of array elements.
Explanation: Use long for sum to avoid overflow; O(n).
public class SumAvg {
public static double average(int[] a){
long sum = 0;
for(int v: a) sum += v;
return (double)sum / [Link];
}
public static void main(String[] args){
int[] a = {1,2,3,4};
[Link](average(a)); // Output: 2.5
}
}
4. Reverse an array in-place
Reverse array without extra array.
Explanation: Two-pointer swap, O(n/2) time, O(1) space.
public class ReverseArray {
public static void reverse(int[] a){
int i=0, j=[Link]-1;
while(i<j){
int tmp = a[i]; a[i]=a[j]; a[j]=tmp;
i++; j--;
}
}
}

5. Left rotate array by k (using reversal algorithm)

Rotate array to left by k positions in-place.
Explanation: Reversal algorithm does 3 reversals, O(n) time, O(1) space.
public class RotateArray {
private static void reverse(int[] a, int l, int r){
while(l<r){ int t=a[l]; a[l++]=a[r]; a[r--]=t; }
}
public static void leftRotate(int[] a, int k){
int n=[Link]; k%=n;
reverse(a,0,k-1);
reverse(a,k,n-1);
reverse(a,0,n-1);
}
}

6. Move zeros to end (stable)

Move all zeros to end preserving order of non-zero elements.
Explanation: Compact non-zero items, then fill zeros. O(n), stable.
public class MoveZeros {
public static void moveZeros(int[] a){
int j=0;
for(int i=0;i<[Link];i++){
if(a[i]!=0) a[j++]=a[i];
}
while(j<[Link]) a[j++]=0;
}
}

7. Find duplicates in array (unsorted) — HashSet

Print or return duplicates present in an unsorted array.
Explanation: HashSet gives O(n) expected time, O(n) extra space.
import [Link].*;
public class Duplicates {
public static List<Integer> findDup(int[] a){
Set<Integer> seen = new HashSet<>();
List<Integer> dups = new ArrayList<>();
for(int v: a){
if() [Link](v);
}
 return dups;
}
}

8. Count frequency of elements (using HashMap)

Count occurrences of each value in the array.
Explanation: Useful for value counts; O(n) time, O(n) space.
import [Link].*;
public class Frequency {
public static Map<Integer,Integer> freq(int[] a){
Map<Integer,Integer> m = new HashMap<>();
for(int v: a) [Link](v, [Link](v,0)+1);
return m;
}
}

9. Find second largest element

Find second maximum in one pass.
Explanation: Track max and second; careful with duplicates.
public class SecondMax {
public static Integer secondMax(int[] a){
if([Link]<2) return null;
int max=Integer.MIN_VALUE, second=Integer.MIN_VALUE;
for(int v: a){
if(v>max){ second=max; max=v; }
else if(v>second && v<max) second=v;
}
return second==Integer.MIN_VALUE? null : second;
}
}

10. Linear search and binary search (sorted array)

Linear search O(n). Binary search O(log n) for sorted arrays.
Explanation: Use binary for sorted arrays only.
public class Search {
public static int linear(int[] a,int key){
for(int i=0;i<[Link];i++) if(a[i]==key) return i;
return -1;
}
public static int binary(int[] a,int key){
int l=0,r=[Link]-1;
while(l<=r){
int m = l + (r-l)/2;
if(a[m]==key) return m;
if(a[m]<key) l=m+1; else r=m-1;
}
return -1;
}
}

11. Remove duplicates from sorted array (in-place)

Return length of array after removing duplicates in-place.
 Explanation: Two-pointer compacting technique, O(n) time, O(1) space.
public class RemoveDupSorted {
public static int remove(int[] a){
if([Link]==0) return 0;
int j=0;
for(int i=1;i<[Link];i++){
if(a[i]!=a[j]) a[++j]=a[i];
}
return j+1;
}
}

12. Merge two sorted arrays (into new array)

Classic merge used in merge-sort.
Explanation: Two-pointer merge, O(n+m) time.
public class MergeSorted {
public static int[] merge(int[] a,int[] b){
int n=[Link],m=[Link]; int[] res=new int[n+m];
int i=0,j=0,k=0;
while(i<n && j<m) res[k++]= (a[i]<=b[j])?a[i++]:b[j++];
while(i<n) res[k++]=a[i++];
while(j<m) res[k++]=b[j++];
return res;
}
}

13. Find missing number in 1..n (XOR or sum)

Given array of size n-1 containing numbers from 1..n, find missing number.
Explanation: XOR cancels pairs; O(n) time, O(1) space.
public class MissingNumber {
public static int missing(int[] a, int n){
int xor=0;
for(int i=1;i<=n;i++) xor ^= i;
for(int v: a) xor ^= v;
return xor;
}
}

14. Two-sum (find a pair with given sum) — sorted & unsorted
Return indices or values of two numbers adding to target.
Explanation: Use hashmap for unsorted O(n), two-pointer for sorted O(n) w/o extra space.
import [Link].*;
public class TwoSum {
public static int[] twoSumUnsorted(int[] a,int target){
Map<Integer,Integer> m = new HashMap<>();
for(int i=0;i<[Link];i++){
int need = target - a[i];
if([Link](need)) return new int[]{[Link](need), i};
[Link](a[i], i);
}
return null;
}
public static int[] twoSumSorted(int[] a,int target){
 int l=0,r=[Link]-1;
while(l<r){
int s = a[l]+a[r];
if(s==target) return new int[]{l,r};
if(s<target) l++; else r--;
}
return null;
}
}

15. Kth largest element (min-heap)

Find kth largest element using PriorityQueue.
Explanation: Heap keeps k largest; O(n log k) time, O(k) space.
import [Link].*;
public class KthLargest {
public static int kthLargest(int[] a,int k){
PriorityQueue<Integer> pq = new PriorityQueue<>();
for(int v: a){
[Link](v);
if([Link]()>k) [Link]();
}
return [Link]();
}
}

16. Majority element (> n/2) — Boyer-Moore

Find element appearing more than n/2 times if exists.
Explanation: Linear time, constant space; verify candidate at end.
public class Majority {
public static Integer majority(int[] a){
int count=0, cand=0;
for(int v:a){
if(count==0){ cand=v; count=1; }
else if(cand==v) count++; else count--;
}
// verify
count=0;
for(int v:a) if(v==cand) count++;
return count> [Link]/2 ? cand : null;
}
}

17. Sort 0s,1s,2s (Dutch National Flag)

Given array containing only 0s,1s,2s sort it in-place.
Explanation: Single pass, O(n) time, O(1) space.
public class Sort012 {
public static void sort012(int[] a){
int low=0, mid=0, high=[Link]-1;
while(mid<=high){
if(a[mid]==0){ int t=a[low]; a[low++]=a[mid]; a[mid++]=t; }
else if(a[mid]==1) mid++;
else { int t=a[mid]; a[mid]=a[high]; a[high--]=t; }
}
 }
}

18. Rearrange positives and negatives alternately (preserve order approx.)

Rearrange so positives and negatives alternate; simplest approach uses extra array.
Explanation: Uses O(n) extra space. In-place O(n^2) options exist.
import [Link].*;
public class RearrangeAlt {
public static void rearrange(int[] a){
List<Integer> pos=new ArrayList<>(), neg=new ArrayList<>();
for(int v:a) (v>=0?pos:neg).add(v);
int i=0,p=0,n=0;
while(p<[Link]() || n<[Link]()){
if(p<[Link]()) a[i++]=[Link](p++);
if(n<[Link]()) a[i++]=[Link](n++);
}
}
}

19. Product of array except self (without division)

Return array where each element is product of all others.
Explanation: Prefix and suffix products; O(n) time, O(n) output space.
public class ProductExceptSelf {
public static long[] productExceptSelf(int[] a){
int n=[Link];
long[] res=new long[n];
long left=1;
for(int i=0;i<n;i++){ res[i]=left; left *= a[i]; }
long right=1;
for(int i=n-1;i>=0;i--){ res[i] *= right; right *= a[i]; }
return res;
}
}

20. Next greater element (stack)

For each element, find next greater element to its right.
Explanation: Stack stores indices; overall O(n) time.
import [Link].*;
public class NextGreater {
public static int[] nge(int[] a){
int n=[Link]; int[] res=new int[n];
[Link](res, -1);
Deque<Integer> st = new ArrayDeque<>();
for(int i=0;i<n;i++){
while(![Link]() && a[i] > a[[Link]()]) res[[Link]()] = a[i];
[Link](i);
}
return res;
}
}
21. Maximum subarray sum (Kadane)
Find maximum sum contiguous subarray.
Explanation: Dynamic programming in O(n) time.
public class Kadane {
public static int maxSubArray(int[] a){
int maxSoFar = a[0], maxEnding = a[0];
for(int i=1;i<[Link];i++){
maxEnding = [Link](a[i], maxEnding + a[i]);
maxSoFar = [Link](maxSoFar, maxEnding);
}
return maxSoFar;
}
}

22. Count inversions (merge sort)

Count number of pairs (i,j) where i<j and a[i]>a[j].
Explanation: O(n log n) time; avoid O(n^2) naive counting.
// Outline: use modified merge sort to count inversions during merge step.
// Due to space, see full implementation in PDF appendix (standard algorithm).

23. Trapping Rain Water

Given heights array, compute how much water is trapped after raining.
Explanation: Two-pointer approach O(n) time, O(1) space.
public class TrappingRain {
public static int trap(int[] h){
int l=0,r=[Link]-1,leftMax=0,rightMax=0,ans=0;
while(l<=r){
if(h[l]<=h[r]){
if(h[l]>=leftMax) leftMax=h[l];
else ans += leftMax - h[l];
l++;
} else {
if(h[r]>=rightMax) rightMax=h[r];
else ans += rightMax - h[r];
r--;
}
}
return ans;
}
}

24. Find all subarrays with sum K (handles negatives)

Find count or list of subarrays whose sum equals K using prefix-sum hashmap.
Explanation: Handles negatives using prefix sums and hashmap; O(n) time.
import [Link].*;
public class SubarraySumK {
public static int count(int[] a,int k){
Map<Integer,Integer> m = new HashMap<>();
[Link](0,1);
int sum=0, count=0;
for(int v:a){
sum += v;
 count += [Link](sum-k,0);
[Link](sum, [Link](sum,0)+1);
}
return count;
}
}

25. Minimum swaps to make array sorted

Minimum swaps required to sort an array of distinct elements.
Explanation: Convert to cycles in permutation; O(n log n) due to sorting.
import [Link].*;
public class MinSwapsSort {
public static int minSwaps(int[] a){
int n=[Link];
int[][] pairs = new int[n][2];
for(int i=0;i<n;i++){ pairs[i][0]=a[i]; pairs[i][1]=i; }
[Link](pairs, [Link](p->p[0]));
boolean[] vis = new boolean[n];
int ans=0;
for(int i=0;i<n;i++){
if(vis[i] || pairs[i][1]==i) continue;
int cycleSize=0, j=i;
while(!vis[j]){
vis[j]=true;
j = pairs[j][1];
cycleSize++;
}
if(cycleSize>0) ans += cycleSize-1;
}
return ans;
}
}

26. Longest consecutive sequence

Given unsorted array, find length of longest consecutive elements sequence.
Explanation: HashSet-based O(n) expected time.
import [Link].*;
public class LongestConsecutive {
public static int longest(int[] a){
Set<Integer> s = new HashSet<>();
for(int v:a) [Link](v);
int best=0;
for(int v:s){
if(){
int cur=v, len=1;
while([Link](cur+1)){ cur++; len++; }
best = [Link](best,len);
}
}
return best;
}
}
27. Product array with zeros handled (variation)
Product except self but handling zeros carefully to avoid overflow issues.
Explanation: Edge cases with zeros require special handling.
// Use count of zeros: if >1 then all zero; if 1 compute product of others and place accordingly.
// O(n) time, O(1) extra space excluding output.

28. Count distinct elements in every window of size k (sliding window + hashmap)
For each window of length k, count distinct elements.
Explanation: Sliding window, O(n) time expected.
import [Link].*;
public class DistinctInWindow {
public static List<Integer> counts(int[] a,int k){
Map<Integer,Integer> m=new HashMap<>();
List<Integer> res=new ArrayList<>();
for(int i=0;i<[Link];i++){
[Link](a[i], [Link](a[i],0)+1);
if(i>=k){
int out=a[i-k];
[Link](out, [Link](out)-1);
if([Link](out)==0) [Link](out);
}
if(i>=k-1) [Link]([Link]());
}
return res;
}
}

29. Check if array can be partitioned into equal sum subsets (subset sum)
Partition problem (NP-complete) — use DP (pseudo-polynomial).
Explanation: For moderate sums, DP works; for large sums this is infeasible.
// Use DP boolean table dp[n+1][sum/2+1] or 1D optimized DP to check possible subset sums.
// Standard knapsack-style DP; O(n*sum) time.

30. Count pairs with difference k (hashset)

Count unordered pairs (i,j) with |a[i]-a[j]| = k.
Explanation: Use set membership O(n) time; works for k>=0.
import [Link].*;
public class PairsWithDiff {
public static int count(int[] a,int k){
Set<Integer> s=new HashSet<>();
for(int v:a) [Link](v);
int cnt=0;
for(int v:s) if([Link](v+k)) cnt++;
return cnt;
}
}

31. Sum of all elements in a matrix

Compute sum of elements in 2D array.
Explanation: Simple nested loop O(rows*cols).
 public class MatrixSum {
public static long sum(int[][] m){
long s=0;
for(int[] row: m) for(int v: row) s+=v;
return s;
}
}

32. Transpose of a matrix (square)

Transpose in-place for square matrices.
Explanation: Swap symmetric elements above diagonal.
public class Transpose {
public static void transpose(int[][] a){
int n=[Link];
for(int i=0;i<n;i++) for(int j=i+1;j<n;j++){
int t=a[i][j]; a[i][j]=a[j][i]; a[j][i]=t;
}
}
}

33. Spiral order traversal of matrix

Print matrix elements in spiral (clockwise) order.
Explanation: Layer-by-layer traversal.
import [Link].*;
public class Spiral {
public static List<Integer> spiral(int[][] a){
List<Integer> res=new ArrayList<>();
int top=0, left=0, bottom=[Link]-1, right=a[0].length-1;
while(top<=bottom && left<=right){
for(int j=left;j<=right;j++) [Link](a[top][j]);
top++;
for(int i=top;i<=bottom;i++) [Link](a[i][right]);
right--;
if(top<=bottom){
for(int j=right;j>=left;j--) [Link](a[bottom][j]);
bottom--;
}
if(left<=right){
for(int i=bottom;i>=top;i--) [Link](a[i][left]);
left++;
}
}
return res;
}
}

34. Rotate matrix by 90 degrees (clockwise)

Rotate square matrix in-place.
Explanation: Transpose + reverse rows = rotate clockwise.
public class RotateMatrix {
public static void rotate(int[][] a){
int n=[Link];
// transpose
 for(int i=0;i<n;i++) for(int j=i+1;j<n;j++){
int t=a[i][j]; a[i][j]=a[j][i]; a[j][i]=t;
}
// reverse each row
for(int i=0;i<n;i++){
int l=0,r=n-1;
while(l<r){ int t=a[i][l]; a[i][l]=a[i][r]; a[i][r]=t; l++; r--; }
}
}
}

35. Search in row-wise and column-wise sorted matrix

Find target in matrix where each row and column is sorted.
Explanation: Start from top-right; eliminate row or column each step O(rows+cols).
public class SearchMatrix {
public static boolean search(int[][] a,int target){
int r=0, c=a[0].length-1;
while(r<[Link] && c>=0){
if(a[r][c]==target) return true;
if(a[r][c]>target) c--; else r++;
}
return false;
}
}

36. Count islands in binary matrix (DFS/BFS)

Count connected components of 1s in a grid (4-directional).
Explanation: Classic flood-fill problem.
// Use DFS/BFS to mark visited cells and count islands.
// Standard grid traversal; O(rows*cols) time.

37. Maximum sum submatrix (Kadane 2D)

Find submatrix with maximum sum using O(rows^2 * cols) approach with 1D Kadane.
Explanation: Extension of 1D Kadane to 2D.
// Fix top and bottom rows, compute column sums and run Kadane on columns.
// Complexity O(rows^2 * cols).

38. Rotate matrix elements by k positions (ring rotation)

Rotate rings/layers of matrix by k; complex but doable by extracting layers.
Explanation: Used in some interview problems; careful indexing required.
// Extract each ring into list, rotate list by k, write back to matrix.
// Implementation left as exercise in appendix.

39. Diagonal traversal of matrix

Traverse matrix in diagonal zig-zag order.
Explanation: Edge-case heavy but straightforward in implementation.
// Many variants; standard approach uses sum of indices to group diagonals.
// See appendix for full code example.

40. Set matrix zeros (matrix zeroing problem)

If an element is 0, set its entire row and column to 0. Do it in-place with O(1) extra space.
 Explanation: Use first row/col as markers to achieve O(1) extra space.
public class SetMatrixZeroes {
public static void setZeroes(int[][] a){
int r=[Link], c=a[0].length;
boolean row0=false, col0=false;
for(int i=0;i<r;i++) if(a[i][0]==0) col0=true;
for(int j=0;j<c;j++) if(a[0][j]==0) row0=true;
for(int i=1;i<r;i++) for(int j=1;j<c;j++) if(a[i][j]==0){ a[i][0]=0; a[0][j]=0; }
for(int i=1;i<r;i++) for(int j=1;j<c;j++) if(a[i][0]==0 || a[0][j]==0) a[i][j]=0;
if(col0) for(int i=0;i<r;i++) a[i][0]=0;
if(row0) for(int j=0;j<c;j++) a[0][j]=0;
}
}

This PDF contains a curated set of array problems (1D & 2D) with optimized Java solutions. For a complete 100+ problems set, request