Top 50 Repeated Coding Interview Questions

BY SYNTAX ERROR - Instagram: @code.abhii07

// Array & String Problems

public class InterviewProblems {

// 1. Two Sum
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement)) {
return new int[]{map.get(complement), i};
}
map.put(nums[i], i);
}
return new int[]{};
}

// 2. Reverse String
public void reverseString(char[] s) {
int left = 0, right = s.length - 1;
 while (left < right) {
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}

// 3. Valid Palindrome
public boolean isPalindrome(String s) {
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) {
if (Character.isLetterOrDigit(c)) {
sb.append(Character.toLowerCase(c));
}
}
String cleaned = sb.toString();
return cleaned.equals(new
StringBuilder(cleaned).reverse().toString());
}
 // 4. Maximum Subarray (Kadane's Algorithm)
public int maxSubArray(int[] nums) {
int maxSum = nums[0];
int currentSum = nums[0];
for (int i = 1; i < nums.length; i++) {
currentSum = Math.max(nums[i], currentSum +
nums[i]);
maxSum = Math.max(maxSum, currentSum);
}
return maxSum;
}

// 5. Contains Duplicate
public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>();
for (int num : nums) {
if (!set.add(num)) {
return true;
}
}
return false;
}
 // 6. Product of Array Except Self
public int[] productExceptSelf(int[] nums) {
int[] result = new int[nums.length];
result[0] = 1;
for (int i = 1; i < nums.length; i++) {
result[i] = result[i-1] * nums[i-1];
}
int right = 1;
for (int i = nums.length - 1; i >= 0; i--) {
result[i] *= right;
right *= nums[i];
}
return result;
}

// 7. Move Zeros
public void moveZeroes(int[] nums) {
int writeIndex = 0;
for (int readIndex = 0; readIndex < nums.length;
readIndex++) {
if (nums[readIndex] != 0) {
 nums[writeIndex++] = nums[readIndex];
}
}
while (writeIndex < nums.length) {
nums[writeIndex++] = 0;
}
}

// 8. Best Time to Buy and Sell Stock

public int maxProfit(int[] prices) {
int minPrice = Integer.MAX_VALUE;
int maxProfit = 0;
for (int price : prices) {
minPrice = Math.min(minPrice, price);
maxProfit = Math.max(maxProfit, price - minPrice);
}
return maxProfit;
}

// 9. Valid Anagram
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) return false;
 char[] sArray = s.toCharArray();
char[] tArray = t.toCharArray();
Arrays.sort(sArray);
Arrays.sort(tArray);
return Arrays.equals(sArray, tArray);
}

// 10. Longest Substring Without Repeating Characters

public int lengthOfLongestSubstring(String s) {
Set<Character> charSet = new HashSet<>();
int left = 0, maxLength = 0;
for (int right = 0; right < s.length(); right++) {
while (charSet.contains(s.charAt(right))) {
charSet.remove(s.charAt(left));
left++;
}
charSet.add(s.charAt(right));
maxLength = Math.max(maxLength, right - left + 1);
}
return maxLength;
}
}
// Definition for singly-linked list
class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next =
next; }
}

// Linked List Problems

class LinkedListProblems {

// 11. Reverse Linked List

public ListNode reverseList(ListNode head) {
ListNode prev = null;
ListNode current = head;
while (current != null) {
ListNode nextNode = current.next;
current.next = prev;
prev = current;
 current = nextNode;
}
return prev;
}

// 12. Merge Two Sorted Lists

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy = new ListNode(0);
ListNode current = dummy;
while (l1 != null && l2 != null) {
if (l1.val <= l2.val) {
current.next = l1;
l1 = l1.next;
} else {
current.next = l2;
l2 = l2.next;
}
current = current.next;
}
current.next = (l1 != null) ? l1 : l2;
return dummy.next;
}
 // 13. Remove Nth Node From End
public ListNode removeNthFromEnd(ListNode head, int n)
{
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode first = dummy;
ListNode second = dummy;

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

first = first.next;
}

while (first != null) {

first = first.next;
second = second.next;
}

second.next = second.next.next;
return dummy.next;
}
// 14. Linked List Cycle
public boolean hasCycle(ListNode head) {
if (head == null || head.next == null) return false;
ListNode slow = head;
ListNode fast = head;

while (fast != null && fast.next != null) {

slow = slow.next;
fast = fast.next.next;
if (slow == fast) return true;
}
return false;
}

// 15. Middle of Linked List

public ListNode middleNode(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
 return slow;
}
}

// Definition for a binary tree node

class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}

// Binary Tree Problems

class BinaryTreeProblems {

// 16. Maximum Depth of Binary Tree

 public int maxDepth(TreeNode root) {
if (root == null) return 0;
return 1 + Math.max(maxDepth(root.left),
maxDepth(root.right));
}

// 17. Binary Tree Inorder Traversal

public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
inorder(root, result);
return result;
}

private void inorder(TreeNode node, List<Integer> result)

{
if (node != null) {
inorder(node.left, result);
result.add(node.val);
inorder(node.right, result);
}
}
// 18. Same Tree
public boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null && q == null) return true;
if (p == null || q == null) return false;
return p.val == q.val &&
isSameTree(p.left, q.left) &&
isSameTree(p.right, q.right);
}

// 19. Symmetric Tree

public boolean isSymmetric(TreeNode root) {
return isMirror(root, root);
}

private boolean isMirror(TreeNode left, TreeNode right) {

if (left == null && right == null) return true;
if (left == null || right == null) return false;
return left.val == right.val &&
isMirror(left.left, right.right) &&
isMirror(left.right, right.left);
}
// 20. Binary Tree Level Order Traversal
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if (root == null) return result;

Queue<TreeNode> queue = new LinkedList<>();

queue.offer(root);

while (!queue.isEmpty()) {
int levelSize = queue.size();
List<Integer> level = new ArrayList<>();

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

TreeNode node = queue.poll();
level.add(node.val);

if (node.left != null) queue.offer(node.left);

if (node.right != null) queue.offer(node.right);
}
result.add(level);
}
return result;
 }
}

// Dynamic Programming Problems

class DynamicProgrammingProblems {

// 21. Climbing Stairs

public int climbStairs(int n) {
if (n <= 2) return n;
int prev2 = 1, prev1 = 2;
for (int i = 3; i <= n; i++) {
int current = prev1 + prev2;
prev2 = prev1;
prev1 = current;
}
return prev1;
}

// 22. House Robber

public int rob(int[] nums) {
if (nums.length == 0) return 0;
if (nums.length == 1) return nums[0];
 int[] dp = new int[nums.length];
dp[0] = nums[0];
dp[1] = Math.max(nums[0], nums[1]);

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

dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
}
return dp[nums.length - 1];
}

// 23. Coin Change

public int coinChange(int[] coins, int amount) {
int[] dp = new int[amount + 1];
Arrays.fill(dp, amount + 1);
dp[0] = 0;

for (int coin : coins) {

for (int i = coin; i <= amount; i++) {
dp[i] = Math.min(dp[i], dp[i - coin] + 1);
}
}
 return dp[amount] > amount ? -1 : dp[amount];
}

// 24. Longest Increasing Subsequence

public int lengthOfLIS(int[] nums) {
if (nums.length == 0) return 0;
int[] dp = new int[nums.length];
Arrays.fill(dp, 1);

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

for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
}
return Arrays.stream(dp).max().orElse(0);
}

// 25. Unique Paths

public int uniquePaths(int m, int n) {
int[][] dp = new int[m][n];
 for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 1;
} else {
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
}
return dp[m-1][n-1];
}
}

// Searching & Sorting Problems

class SearchingSortingProblems {

// 26. Binary Search

public 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;
 else if (nums[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}

// 27. Find First and Last Position

public int[] searchRange(int[] nums, int target) {
int first = findFirst(nums, target);
if (first == -1) return new int[]{-1, -1};
int last = findLast(nums, target);
return new int[]{first, last};
}

private int findFirst(int[] nums, int target) {

int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] >= target) right = mid - 1;
else left = mid + 1;
}
 return left < nums.length && nums[left] == target ? left :
-1;
}

private int findLast(int[] nums, int target) {

int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] <= target) left = mid + 1;
else right = mid - 1;
}
return right >= 0 && nums[right] == target ? right : -1;
}

// 28. Merge Intervals

public int[][] merge(int[][] intervals) {
if (intervals.length == 0) return new int[0][];
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

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

merged.add(intervals[0]);
 for (int i = 1; i < intervals.length; i++) {
int[] current = intervals[i];
int[] last = merged.get(merged.size() - 1);

if (current[0] <= last[1]) {

last[1] = Math.max(last[1], current[1]);
} else {
merged.add(current);
}
}
return merged.toArray(new int[merged.size()][]);
}

// 29. Search in Rotated Sorted Array

public int searchRotated(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 (nums[left] <= target && target < nums[mid]) {
 right = mid - 1;
} else {
left = mid + 1;
}
} else {
if (nums[mid] < target && target <= nums[right]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
}
return -1;
}

// 30. Kth Largest Element

public int findKthLargest(int[] nums, int k) {
PriorityQueue<Integer> pq = new
PriorityQueue<>(Collections.reverseOrder());
for (int num : nums) {
pq.offer(num);
}
 for (int i = 0; i < k - 1; i++) {
pq.poll();
}
return pq.poll();
}
}

// Stack & Queue Problems

class StackQueueProblems {

// 31. Valid Parentheses

public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
Map<Character, Character> mapping = new
HashMap<>();
mapping.put(')', '(');
mapping.put('}', '{');
mapping.put(']', '[');

for (char c : s.toCharArray()) {

if (mapping.containsKey(c)) {
 if (stack.isEmpty() || stack.pop() != mapping.get(c))
{
return false;
}
} else {
stack.push(c);
}
}
return stack.isEmpty();
}

// 32. Min Stack

class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minStack;

public MinStack() {
stack = new Stack<>();
minStack = new Stack<>();
}

public void push(int val) {

 stack.push(val);
if (minStack.isEmpty() || val <= minStack.peek()) {
minStack.push(val);
}
}

public void pop() {

if (stack.pop().equals(minStack.peek())) {
minStack.pop();
}
}

public int top() {

return stack.peek();
}

public int getMin() {

return minStack.peek();
}
}

// 33. Evaluate Reverse Polish Notation

 public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
Set<String> operators = new
HashSet<>(Arrays.asList("+", "-", "*", "/"));

for (String token : tokens) {

if (operators.contains(token)) {
int b = stack.pop();
int a = stack.pop();
switch (token) {
case "+": stack.push(a + b); break;
case "-": stack.push(a - b); break;
case "*": stack.push(a * b); break;
case "/": stack.push(a / b); break;
}
} else {
stack.push(Integer.parseInt(token));
}
}
return stack.pop();
}
 // 34. Daily Temperatures
public int[] dailyTemperatures(int[] temperatures) {
int[] result = new int[temperatures.length];
Stack<Integer> stack = new Stack<>();

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

while (!stack.isEmpty() && temperatures[stack.peek()]
< temperatures[i]) {
int idx = stack.pop();
result[idx] = i - idx;
}
stack.push(i);
}
return result;
}

// 35. Implement Queue using Stacks

class MyQueue {
private Stack<Integer> stack1;
private Stack<Integer> stack2;

public MyQueue() {
 stack1 = new Stack<>();
stack2 = new Stack<>();
}

public void push(int x) {

stack1.push(x);
}

public int pop() {

peek();
return stack2.pop();
}

public int peek() {

if (stack2.isEmpty()) {
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.peek();
}
 public boolean empty() {
return stack1.isEmpty() && stack2.isEmpty();
}
}
}

// Graph Problems
class GraphProblems {

// 36. Number of Islands

public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) return 0;
int count = 0;

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

for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == '1') {
dfs(grid, i, j);
count++;
}
}
}
 return count;
}

private void dfs(char[][] grid, int i, int j) {

if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length
|| grid[i][j] != '1') {
return;
}
grid[i][j] = '0';
dfs(grid, i + 1, j);
dfs(grid, i - 1, j);
dfs(grid, i, j + 1);
dfs(grid, i, j - 1);
}

// 37. Clone Graph (assuming Node class exists)

class Node {
public int val;
public List<Node> neighbors;

public Node() {
val = 0;
 neighbors = new ArrayList<Node>();
}

public Node(int _val) {

val = _val;
neighbors = new ArrayList<Node>();
}
}

public Node cloneGraph(Node node) {

if (node == null) return null;
Map<Node, Node> visited = new HashMap<>();
return dfsClone(node, visited);
}

private Node dfsClone(Node node, Map<Node, Node>

visited) {
if (visited.containsKey(node)) {
return visited.get(node);
}

Node clone = new Node(node.val);

 visited.put(node, clone);

for (Node neighbor : node.neighbors) {

clone.neighbors.add(dfsClone(neighbor, visited));
}
return clone;
}

// 38. Course Schedule

public boolean canFinish(int numCourses, int[][]
prerequisites) {
List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < numCourses; i++) {
graph.add(new ArrayList<>());
}

for (int[] prereq : prerequisites) {

graph.get(prereq[1]).add(prereq[0]);
}

int[] color = new int[numCourses]; // 0: white, 1: gray, 2:

black
 for (int i = 0; i < numCourses; i++) {
if (!dfsCanFinish(graph, i, color)) {
return false;
}
}
return true;
}

private boolean dfsCanFinish(List<List<Integer>> graph,

int node, int[] color) {
if (color[node] == 1) return false; // cycle detected
if (color[node] == 2) return true; // already processed

color[node] = 1; // mark as being processed

for (int neighbor : graph.get(node)) {
if (!dfsCanFinish(graph, neighbor, color)) {
return false;
}
}
color[node] = 2; // mark as processed
return true;
}

// 39. Pacific Atlantic Water Flow

public List<List<Integer>> pacificAtlantic(int[][] heights) {
List<List<Integer>> result = new ArrayList<>();
if (heights == null || heights.length == 0) return result;

int m = heights.length, n = heights[0].length;

boolean[][] pacific = new boolean[m][n];
boolean[][] atlantic = new boolean[m][n];

// Start DFS from edges

for (int i = 0; i < m; i++) {
dfsFlow(heights, i, 0, pacific);
dfsFlow(heights, i, n - 1, atlantic);
}
for (int j = 0; j < n; j++) {
dfsFlow(heights, 0, j, pacific);
dfsFlow(heights, m - 1, j, atlantic);
}

// Find cells that can reach both oceans

 for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (pacific[i][j] && atlantic[i][j]) {
result.add(Arrays.asList(i, j));
}
}
}
return result;
}

private void dfsFlow(int[][] heights, int i, int j, boolean[][]

ocean) {
ocean[i][j] = true;
int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

for (int[] dir : dirs) {

int ni = i + dir[0], nj = j + dir[1];
if (ni >= 0 && ni < heights.length && nj >= 0 && nj <
heights[0].length &&
!ocean[ni][nj] && heights[ni][nj] >= heights[i][j]) {
dfsFlow(heights, ni, nj, ocean);
}
 }
}

// 40. Word Ladder

public int ladderLength(String beginWord, String endWord,
List<String> wordList) {
if (!wordList.contains(endWord)) return 0;

Set<String> wordSet = new HashSet<>(wordList);

Queue<String> queue = new LinkedList<>();
queue.offer(beginWord);
int length = 1;

while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
String word = queue.poll();
if (word.equals(endWord)) return length;

for (int j = 0; j < word.length(); j++) {

for (char c = 'a'; c <= 'z'; c++) {
 String newWord = word.substring(0, j) + c +
word.substring(j + 1);
if (wordSet.contains(newWord)) {
wordSet.remove(newWord);
queue.offer(newWord);
}
}
}
}
length++;
}
return 0;
}
}

// Backtracking Problems
class BacktrackingProblems {

// 41. Generate Parentheses

public List<String> generateParenthesis(int n) {
List<String> result = new ArrayList<>();
backtrack(result, "", 0, 0, n);
 return result;
}

private void backtrack(List<String> result, String current,

int open, int close, int n) {
if (current.length() == 2 * n) {
result.add(current);
return;
}

if (open < n) {
backtrack(result, current + "(", open + 1, close, n);
}
if (close < open) {
backtrack(result, current + ")", open, close + 1, n);
}
}

// 42. Letter Combinations of Phone Number

public List<String> letterCombinations(String digits) {
List<String> result = new ArrayList<>();
if (digits.length() == 0) return result;
 String[] mapping = {
"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv",
"wxyz"
};

backtrackLetters(result, digits, 0, "", mapping);

return result;
}

private void backtrackLetters(List<String> result, String

digits, int index,
String current, String[] mapping) {
if (index == digits.length()) {
result.add(current);
return;
}

String letters = mapping[digits.charAt(index) - '0'];

for (char c : letters.toCharArray()) {
backtrackLetters(result, digits, index + 1, current + c,
mapping);
}
 }

// 43. Subsets
public List<List<Integer>> subsets(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
backtrackSubsets(result, new ArrayList<>(), nums, 0);
return result;
}

private void backtrackSubsets(List<List<Integer>> result,

List<Integer> current,
int[] nums, int start) {
result.add(new ArrayList<>(current));
for (int i = start; i < nums.length; i++) {
current.add(nums[i]);
backtrackSubsets(result, current, nums, i + 1);
current.remove(current.size() - 1);
}
}

// 44. Permutations
public List<List<Integer>> permute(int[] nums) {
 List<List<Integer>> result = new ArrayList<>();
backtrackPermute(result, new ArrayList<>(), nums);
return result;
}

private void backtrackPermute(List<List<Integer>> result,

List<Integer> current, int[] nums) {
if (current.size() == nums.length) {
result.add(new ArrayList<>(current));
return;
}

for (int num : nums) {

if (!current.contains(num)) {
current.add(num);
backtrackPermute(result, current, nums);
current.remove(current.size() - 1);
}
}
}