SWE Interview

Question 1

What is the difference between var, let, and const in JavaScript?

Answer 1

var is function-scoped and can be redeclared; let is block-scoped and reassignable; const is block-scoped and cannot be reassigned, but objects can be mutated.

Question 2

How does this work in JavaScript?

Answer 2

this refers to the context of a function’s call. In global scope, it’s window (browser). In a method, it’s the object. Arrow functions inherit this lexically.

Question 3

What is a closure in JavaScript?

Answer 3

A closure is a function that retains access to its outer scope’s variables. Example: function outer() { let x = 10; return () => x; } returns a function accessing x.

Question 4

What is event delegation in JavaScript?

Answer 4

Event delegation handles events on a parent element for its children, using event bubbling. Example: Add click listener to a ul to handle li clicks (reduces listeners).

Question 5

Explain the event loop in JavaScript.

Answer 5

The event loop processes the call stack and callback queue, handling asynchronous tasks (e.g., setTimeout, promises) when the stack is empty, enabling non-blocking I/O.

Question 6

What is a Promise in JavaScript?

Answer 6

A Promise represents an asynchronous operation’s outcome (pending, fulfilled, rejected). Example: new Promise((resolve, reject) => resolve('Done')).

Question 7

How do async and await simplify asynchronous code?

Answer 7

async functions return Promises; await pauses execution until a Promise resolves. Example: async function fetchData() { let data = await fetch(url); }.

Question 8

What is a React component?

Answer 8

A React component is a function or class returning UI as JSX. Example: function MyComponent() { return <div>Hello</div>; }.

Question 9

What is the purpose of useState in React?

Answer 9

useState manages state in functional components, returning a state value and updater. Example: const [count, setCount] = useState(0);.

Question 10

Explain the useEffect hook in React.

Answer 10

useEffect runs side effects (e.g., API calls) after render, with a dependency array to control execution. Example: useEffect(() => { fetchData(); }, [id]);.

Question 11

What is a controlled component in React?

Answer 11

A controlled component ties form input values to React state, updated via onChange. Example: <input value={state} onChange={(e) => setState(e.target.value)} />.

Question 12

How does React.memo improve performance?

Answer 12

React.memo memoizes a functional component, preventing re-renders unless props change. Example: const Memoized = React.memo(MyComponent);.

Question 13

What is the virtual DOM in React?

Answer 13

The virtual DOM is an in-memory representation of the real DOM. React diffs it with the previous version to minimize DOM updates.

Question 14

What is a data structure?

Answer 14

A data structure organizes data for efficient access/modification, like arrays (contiguous memory) or linked lists (nodes with pointers).

Question 15

What is an algorithm?

Answer 15

An algorithm is a step-by-step procedure to solve a problem, like sorting an array or searching for an item.

Question 16

What is Big O notation?

Answer 16

Big O describes the worst-case growth rate of an algorithm’s time or space usage as input size increases. Example: O(n) for linear time.

Question 17

What is O(log n) time complexity?

Answer 17

O(log n) is logarithmic time, where runtime grows slowly by halving the problem. Example: Binary search on a sorted array.

Question 18

What is the time complexity of accessing a hash table?

Answer 18

O(1) average case for hash table lookups, assuming minimal collisions and a good hash function.

Question 19

What is the Sliding Window pattern, with an example?

Answer 19

Sliding Window optimizes subarray/substring problems. Example: function maxSum(arr, k) { let sum = 0, max = 0; for (let i = 0; i < k; i++) sum += arr[i]; max = sum; for (let i = k; i < arr.length; i++) { sum += arr[i] - arr[i-k]; max = Math.max(max, sum); } return max; } (O(n)).

Question 20

Implement Two Pointers to reverse an array in place.

Answer 20

```javascript
function reverseArray(arr) {
let left = 0, right = arr.length - 1;
while (left < right) {
[arr[left], arr[right]] = [arr[right], arr[left]];
left++;
right–;
}
return arr;
}
// Example: reverseArray([1, 2, 3]) → [3, 2, 1]
// Explanation: Swaps elements from both ends (O(n)).
~~~

Question 21

Use Binary Search to find the first occurrence of a target.

Answer 21

```javascript
function firstOccurrence(arr, target) {
let left = 0, right = arr.length - 1, result = -1;
while (left <= right) {
let mid = Math.floor((left + right) / 2);
if (arr[mid] === target) {
result = mid;
right = mid - 1;
} else if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return result;
}
// Example: firstOccurrence([1, 2, 2, 2, 3], 2) → 1
// Explanation: Tracks first occurrence while searching (O(log n)).
~~~

Question 22

What is Kadane’s Algorithm for max subarray sum?

Answer 22

```javascript
function maxSubArray(nums) {
let max = nums[0], current = nums[0];
for (let i = 1; i < nums.length; i++) {
current = Math.max(nums[i], current + nums[i]);
max = Math.max(max, current);
}
return max;
}
// Example: maxSubArray([-2, 1, -3, 4, -1, 2]) → 6
// Explanation: Tracks local and global max sum (O(n)).
~~~

Question 23

Explain Depth-First Search (DFS) with a code snippet.

Answer 23

```javascript
function dfs(graph, start, visited = new Set()) {
visited.add(start);
console.log(start);
for (let neighbor of graph[start]) {
if (!visited.has(neighbor)) dfs(graph, neighbor, visited);
}
}
// Example: graph = {0:[1,2], 1:[2], 2:[]} → dfs(graph, 0) prints 0,1,2
// Explanation: Recursively explores each branch (O(V + E)).
~~~

Question 24

What is the Merge Intervals pattern?

Answer 24

```javascript
function mergeIntervals(intervals) {
intervals.sort((a, b) => a[0] - b[0]);
let result = [intervals[0]];
for (let i = 1; i < intervals.length; i++) {
let last = result[result.length - 1];
if (intervals[i][0] <= last[1]) {
last[1] = Math.max(last[1], intervals[i][1]);
} else {
result.push(intervals[i]);
}
}
return result;
}
// Example: mergeIntervals([[1,3], [2,6], [8,10]]) → [[1,6], [8,10]]
// Explanation: Merges overlapping intervals (O(n log n)).
~~~

Question 25

What is a linked list, and how do you reverse it?

Answer 25

```javascript class ListNode { constructor(val) { this.val = val; this.next = null; } } function reverseList(head) { let prev = null, current = head; while (current) { let next = current.next; current.next = prev; prev = current; current = next; } return prev; } // Example: 1->2->3 → 3->2->1 // Explanation: Iteratively reverses pointers (O(n)). ```

Question 26

What is the time complexity of quicksort?

Answer 26

Average case O(n log n), worst case O(n²) when the pivot is poorly chosen (e.g., sorted array). Uses divide-and-conquer.

Question 27

How does currying work in JavaScript?

Answer 27

```javascript function curry(fn) { return function curried(...args) { if (args.length >= fn.length) return fn(...args); return (...nextArgs) => curried(...args, ...nextArgs); }; } // Example: const add = curry((a, b) => a + b); add(2)(3) → 5 // Explanation: Transforms a function to take arguments one at a time. ```

Question 28

What is a hash table, and what’s its average lookup time?

Answer 28

A hash table stores key-value pairs using a hash function for indexing. Average lookup time is O(1), worst case O(n) with collisions.

Question 29

Explain error boundaries in React.

Answer 29

```javascript class ErrorBoundary extends React.Component { state = { hasError: false }; static getDerivedStateFromError() { return { hasError: true }; } render() { if (this.state.hasError) return

Error!

; return this.props.children; } } // Example: Wraps to catch errors in child components // Explanation: Catches JavaScript errors in child tree, renders fallback UI. ```

Question 30

What is the Monotonic Stack pattern?

Answer 30

```javascript function nextGreaterElement(nums) { let stack = [], result = new Array(nums.length).fill(-1); for (let i = 0; i < nums.length; i++) { while (stack.length && nums[stack[stack.length - 1]] < nums[i]) { result[stack.pop()] = nums[i]; } stack.push(i); } return result; } // Example: nextGreaterElement([4, 5, 2, 25]) → [5, 25, 25, -1] // Explanation: Maintains a stack of increasing/decreasing elements (O(n)). ```