Coding Tasks

Declare a local let count = 0 inside createCounter, then return an object whose inc and get methods close over that variable. The returned methods keep a live reference to count after the factory returns, so it stays private. Each call to the factory creates a fresh count, giving independent counters.

It prints A, D, C, B. The two synchronous console.log calls run first, so A then D. The Promise.then callback is a microtask and the setTimeout callback is a macrotask; after the synchronous code finishes, all microtasks drain before any macrotask, so C prints before B even though the timeout delay is 0.

Keep a timeoutId in the closure. The returned function calls clearTimeout(timeoutId) to cancel any pending run, then timeoutId = setTimeout(...) to schedule fn after delay. Inside the timer call fn.apply(this, args) to preserve this and forward arguments. Only the last call's timer survives, so fn runs once after activity stops.

Iterate the array with reduce; for each element, if Array.isArray is true, recurse into it and concat the flattened result, otherwise push the value. The recursion is what reaches every depth. An empty array reduces to [], and the order of elements is preserved across all levels.

Lines print '33', 6, 4, and '[object Object]'. + evaluates left to right: (1 + 2) is 3, then 3 + '3' concatenates to '33' because one operand is a string. * and - force numbers, so '3' * 2 is 6 and '5' - 1 is 4. In [] + {}, [] stringifies to '' and {} to '[object Object]', joining to '[object Object]'.

{ a: 5, b: 2 }, then { a: 5, b: 2 }, then 5. JavaScript passes the object's reference by value: fn1 mutates the shared object through the parameter, so the change is visible outside. fn3 only reassigns its local parameter to 5 — that rebinds the local name, leaving the outer object untouched. fn4 reassigns the outer x itself (no parameter shadows it), so x becomes the primitive 5.

Pass the array into a Set, which drops duplicates while keeping insertion order, then spread it back: [...new Set(arr)]. Set membership uses SameValueZero, so it dedups primitives correctly (and treats NaN as equal to itself). This is O(n) and never mutates the input.

Return a recursive curried(...args): if args.length >= fn.length, call fn(...args); otherwise return a new function that takes more arguments and calls curried(...args, ...next), accumulating them in the closure. fn.length (the declared arity) is the threshold, so all the partial-application forms collect arguments until enough are gathered.

Start with a shallow copy { ...a }. For each key of b, if both a[key] and b[key] are plain objects, set the result key to deepMerge(a[key], b[key]) recursively; otherwise assign b[key]. The recursion merges nested objects, and copying first means neither input is mutated. Non-object values from b overwrite.

It prints obj, then '' three times. this is set by the call site, not where the function is defined. obj.method() binds this to obj. The detached fn() and the setTimeout callback are plain calls, so this is the global object (window.name is ''). The arrow has no own this; it inherits the module's outer this, also giving ''.

Track lastRun (timestamp) in the closure, starting so the first call passes. On each call compute now = Date.now(); if now - lastRun >= limit, set lastRun = now and run fn.apply(this, args), otherwise ignore the call. This caps fn to one run per limit window on the leading edge while preserving this and arguments.

Each mutating method updates the instance state and then return this. Returning the same object lets the next call in the chain operate on it, so append('a').append('b').upper() reads as one fluent sequence. The terminal value getter returns the actual result, since it ends the chain — exactly how jQuery achieves fluent APIs.

Base case: when n is 0 (or 1), return 1. Recursive case: return n * factorial(n - 1). Each call multiplies n by the factorial of n - 1 until the base case stops the recursion. The base case at 0 is what makes factorial(0) correctly yield 1.

Clear the container (replaceChildren()), create an img, set its placeholder background grey, and attach handlers BEFORE setting src: img.onload reveals the image, img.onerror sets a red background. Setting src last kicks off the load, firing exactly one of the two events. Clearing first means a second click replaces the previous result.

Split into characters, reverse, and join: s.split('').join after .reverse(), or [...s].reverse().join(''). The spread form handles multi-byte code points better than split(''). A manual loop building the result from the last index down also works in O(n) time and returns '' for the empty string.

Keep the running total in a closure variable. Return an object whose add/div mutate it and return this for chaining. Expose the total through a get value() accessor only — with no setter, calc.value = 100 is silently ignored, so the state stays private. In div, check the divisor and throw before dividing, so a divide-by-zero leaves the total untouched.

Store the querySelectorAll result on the instance. Each method loops over this.elements applying the change — classList.add/remove, Object.entries(obj) into el.style, el.innerHTML = s — then return this so the wrapper chains. The methods live once on the class prototype rather than being recreated per element, and one call fans the operation across the whole matched set.

XOR every element together — nums.reduce((a, b) => a ^ b, 0). XOR is commutative and associative, x ^ x === 0, and x ^ 0 === x, so each pair cancels to zero and only the lone value survives. This is O(n) time and O(1) space, beating the hash-count baseline that needs O(n) memory.

Two pointers l = 0 and r = s.length - 1 move inward. Skip any side whose character fails a letter test (e.g. a regex like /[a-z]/i), then compare with toLowerCase; a mismatch returns false. Meeting in the middle returns true. This is O(n) time and O(1) extra space — no cleaned copy is built.