let's look at the questions frequently asked in coding and technical interviews.

🔹 1. What is an Array?

Answer:

An array is a data structure used to store multiple elements in an ordered sequence.

Each element can generally be accessed using an index.

Example:

arr = [10, 20, 30, 40]

print(arr[2])

Output:

30

The index of "30" is "2".

The main advantage of an array is efficient index-based access.

🔹 2. What is the time complexity of accessing an array element?

Answer:

Accessing an element by its index is typically:

O(1)

Example:

arr = [10, 20, 30, 40, 50]

print(arr[3])

The system can directly access the element at index "3" rather than searching through all previous elements.

This is one of the biggest advantages of arrays.

🔹 3. What is the difference between an Array and a Linked List?

Answer:

An array stores elements in a contiguous structure in traditional array implementations, while a linked list stores elements as separate nodes connected using references/pointers.

Arrays provide fast index-based access:

arr[i] → O(1)

Linked lists generally require traversal to reach a particular position:

Access → O(n)

However, linked lists can be advantageous when inserting or deleting nodes at a known position because elements do not need to be shifted like they may in an array.

The choice depends on the problem.

🔹 4. How do you find the largest element in an array?

Answer:

Traverse the array while maintaining the largest value found so far.

Example:

arr = [10, 45, 23, 67, 12]

largest = arr[0]

for num in arr:
if num > largest:
largest = num

print(largest)

Output:

67

Time complexity:

O(n)

Space complexity:

O(1)

🔹 5. How do you find the second-largest element?

Answer:

We can maintain two variables:

largest
second_largest

Example:

arr = [10, 45, 23, 67, 12]

largest = float('-inf')
second_largest = float('-inf')

for num in arr:
if num > largest:
second_largest = largest
largest = num

elif num > second_largest and num != largest:
second_largest = num

print(second_largest)

Output:

45

This can be solved in:

Time: O(n)
Space: O(1)

An important interview follow-up is:

"What if all elements are equal?"

A good solution should explicitly handle the case where a distinct second-largest element does not exist.

🔹 6. How do you reverse an array?

Answer:

One approach is to use two pointers.

Example:

arr = [1, 2, 3, 4, 5]

left = 0
right = len(arr) - 1

while left < right:
arr[left], arr[right] = arr[right], arr[left]

left += 1
right -= 1

print(arr)

Output:

[5, 4, 3, 2, 1]

Time complexity:

O(n)

Space complexity:

O(1)

This is an example of an in-place algorithm because we modify the original array instead of creating another array.

🔹 7. How do you find duplicate elements in an array?

Answer:

A HashSet can be used to keep track of elements already encountered.

Example:

arr = [1, 2, 3, 2, 4, 1]

seen = set()
duplicates = set()

for num in arr:
if num in seen:
duplicates.add(num)
else:
seen.add(num)

print(duplicates)

Output:

{1, 2}

Average time complexity:

O(n)

Additional space:

O(n)

This is usually faster than comparing every pair, which can take O(n²).

🔹 8. What is the Two Sum problem?

Answer:

You are given an array and a target value. Find two elements whose sum equals the target.

Example:

Array: [2, 7, 11, 15]
Target: 9

The answer is:

2 + 7 = 9

A HashMap can solve this efficiently.

arr = [2, 7, 11, 15]
target = 9

seen = {}

for i, num in enumerate(arr):
complement = target - num

if complement in seen:
print(seen[complement], i)
break

seen[num] = i

Output:

0 1

Average time complexity:

O(n)

Space complexity:

O(n)

This is one of the most important patterns to recognize in array interviews.

🔹 9. How do you move all zeroes to the end?

Example:

Input:
[0, 1, 0, 3, 12]

Output:
[1, 3, 12, 0, 0]

A Two Pointer approach can solve this in-place.

arr = [0, 1, 0, 3, 12]

position = 0

for i in range(len(arr)):
if arr[i] != 0:
arr[position], arr[i] = arr[i], arr[position]
position += 1

print(arr)

Output:

[1, 3, 12, 0, 0]

Time complexity:

O(n)

Space complexity:

O(1)

🔹 10. How do you find the missing number?

Suppose the array contains numbers from "0" to "n", but one number is missing.

Example:

[3, 0, 1]

The missing number is:

2

One efficient approach uses the expected sum:

arr = [3, 0, 1]

n = len(arr)

expected_sum = n * (n + 1) // 2
actual_sum = sum(arr)

missing = expected_sum - actual_sum

print(missing)

Output:

2

Time complexity:

O(n)

Space complexity:

O(1)

🔹 11. What is the difference between Linear Search and Binary Search?

Answer:

Linear Search checks elements one by one.

Time: O(n)

It can work on unsorted data.

Binary Search repeatedly divides the search space approximately in half.

Time: O(log n)

It requires suitable sorted data.

For example:

Linear Search:
10 → 20 → 30 → 40 → 50

Binary Search:
30
/
10 40...

The key interview point is not simply memorizing the complexities. You should understand when Binary Search can actually be applied.

🔹 12. What is an in-place algorithm?

Answer:

An in-place algorithm modifies the input data structure while using only a small amount of additional memory.

For example, reversing an array using two pointers:

arr = [1, 2, 3, 4]

left = 0
right = len(arr) - 1

while left < right:
arr[left], arr[right] = arr[right], arr[left]
left += 1
right -= 1

No second array is created.

Therefore, the extra space used is:

O(1)

🔹 13. What is the Maximum Subarray problem?

Answer:

You are given an array of integers and need to find the contiguous subarray with the maximum sum.

Example:

[-2, 1, -3, 4, -1, 2, 1, -5, 4]

The maximum-sum contiguous subarray is:

[4, -1, 2, 1]

Its sum is:

6

A famous solution uses Kadane's Algorithm.

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]

current = arr[0]
maximum = arr[0]

for i in range(1, len(arr)):
current = max(arr[i], current + arr[i])
maximum = max(maximum, current)

print(maximum)

Output:

6

Time complexity:

O(n)

This is a very important array interview problem because it tests whether you can optimize a seemingly expensive problem.

🔹 14. What is the difference between a subarray and a subsequence?

Answer:

A subarray must contain contiguous elements.

Example:

[2, 3, 4]

is a subarray of:

[1, 2, 3, 4, 5]

A subsequence does not need to be contiguous, but the original order must be maintained.

Example:

[1, 3, 5]

is a subsequence of:

[1, 2, 3, 4, 5]

but it is not a contiguous subarray.

This distinction becomes extremely important in Dynamic Programming problems such as Longest Common Subsequence.

🔹 15. How do you rotate an array?

Example:

Input:
[1, 2, 3, 4, 5]

Rotate right by 2:

[4, 5, 1, 2, 3]

One efficient approach uses the reversal technique.

Conceptually:

Reverse entire array
Reverse first k elements
Reverse remaining elements

For:

[1, 2, 3, 4, 5]

rotate right by "2":

Reverse all:
[5, 4, 3, 2, 1]

Reverse first 2:
[4, 5, 3, 2, 1]

Reverse remaining:
[4, 5, 1, 2, 3]

This technique can achieve:

Time: O(n)
Space: O(1)


Learn to recognize patterns:

✔ Two Pointers

✔ Sliding Window

✔ Prefix Sum

✔ HashMap / HashSet

✔ Binary Search

✔ Sorting

✔ Kadane's Algorithm

✔ In-place modification

Once you recognize the pattern, many seemingly different array problems become much easier to solve.