

1. implement curry()JavaScripteasy
 2. implement curry() with placeholder supportJavaScriptmedium
 3. implement [Link]()JavaScriptmedium
 4. implement basic throttle()JavaScriptLodashmedium
 5. implement throttle() with leading & trailing optionJavaScriptLodashmedium
 6. implement basic debounce()JavaScriptLodasheasy
 7. implement debounce() with leading & trailing optionJavaScriptLodashmedium
 8. can you shuffle() an array?JavaScriptmedium
 9. decode messageJavaScriptmedium
 10. first bad versionJavaScriptAlgorithmmedium
 11. what is Composition? create a pipe()JavaScripteasy
 12. implement Immutability helperJavaScriptmedium
 13. Implement a Queue by using StackJavaScriptAlgorithmmedium
 14. Implement a general memoization function - `memo()`JavaScriptmedium
 15. implement a simple DOM wrapper to support method chaining like jQueryJavaScripteasy
 16. create an Event EmitterJavaScriptmedium
 17. Create a simple store for DOM elementJavaScripteasy
 18. Improve a functionJavaScripteasy
 19. find corresponding node in two identical DOM treeJavaScripteasy
 20. Detect data type in JavaScriptJavaScriptmedium
 21. implement [Link]()JavaScripthard?
 22. implement [Link]()JavaScriptmedium
 23. create a sum()JavaScriptmedium
 24. create a Priority Queue in JavaScriptJavaScriptAlgorithmmedium
 25. Reorder array with new indexesJavaScriptAlgorithmeasy
 26. implement [Link]()JavaScriptmedium
 27. implement completeAssign()JavaScriptmedium
 28. implement clearAllTimeout()JavaScripteasy
 29. implement async helper - `sequence()`JavaScriptmedium
 30. implement async helper - `parallel()`JavaScriptmedium
 31. implement async helper - `race()`JavaScripteasy
 32. implement `[Link]()`JavaScriptmedium
 33. implement `[Link]()`JavaScriptmedium
 34. implement `[Link]()`JavaScriptmedium
 35. implement `[Link]()`JavaScripteasy
 36. create a fake timer(setTimeout)JavaScriptmedium
 37. implement Binary Search (unique)JavaScripteasy
 38. implement `[Link]()`JavaScripteasy
 39. implement range()JavaScripteasy
 40. implement Bubble SortJavaScriptAlgorithmeasy
 41. implement Merge SortJavaScriptAlgorithmmedium
 42. implement Insertion SortJavaScriptAlgorithmeasy
 43. implement Quick SortJavaScriptAlgorithmmedium
 44. implement Selection SortJavaScriptAlgorithmeasy
 45. find the K-th largest element in an unsorted arrayJavaScriptAlgorithmmedium
 46. implement `_.once()`JavaScriptLodashmedium
 47. reverse a linked listJavaScriptAlgorithmeasy
 48. search first index with Binary Search(possible duplicate array)JavaScriptAlgorithmeasy
 49. search last index with Binary Search(possible duplicate array)JavaScriptAlgorithmeasy
 50. search element right before target with Binary Search(possible duplicate array)JavaScriptAlgorithmeasy
 51. search element right after target with Binary Search(possible duplicate array)JavaScriptAlgorithmeasy
 52. create a middleware systemJavaScriptmedium
 53. write your own `extends` in es5JavaScriptmedium
 54. flatten ThunkJavaScripteasy
 55. highlight keywords in HTML stringJavaScriptAlgorithmmedium
 56. call APIs with paginationJavaScriptmedium
 57. create an ObservableJavaScriptmedium
 58. get DOM tree heightJavaScriptAlgorithmDOMmedium
 59. create a browser historyJavaScriptmedium
 60. create your own `new` operatorJavaScripteasy
 61. create your own `[Link]`JavaScriptmedium
 62. implement BigInt additionJavaScriptAlgorithmeasy
 63. create `_.cloneDeep()`JavaScriptAlgorithmLodashmedium
 64. auto-retry Promise on rejectionJavaScriptmedium
 65. add comma to numberJavaScriptmedium
 66. remove duplicates from an arrayJavaScriptAlgorithmmedium
 67. create your own PromiseJavaScriptmedium
 68. get DOM tagsJavaScriptAlgorithmDOMmedium
 69. implement deep equal `_.isEqual()`JavaScriptLodashmedium
 70. implement [Link]()JavaScriptmedium
 71. implement Observable SubjectJavaScriptmedium
 72. implement Observable interval()JavaScripteasy
 73. implement Observable fromEvent()JavaScripteasy
 74. implement Observable Transformation OperatorsJavaScripteasy
 75. implement BigInt subtractionJavaScriptAlgorithmmedium
 76. implement BigInt addition with signJavaScriptmedium
 77. implement BigInt subtraction with signJavaScriptmedium
 78. convert HEX color to RGBAJavaScriptmedium
 79. convert snake_case to camelCaseJavaScriptmedium
 80. implement your own URLSearchParamsJavaScripthard?
 81. merge sorted arraysJavaScriptAlgorithmeasy
 82. find available meeting slotsJavaScriptAlgorithmmedium
 83. create an intervalJavaScriptmedium
 84. create a fake timer (setInterval)JavaScriptmedium
 85. implement `_.get()`JavaScriptLodashmedium
 86. Generate Fibonacci NumberJavaScriptAlgorithmmedium
 87. longest substring with unique charactersJavaScriptAlgorithmeasy
 88. support negative Array index in JavaScriptJavaScriptmedium
 89. Next Right SiblingJavaScriptDOMeasy
 90. write your own `instanceof`JavaScriptmedium
 91. invert a binary treeJavaScriptAlgorithmeasy
 92. throttle PromisesJavaScriptmedium
 93. Generate Fibonacci Number with recursionJavaScripteasy
 94. implement your own `[Link]`JavaScripteasy
 95. implement [Link]()JavaScriptmedium
 96. count "1" in binary formJavaScripteasy
 97. compress a stringJavaScriptstringeasy
 98. validate an IP addressJavaScriptmedium
 99. extract all anchor element from HTML stringJavaScriptmedium
 100. detect circle in linked listJavaScriptAlgorithmeasy
 101. merge identical API callsJavaScriptmedium
 102. validate string of parenthesesJavaScriptAlgorithmstringeasy
 103. implement [Link]()JavaScriptAlgorithmmedium
 104. Traverse DOM level by levelJavaScriptAlgorithmDOMmedium
 105. find the first duplicate character in a stringJavaScriptstringeasy
 106. Find two numbers that sum up to 0JavaScriptAlgorithmeasy
 107. Find the largest differenceJavaScriptAlgorithmeasy
 108. Implement a Stack by using QueueJavaScriptAlgorithmmedium
 109. implement `[Link]()`JavaScriptAlgorithmeasy
 110. serialize and deserialize binary treeJavaScriptAlgorithmmedium
 111. Count palindromic substringsJavaScriptAlgorithmstringmedium
 112. remove duplicate characters in a stringJavaScriptAlgorithmstringmedium
 113. Virtual DOM IJavaScriptAlgorithmDOMmedium
 114. implement BigInt multiplicationJavaScriptmedium
 115. implement BigInt divisionJavaScriptmedium
 116. implement [Link]()JavaScripteasy
 117. event delegationJavaScriptmedium
 118. Virtual DOM II - createElementJavaScripteasy
 119. create a tokenizerJavaScriptmedium
 120. create `isPrime()`JavaScriptAlgorithmeasy
 121. A number sequenceJavaScripteasy
 122. implement memoizeOne()JavaScriptmedium
 123. implement [Link]()JavaScriptmedium
 124. calculate arithmetic expressionJavaScriptAlgorithmmedium
 125. implement classNames()JavaScriptmedium
 126. BigDecimal additionJavaScriptAlgorithmmedium
 127. BigDecimal subtractionJavaScriptAlgorithmmedium
 128. BigDecimal multiplicationJavaScriptAlgorithmmedium
 129. BigDecimal DivisionJavaScriptAlgorithmmedium
 130. create LazyMan()JavaScriptmedium
  131. implement _.chunk()JavaScriptLodashmedium
 132. the angle between hour hand and minute hand of a clockJavaScriptmedium
 133. roman numerals to integerJavaScripteasy
 134. create your own CookieJavaScriptmedium
 135. localStorage with expirationJavaScriptmedium
 136. find median of two sorted arrayJavaScriptAlgorithmmedium
 137. binary tree vertical traversalJavaScriptAlgorithmhard?
 138. Intersection of two sorted arraysJavaScriptAlgorithmeasy
 139. implement _.partial()JavaScriptLodashmedium
 140. Virtual DOM III - Functional ComponentJavaScripteasy
 141. implement btoa()JavaScripteasy
 142. lit-html 1 - tagged templatesJavaScriptlit-htmleasy
 143. Virtual DOM IV - JSX 1JavaScriptmedium
 144. serialize and deserialize data types not supported in JSONJavaScriptmedium
 145. most frequently occurring characterJavaScripteasy
 146. implement [Link]()JavaScriptmedium
 147. Pick up stonesJavaScripteasy
 148. create a counter objectJavaScripteasy
 149. interpolationJavaScriptmedium
 150. Virtual DOM V - JSX 2JavaScriptmedium
 151. implement [Link]()JavaScriptmedium
 152. Find Top k ElementsJavaScriptAlgorithmmedium
 153. uglify CSS class namesJavaScriptmedium
 154. Two-way bindingJavaScriptDOMeasy
 155. create a count functionJavaScripteasy
 156. implement `_.set()`JavaScriptLodashmedium
 157. semver compareJavaScripteasy
 158. Previous Left SiblingJavaScriptDOMmedium
 159. implement promisify()JavaScripteasy
 160. implement atob()JavaScriptmedium
 161. toBe() or [Link]()JavaScriptmedium
 162. find the single integerJavaScriptAlgorithmeasy
 163. integer to roman numeralsJavaScriptAlgorithmeasy
 164. implement Immer produce()JavaScriptmedium
 165. remove charactersAlgorithmmedium
 166. validate number stringJavaScriptAlgorithmstringmedium
 167. Intersection of unsorted arraysJavaScriptAlgorithmeasy
 168. move zerosJavaScriptAlgorithmmedium
 169. LRU - Chrome storage automatic evictionJavaScriptAlgorithmmedium
 170. Generate CSS Selector for target elementJavaScriptmedium
 171. create callback on message channelJavaScriptmedium
 172. implement `Math.clz32()`JavaScriptmedium
 173. uncompress stringJavaScriptstringalgorithmmedium
 174. CSS Grid Layout auto-placement algorithm - sparseJavaScriptCSShard?
 175. CSS Grid Layout auto-placement algorithm - denseJavaScriptCSSmedium
 176. undefined to nullJavaScriptmedium
 177. Implement [Link]()JavaScriptmedium

[Link]
function objectAssign(target, ...sources) {
if (target == null) {
throw new TypeError('Target cannot be null or undefined');
}

// Make sure that the target is treated as an object

target = Object(target);

[Link](source => {
if (source == null) return; // Ignore non-objects (null, undefined)

// Treat source as an object

 source = Object(source);

// Copy all enumerable properties (including symbol properties)

[Link](source).forEach(key => {
// Handle special case for "string" as a source object
if (typeof source[key] === 'string' || typeof source[key] === 'number'
|| typeof source[key] === 'boolean') {
// Skip non-enumerable properties for primitive values (string,
number, etc.)
if () return;
}

try {
// Assign the property to target
target[key] = source[key];
} catch (error) {
throw error; // Throw any error that occurs during the assignment
process
}
});
});

return target;
}

// Example usage
const obj1 = {a: 3};
const obj2 = {b: 4};

[Link](objectAssign({}, obj1, obj2)); // Output: { a: 3, b: 4 }

Complete assign:

function completeAssign(target, ...sources) {

if (target == null) {
throw new TypeError('Target cannot be null or undefined');
}

target = Object(target);

[Link](source => {
if (source == null) return; // Skip null or undefined sources

source = Object(source);
 // Get all own property keys (including symbol keys)
[Link](source).forEach(key => {
// Get the property descriptor of each key in the source object
const descriptor = [Link](source, key);

// Define the property on the target object using the same descriptor
[Link](target, key, descriptor);
});
});

return target;
}

Clear all timeout:

// Create an array to store timeout IDs
let timeoutIds = [];

// Override the setTimeout function to store the timeout IDs

const originalSetTimeout = [Link];
[Link] = function(callback, delay) {
const timeoutId = originalSetTimeout(callback, delay);
[Link](timeoutId); // Store the timeout ID
return timeoutId;
};

// Implement clearAllTimeout to clear all timeouts

function clearAllTimeout() {
[Link](timeoutId => {
clearTimeout(timeoutId); // Clear each timeout
});
timeoutIds = []; // Reset the array of timeout IDs
}

Async sequence:
function sequence(funcs: AsyncFunc[]): AsyncFunc {
return function(callback: Callback, initialData: any) {
let currentData = initialData;

// Chain the async functions

const runNext = (index: number) => {
if (index >= [Link]) {
// All functions have been executed, call the callback
callback(null, currentData);
return;
}

// Execute the current async function

 funcs[index]((error, data) => {
if (error) {
// If any function returns an error, pass it to the callback
callback(error, null);
return;
}

// Update current data and call the next function

currentData = data;
runNext(index + 1);
}, currentData);
};

// Start the chain

runNext(0);
};
}

Parallel:
// Type definition for AsyncFunc and Callback
type Callback = (error: Error, data: any) => void;
type AsyncFunc = (callback: Callback, data: any) => void;

// The parallel function that triggers async functions concurrently

function parallel(funcs: AsyncFunc[]): AsyncFunc {
return function(callback: Callback, initialData: any) {
let remaining = [Link];
let results: any[] = [];
let errorOccurred = false;

// Function to be called after each async function finishes

const handleCompletion = (index: number) => (error: Error, data: any)
=> {
if (errorOccurred) return; // If an error already occurred, don't process
further

if (error) {
errorOccurred = true;
callback(error, null); // If an error occurs, stop and return the error
return;
}

results[index] = data; // Store the result of the async function

remaining--; // Decrease the count of remaining async functions

if (remaining === 0) {
 callback(null, results); // Once all async functions are completed, call
the callback with the results
}
};

// Trigger all async functions concurrently

[Link]((func, index) => {
func(handleCompletion(index), initialData);
});
};
}

// Example async functions

const async1 = (callback: Callback) => {
setTimeout(() => callback(undefined, 1), 100);
};
const async2 = (callback: Callback) => {
setTimeout(() => callback(undefined, 2), 200);
};
const async3 = (callback: Callback) => {
setTimeout(() => callback(undefined, 3), 150);
};

// Using parallel to execute all async functions concurrently

const all = parallel([async1, async2, async3]);

all((error, data) => {

if (error) {
[Link]('Error:', error);
} else {
[Link](data); // Should log [1, 2, 3] in any order depending on the
async completion
}
}, null);

Race:
// Type definition for AsyncFunc and Callback
type Callback = (error: Error, data: any) => void;
type AsyncFunc = (callback: Callback, data: any) => void;

// The race function that triggers async functions concurrently and returns
the first result
function race(funcs: AsyncFunc[]): AsyncFunc {
return function(callback: Callback, initialData: any) {
let errorOccurred = false; // Flag to check if any error has occurred

// Function to handle the first completion (either success or error)

const handleCompletion = (error: Error, data: any) => {
 if (errorOccurred) return; // If an error has already occurred, stop
further handling

if (error) {
errorOccurred = true;
callback(error, null); // If any function returns an error, stop and
return the error
return;
}

callback(null, data); // If any function succeeds, call the callback with

its data
};

// Trigger all async functions concurrently

[Link]((func) => {
func(handleCompletion, initialData);
});
};
}

PROMISE ALL
function myPromiseAll(promises) {
return new Promise((resolve, reject) => {
// Check if the input is an array
if () {
return reject(new TypeError('The input must be an array.'));
}

// Array to store the resolved values

const results = [];
let resolvedCount = 0;

// Edge case: If no promises are provided, resolve immediately with

an empty array
if ([Link] === 0) {
return resolve(results);
}

// Loop through all the promises

[Link]((promise, index) => {
// Handle each promise, whether it's already resolved or still
pending
[Link](promise)
.then((value) => {
results[index] = value; // Store the resolved value at the
correct index
resolvedCount++;
 // If all promises are resolved, resolve the main promise
if (resolvedCount === [Link]) {
resolve(results);
}
})
.catch((error) => {
// If any promise is rejected, reject the main promise with the
error
reject(error);
});
});
});
}

// Usage example
const promise1 = [Link](1);
const promise2 = [Link](2);
const promise3 = [Link](3);

myPromiseAll([promise1, promise2, promise3])

.then((results) => [Link](results)) // Output: [1, 2, 3]
.catch((error) => [Link](error));

Faketimers:
class FakeTimers {
constructor() {
[Link] = 0;
[Link] = [];
[Link] = 0;
}

// Replaces setTimeout
setTimeout(callback, delay) {
const timerId = [Link]++;
const timer = { callback, delay, timerId, startTime: [Link] };
[Link](timer);
return timerId;
}

// Replaces clearTimeout
clearTimeout(timerId) {
[Link] = [Link](timer => [Link] !== timerId);
}

// Advances the time and executes due callbacks

tick(ms) {
[Link] += ms;
 const dueTimers = [Link](timer => [Link] >=
[Link] + [Link]);

// Execute the due timers synchronously

[Link](timer => {
[Link](); // Execute the callback
});

// Remove the timers that have executed

[Link] = [Link](timer => [Link] <
[Link] + [Link]);
}

// Replaces [Link]() with a custom clock

now() {
return [Link];
}

// Reset all timers and clock

reset() {
[Link] = 0;
[Link] = [];
}
}

// Usage Example:
const fakeTimers = new FakeTimers();

// Replace setTimeout and clearTimeout with fake timers

[Link] = [Link](fakeTimers);
[Link] = [Link](fakeTimers);
[Link] = [Link](fakeTimers);

// Testing code with fake timers

const timeoutId = setTimeout(() => {
[Link]('Timeout triggered at', [Link]()); // Should log 100
}, 100);

[Link](100); // Move time forward by 100ms

// Output: 'Timeout triggered at 100'

[Link](); // Reset the fake timers for next test

[Link] custom

function spyOn(object, methodName) {

// Store the original method
 const originalMethod = object[methodName];

// Create the spy function that wraps the original method

const spy = function(...args) {
// Push the arguments to the calls array
[Link](args);

// Call the original method

return [Link](object, args);
};

// Add a 'calls' property to the spy to store the arguments

[Link] = [];

// Replace the original method with the spy function

object[methodName] = spy;

// Restore method function

[Link] = function() {
object[methodName] = originalMethod;
};

return spy;
}

// Example usage:

const myObject = {
greet(name) {
return `Hello, ${name}!`;
}
};

// Spy on the 'greet' method

const greetSpy = spyOn(myObject, 'greet');

// Call the method multiple times

[Link]('Alice');
[Link]('Bob');

// Check if the spy has captured the calls

[Link]([Link]); // Output: [ ['Alice'], ['Bob'] ]

// Call the method after spying, it should still call the original function
[Link]([Link]('Charlie')); // Output: "Hello, Charlie!"

// Restore the original method

[Link]();
// Call the method after restore, it will no longer be spied
[Link]([Link]('David')); // Output: "Hello, David!"

range()

function range(from, to) {

return {
[[Link]]() {
let current = from;
return {
next() {
if (current <= to) {
return { value: current++, done: false };
} else {
return { done: true };
}
}
};
}
};
}

Reverse linked list

To reverse a linked list, you can approach the problem both with and without recursion. Let's
walk through both solutions.

Without Recursion (Iterative Solution)

This approach involves traversing the linked list and changing the next pointers so that each
node points to its previous node.

Here's how you can do it:

class Node {
val: number;
next: Node;

constructor(val: number, next: Node = null) {

[Link] = val;
[Link] = next;
}
}

function reverseLinkedList(head: Node): Node {

let prev: Node = null;
let current: Node = head;

while (current !== null) {

let nextNode: Node = [Link]; // Store the next node
 [Link] = prev; // Reverse the current node's
pointer
prev = current; // Move prev to current node
current = nextNode; // Move to the next node in the
list
}

return prev; // New head of the reversed linked list

}

// Example usage:
const Three = new Node(3, null);
const Two = new Node(2, Three);
const One = new Node(1, Two);

// Now reverse the linked list

let reversedHead = reverseLinkedList(One);
// The reversed list will be 3 → 2 → 1

With Recursion

In this approach, you recursively reverse the rest of the list and then reverse the pointers
when unwinding the recursion.

Here's the recursive solution:

function reverseLinkedListRecursive(head: Node): Node {

if (head === null || [Link] === null) {
return head; // Base case: If the list is empty or only one node,
return the head
}

let restReversed: Node = reverseLinkedListRecursive([Link]); //

Recursively reverse the rest of the list
[Link] = head; // Reverse the current node's pointer
[Link] = null; // Set the current node's next to null

return restReversed; // Return the new head of the reversed list

}

// Example usage:
reversedHead = reverseLinkedListRecursive(One);
// The reversed list will be 3 → 2 → 1

Key Points:

 Iterative Solution: You keep track of three pointers: prev, current, and nextNode.
This approach is generally more space-efficient, as it only uses a constant amount of
extra space.
 Recursive Solution: Recursion simplifies the logic and requires fewer lines of code,
but it uses extra stack space for each recursive call, which could lead to a stack
overflow for very large lists.

Both solutions work well, but the iterative approach is preferred for large lists due to its
constant space complexity.
Middleware:

const middlewareWithError = new Middleware();

// Throw an error at the first middleware

[Link]((req, next) => {
req.a = 1;
throw new Error('sth wrong');
// Or use next(new Error('sth wrong'))
});

[Link]((req, next) => {

req.b = 2; // This middleware will be skipped due to the error
next();
});

[Link]((req, next) => {

[Link](req); // This will also be skipped due to the error
});

[Link]((error, req, next) => {

[Link](error); // Logs the error
[Link](req); // Logs {a: 1}
});

[Link]({});
// Output:
// Error: sth wrong
// { a: 1 }