Top 8 Coding Interview Questions Every Hiring Manager Should Ask

• Ensure the class is thread-safe.
• Avoid using the synchronized keyword on the getInstance() method to improve performance.
• Use lazy initialization for the singleton instance.

    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {

        if (instance == null) {

            synchronized (Singleton.class) {

                if (instance == null) {

                    instance = new Singleton();

                }

            }

        }

        return instance;

    }

}

• Forgetting to declare the instance variable as volatile, which is crucial for thread safety in this context.
• Implementing the Singleton without considering thread safety, leading to potential issues in a multi-threaded environment.
• Using eager initialization unnecessarily can lead to resource wastage if the instance is never used.

• Discuss how different initialization techniques (lazy vs. eager) affect the performance and resource utilization of your application.
• How would you implement the Singleton pattern using an enum type in Java?

• The decorator should be flexible enough to be applied to any function.
• Ensure the timing is accurate to the nearest millisecond.

from functools import wraps

def execution_time_logger(func):

    @wraps(func)

    def wrapper(*args, **kwargs):

        start_time = time.time()

        result = func(*args, **kwargs)

        end_time = time.time()

        print(f”{func.__name__} executed in {end_time – start_time:.4f} seconds.”)

        return result

    return wrapper

@execution_time_logger

def sample_function():

    time.sleep(2)

sample_function()

• Not using @wraps(func) from the functools module, which can lead to lost metadata about the original function.
• Forgetting to return the result of the decorated function, altering the function’s expected behavior.
• Incorrectly calculating the time, leading to inaccurate logging of the execution time.

• How would you modify the decorator to log the execution time to a file instead of printing it?
• Discuss how decorators in Python can be used to add other types of logging (e.g., arguments passed, return values).

• Ensure the throttling function is generic and can be applied to any function.
• The limit should accurately represent the minimum time interval between two successive calls of the throttled function.

    let lastFunc;

    let lastRan;

    return function() {

        const context = this;

        const args = arguments;

        if (!lastRan) {

            func.apply(context, args);

            lastRan = Date.now();

        } else {

            clearTimeout(lastFunc);

            lastFunc = setTimeout(function() {

                if ((Date.now() – lastRan) >= limit) {

                    func.apply(context, args);

                    lastRan = Date.now();

                }

            }, limit – (Date.now() – lastRan));

        }

    }

}

// Example usage

const throttledLog = throttle(() => console.log(new Date()), 1000);

setInterval(throttledLog, 100); // Attempts to log the time every 100ms but is throttled to once per 1000ms

• Not clearing the previous timeout, which can lead to unexpected behavior or multiple executions in quick succession.
• Incorrectly handling the timing, leading to more frequent execution than specified by the limit.
• Losing the context of this or arguments passed to the function when it is called.

• How could you modify the throttling function to ensure the first call is executed immediately and subsequent calls are throttled?
• Discuss the differences between throttling and debouncing, and when you might use one technique over the other.

• An array of integers, arr.
• An integer k, where k is less than or equal to the size of the array.

k = 2

def findKthLargest(nums, k):

    minHeap = []

    for num in nums:

        heapq.heappush(minHeap, num)

        if len(minHeap) > k:

            heapq.heappop(minHeap)

    return minHeap[0]

• Attempting to sort the array first, which leads to a less efficient solution.
• Misunderstanding the definition of “kth largest” (e.g., confusing it with kth smallest).
• Incorrectly managing the heap size or not properly initializing the heap.

• How would your approach change if you needed to find the kth smallest element?
• Can you improve the algorithm to achieve better than O(nlogk) complexity in some cases?

• An array of integers, arr, representing the rotated sorted array.
• An integer target, the value to search for.

target = 0

    left, right = 0, len(nums) – 1

    while left <= right:

        mid = (left + right) // 2

        if nums[mid] == target:

            return mid

        # The left half is sorted

        if nums[left] <= nums[mid]:

            if nums[left] <= target < nums[mid]:

                right = mid – 1

            else:

                left = mid + 1

        # The right half is sorted

        else:

            if nums[mid] < target <= nums[right]:

                left = mid + 1

            else:

                right = mid – 1

    return -1

• Failing to correctly identify the sorted portion of the array, leading to incorrect range adjustments.
• Incorrectly handling edge cases, such as when the target is at the midpoint or when the array is not rotated.
• Overlooking the condition where the array might not have been rotated at all.

• How would you modify your solution if the array contained duplicates?
• Discuss the time complexity of your solution and whether there’s any scenario where the algorithm might degrade to linear search.

• A series of integers for insertion into the heap.
• Operations indicating insertion, deletion, and fetch maximum.

Operations: Insert 3, Insert 10, Fetch Maximum, Delete Maximum, Fetch Maximum

Fetch Maximum after Deletion: 5

    def __init__(self):

        self.heap = []

    def insert(self, val):

        self.heap.append(val)

        self._bubble_up(len(self.heap) – 1)

    def getMax(self):

        return self.heap[0] if self.heap else ‘Heap is empty’

    def deleteMax(self):

        if len(self.heap) > 1:

            self._swap(0, len(self.heap) – 1)

            maxVal = self.heap.pop()

            self._bubble_down(0)

        elif self.heap:

            maxVal = self.heap.pop()

        else:

            return ‘Heap is empty’

        return maxVal

    def _bubble_up(self, index):

        parent = (index – 1) // 2

        while index > 0 and self.heap[parent] < self.heap[index]:

            self._swap(index, parent)

            index = parent

            parent = (index – 1) // 2

    def _bubble_down(self, index):

        largest = index

        left = 2 * index + 1

        right = 2 * index + 2

        if left < len(self.heap) and self.heap[left] > self.heap[largest]:

            largest = left

        if right < len(self.heap) and self.heap[right] > self.heap[largest]:

            largest = right

        if largest != index:

            self._swap(index, largest)

            self._bubble_down(largest)

    def _swap(self, i, j):

        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]

# Example usage

heap = MaxHeap()

heap.insert(3)

heap.insert(10)

heap.insert(5)

heap.insert(1)

heap.insert(2)

print(heap.getMax())  # 10

heap.deleteMax()

print(heap.getMax())  # 5

• Not correctly maintaining the heap property after insertions or deletions, leading to incorrect getMax results.
• Failing to handle edge cases, such as deleting from an empty heap or inserting values outside the allowed range.

• How would you implement a min heap based on this structure?
• Discuss how heap data structures can be used in sorting algorithms and their efficiency compared to other sorting methods.

• The head of a singly linked list.

• The number of nodes in the list is in the range [1,5000][1,5000].
• Node values are within the range [−5000,5000][−5000,5000].

class ListNode:

    def __init__(self, val=0, next=None):

        self.val = val

        self.next = next

def reverseLinkedList(head):

    prev, curr = None, head

    while curr:

        nextTemp = curr.next

        curr.next = prev

        prev = curr

        curr = nextTemp

    return prev

# Example usage

# Assuming the linked list is already created and head points to the first node

# newHead = reverseLinkedList(head)

• Losing the reference to the rest of the list while reversing the links, which can result in a memory leak in languages with manual memory management.
• Incorrectly handling the head and tail of the list, especially updating the new head’s next to None.
• Forgetting to return the new head of the list after reversal.

• How would your approach change if this were a doubly linked list?
• Discuss how to reverse the list recursively and compare the space complexity of both approaches.

• An array nums with n integers.

• An array of integers that are missing from the array.

    for i in range(len(nums)):

        new_index = abs(nums[i]) – 1

        if nums[new_index] > 0:

            nums[new_index] *= -1

    result = []

    for i in range(1, len(nums) + 1):

        if nums[i – 1] > 0:

            result.append(i)

    return result

• Forgetting to account for the array’s 0-based indexing when marking numbers as seen.
• Missing to convert the numbers back to positive when checking which ones did not appear.
• Attempting to use extra space, which violates the problem’s constraints for an in-place solution.

• Can you think of a way to solve this problem if the numbers in nums were not guaranteed to be in the range [1, n]?