Solve These 12 Common Interview

Problems in Python & Java

Comprehensive Guide to Essential Coding Interview

Questions and Solutions: Master Key Algorithms, Data
Structures, and Programming Challenges in Python
and Java
1. Array Reversal (Common array manipulation
question)
Python:
```python
def reverse_array(arr):
return arr[::-1]

arr = [1, 2, 3, 4, 5]
print(reverse_array(arr)) # Output: [5, 4, 3, 2, 1]
```

**Java:**
```java
public class ReverseArray {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i] + " ");
}
}
}
```

2. Palindrome Check
python:
```python
def is_palindrome(s):
return s == s[::-1]

print(is_palindrome("racecar")) # Output: True

print(is_palindrome("hello")) # Output: False
```

**Java:**
```java
public class Palindrome {
public static boolean isPalindrome(String str) {
int n = str.length();
for (int i = 0; i < n / 2; i++) {
if (str.charAt(i) != str.charAt(n - i - 1)) {
return false;
}
}
return true;
}

public static void main(String[] args) {

System.out.println(isPalindrome("racecar")); // Output: true
System.out.println(isPalindrome("hello")); // Output: false
}
}
```
3. Fibonacci Sequence
Python:
```python
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
print(a, end=" ")
a, b = b, a + b

fibonacci(10) # Output: 0 1 1 2 3 5 8 13 21 34
```

Java:
```java
public class Fibonacci {
public static void main(String[] args) {
int n = 10, a = 0, b = 1;
for (int i = 1; i <= n; ++i) {
System.out.print(a + " ");
int next = a + b;
a = b;
b = next;
}
}
}
4. Find Duplicates in Array
Python:
```python
def find_duplicates(arr):
return [x for x in set(arr) if arr.count(x) > 1]

arr = [1, 2, 3, 4, 5, 3, 2]
print(find_duplicates(arr)) # Output: [2, 3]
```

Java:
```java
import java.util.*;

public class Duplicates {

public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 3, 2};
Set<Integer> set = new HashSet<>();
Set<Integer> duplicates = new HashSet<>();

for (int num : arr) {

if (!set.add(num)) {
duplicates.add(num);
}
}
System.out.println(duplicates); // Output: [2, 3]
 }
}
```

5. Binary Search
Python:
```python
def binary_search(arr, target):
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return -1

arr = [1, 2, 3, 4, 5, 6, 7]
print(binary_search(arr, 5)) # Output: 4
```

Java:
```java
public class BinarySearch {
 public static int binarySearch(int[] arr, int target) {
int low = 0, high = arr.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}

public static void main(String[] args) {

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

6. Linked List Cycle Detection (Floyd’s Cycle Detection

Algorithm)
Python:
```python
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next

def has_cycle(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
```

Java:
```java
class ListNode {
int val;
ListNode next;
ListNode(int val) {
this.val = val;
this.next = null;
}
}
public class LinkedListCycle {
public static boolean hasCycle(ListNode head) {
if (head == null) return false;
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if (slow == fast) return true;
}
return false;
}
}

7. Merge Two Sorted Arrays

Python:
```python
def merge_sorted_arrays(arr1, arr2):
merged = []
i=j=0
while i < len(arr1) and j < len(arr2):
if arr1[i] < arr2[j]:
merged.append(arr1[i])
i += 1
else:
merged.append(arr2[j])
 j += 1
merged.extend(arr1[i:])
merged.extend(arr2[j:])
return merged

arr1 = [1, 3, 5]
arr2 = [2, 4, 6]
print(merge_sorted_arrays(arr1, arr2)) # Output: [1, 2, 3, 4, 5, 6]
```

Java:
```java
import java.util.Arrays;

public class MergeSortedArrays {

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

public static void main(String[] args) {

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

8. Find the Kth Largest Element

Python:
```python
import heapq

def kth_largest(arr, k):

return heapq.nlargest(k, arr)[-1]

arr = [3, 2, 1, 5, 6, 4]
print(kth_largest(arr, 2)) # Output: 5
```

Java:
```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};
System.out.println(findKthLargest(nums, 2)); // Output: 5
}
}
```
9. Depth-First Search (DFS) in a Graph
Python:
```python
def dfs(graph, node, visited=None):
if visited is None:
visited = set()
visited.add(node)
print(node, end=" ")
for neighbor in graph[node]:
if neighbor not in visited:
dfs(graph, neighbor, visited)

graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}
dfs(graph, 'A') # Output: A B D E F C
```

Java:
```java
import java.util.*;
public class GraphDFS {
private Map<String, List<String>> adjList = new HashMap<>();

public void addEdge(String node, String neighbor) {

adjList.computeIfAbsent(node, k -> new
ArrayList<>()).add(neighbor);
}

public void dfs(String node, Set<String> visited) {

if (visited.contains(node)) return;
visited.add(node);
System.out.print(node + " ");
for (String neighbor : adjList.getOrDefault(node, new
ArrayList<>())) {
dfs(neighbor, visited);
}
}

public static void main(String[] args) {

GraphDFS graph = new GraphDFS();
graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("B", "D");
graph.addEdge("B", "E");
graph.addEdge("C", "F");
Set<String> visited = new HashSet<>();
 graph.dfs("A", visited); // Output: A B D E C F
}
}
```

10. Breadth-First Search (BFS) in a Graph

Python:
```python
from collections import deque

def bfs(graph, start):

visited = set()
queue = deque([start])
visited.add(start)

while queue:
node = queue.popleft()
print(node, end=" ")
for neighbor in graph[node]:
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)

graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
 'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}
bfs(graph, 'A') # Output: A B C D E F
```

Java:
```java
import java.util.*;

public class GraphBFS {

private Map<String, List<String>> adjList = new HashMap<>();

public void addEdge(String node, String neighbor) {

adjList.computeIfAbsent(node, k -> new
ArrayList<>()).add(neighbor);
}

public void bfs(String start) {

Set<String> visited = new HashSet<>();
Queue<String> queue = new LinkedList<>();
visited.add(start);
queue.add(start);
 while (!queue.isEmpty()) {
String node = queue.poll();
System.out.print(node + " ");
for (String neighbor : adjList.getOrDefault(node, new
ArrayList<>())) {
if (!visited.contains(neighbor)) {
visited.add(neighbor);
queue.add(neighbor);
}
}
}
}

public static void main(String[] args) {

GraphBFS graph = new GraphBFS();
graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("B", "D");
graph.addEdge("B", "E");
graph.addEdge("C", "F");
graph.bfs("A"); // Output: A B C D E F
}
}
```

11. Find Missing Number in an Array (1 to N)

Python:
```python
def find_missing_number(arr):
n = len(arr) + 1
total_sum = n * (n + 1) // 2
return total_sum - sum(arr)

arr = [1, 2, 4, 5, 6]
print(find_missing_number(arr)) # Output: 3
```

Java:
```java
public class MissingNumber {
public static int findMissingNumber(int[] arr) {
int n = arr.length + 1;
int totalSum = n * (n + 1) / 2;
int sum = 0;
for (int num : arr) {
sum += num;
}
return totalSum - sum;
}

public static void main(String[] args) {

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

12. Find the Longest Common Subsequence (LCS)

Python:
```python
def lcs(X, Y):
m, n = len(X), len(Y)
dp = [[0] * (n + 1) for _ in range(m + 1)]

for i in range(1, m + 1):

for j in range(1, n + 1):
if X[i - 1] == Y[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
return dp[m][n]

X = "AGGTAB"
Y = "GXTXAYB"
print(lcs(X, Y)) # Output: 4
```

Java:
```java
public class LCS {
public static int lcs(String X, String Y) {
int m = X.length();
int n = Y.length();
int[][] dp = new int[m + 1][n + 1];

for (int i = 1; i <= m; i++) {

for (int j = 1; j <= n; j++) {
if (X.charAt(i - 1) == Y.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = Math.max(dp

[i - 1][j], dp[i][j - 1]);

}
}
}
return dp[m][n];
}

public static void main(String[] args) {

String X = "AGGTAB";
String Y = "GXTXAYB";
System.out.println(lcs(X, Y)); // Output: 4
}
}
```

These code snippets provide valuable examples for coding interviews,

covering important concepts such as merging arrays, searching algorithms,
and dynamic programming.

Follow us for more.

Jetsetjoy66@gmail.com – Gmail

Created by: