Practice Code Examples

function isPrime(n) {
  if (n < 2) return false;
  for (let i = 2; i <= Math.sqrt(n); i++) {
    if (n % i === 0) return false;
  }
  return true;
}
console.log(isPrime(17));  // true
console.log(isPrime(4));   // false

function factorial(n) {
  return n <= 1 ? 1 : n * factorial(n - 1);
}
console.log(factorial(5));   // 120

function fibonacci(count) {
  const seq = [0, 1];
  while (seq.length < count) seq.push(seq[seq.length - 1] + seq[seq.length - 2]);
  return seq.slice(0, count);
}
console.log(fibonacci(8));   // [0,1,1,2,3,5,8,13]

function reverseString(s) {
  return s.split("").reverse().join("");
}
console.log(reverseString("hello"));   // "olleh"

function isPalindrome(s) {
  const clean = s.toLowerCase().replace(/[^a-z0-9]/g, "");
  return clean === clean.split("").reverse().join("");
}
console.log(isPalindrome("Race car"));   // true

let a = 5, b = 10;
[a, b] = [b, a];        // destructuring assignment — no temp variable
console.log(a, b);   // 10 5

const toFahrenheit = c => (c * 9) / 5 + 32;
console.log(toFahrenheit(100));   // 212

function sign(n) {
  return n > 0 ? "positive" : n < 0 ? "negative" : "zero";
}
console.log(sign(-4));   // "negative"

const isEven = n => n % 2 === 0;
console.log(isEven(7));   // false

function isLeapYear(y) {
  return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
}
console.log(isLeapYear(2024));   // true

function primesInRange(start, end) {
  const isPrime = n => {
    if (n < 2) return false;
    for (let i = 2; i <= Math.sqrt(n); i++) if (n % i === 0) return false;
    return true;
  };
  const result = [];
  for (let n = start; n <= end; n++) if (isPrime(n)) result.push(n);
  return result;
}
console.log(primesInRange(10, 30));   // [11,13,17,19,23,29]

function table(n, upTo = 10) {
  return Array.from({ length: upTo }, (_, i) => `${n} x ${i + 1} = ${n * (i + 1)}`);
}
table(5, 3);   // ["5 x 1 = 5", "5 x 2 = 10", "5 x 3 = 15"]

const sumUpTo = n => (n * (n + 1)) / 2;
console.log(sumUpTo(100));   // 5050

function hcf(a, b) { return b === 0 ? a : hcf(b, a % b); }
function lcm(a, b) { return (a * b) / hcf(a, b); }
console.log(hcf(36, 60), lcm(36, 60));   // 12 180

const n = 42;
n.toString(2);    // "101010" — binary
n.toString(8);    // "52"     — octal
n.toString(16);   // "2a"     — hex
parseInt("2a", 16);   // 42 — back to decimal

"A".charCodeAt(0);        // 65
String.fromCharCode(97);   // "a"

function calculate(a, op, b) {
  const ops = { "+": (a,b)=>a+b, "-": (a,b)=>a-b, "*": (a,b)=>a*b, "/": (a,b)=>a/b };
  if (!ops[op]) throw new Error("Unknown operator");
  return ops[op](a, b);
}
console.log(calculate(6, "*", 7));   // 42

for (let i = 1; i <= 15; i++) {
  if (i % 15 === 0) console.log("FizzBuzz");
  else if (i % 3 === 0) console.log("Fizz");
  else if (i % 5 === 0) console.log("Buzz");
  else console.log(i);
}

function countVowels(s) {
  return (s.match(/[aeiou]/gi) || []).length;
}
console.log(countVowels("JavaScript"));   // 3

const largest = Math.max(4, 19, 7);
console.log(largest);   // 19

function binarySearch(arr, target) {
  let lo = 0, hi = arr.length - 1;
  while (lo <= hi) {
    const mid = Math.floor((lo + hi) / 2);
    if (arr[mid] === target) return mid;
    if (arr[mid] < target) lo = mid + 1;
    else hi = mid - 1;
  }
  return -1;
}
console.log(binarySearch([1,3,5,7,9], 7));   // 3

function bubbleSort(arr) {
  const a = [...arr];
  for (let i = 0; i < a.length; i++) {
    for (let j = 0; j < a.length - i - 1; j++) {
      if (a[j] > a[j + 1]) [a[j], a[j+1]] = [a[j+1], a[j]];
    }
  }
  return a;
}
bubbleSort([5,2,8,1]);   // [1,2,5,8]

function wordFrequency(text) {
  const counts = {};
  for (const w of text.toLowerCase().split(/\s+/)) counts[w] = (counts[w] || 0) + 1;
  return counts;
}
wordFrequency("the cat and the dog");   // { the:2, cat:1, and:1, dog:1 }

const nums = [4, 9, 2, 7];
nums.reduce((a,b) => a+b, 0);   // 22
Math.max(...nums);            // 9

function rotate(arr, k) {
  const n = arr.length;
  k = k % n;
  return [...arr.slice(n - k), ...arr.slice(0, n - k)];
}
rotate([1,2,3,4,5], 2);   // [4,5,1,2,3]

const unique = [...new Set([1,2,2,3,3,4])];
console.log(unique);   // [1,2,3,4]

function secondLargest(arr) {
  return [...new Set(arr)].sort((a,b) => b-a)[1];
}
secondLargest([5, 9, 9, 3]);   // 5

const nested = [1, [2, [3, [4]], 5]];
nested.flat(Infinity);   // [1,2,3,4,5] — Infinity flattens any depth

function isAnagram(a, b) {
  const norm = s => s.toLowerCase().split("").sort().join("");
  return norm(a) === norm(b);
}
isAnagram("listen", "silent");   // true

function titleCase(s) {
  return s.split(" ").map(w => w[0].toUpperCase() + w.slice(1)).join(" ");
}
titleCase("the quick brown fox");   // "The Quick Brown Fox"

const people = [{name:"A",team:"red"}, {name:"B",team:"blue"}, {name:"C",team:"red"}];

const grouped = people.reduce((acc, p) => {
  (acc[p.team] ??= []).push(p.name);
  return acc;
}, {});
// { red: ["A","C"], blue: ["B"] }

function debounce(fn, delay) {
  let timer;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}
// searchInput.addEventListener("input", debounce(runSearch, 300));

const original = { a: 1, nested: { b: 2 } };
const deep = structuredClone(original);   // native deep clone, no library needed
deep.nested.b = 99;
console.log(original.nested.b);   // 2 — untouched

function mergeSorted(a, b) {
  const result = [];
  let i = 0, j = 0;
  while (i < a.length && j < b.length) result.push(a[i] < b[j] ? a[i++] : b[j++]);
  return [...result, ...a.slice(i), ...b.slice(j)];
}
mergeSorted([1,3,5], [2,4,6]);   // [1,2,3,4,5,6]

function findMissing(arr, n) {
  const expected = (n * (n + 1)) / 2;
  const actual = arr.reduce((a,b) => a+b, 0);
  return expected - actual;
}
findMissing([1,2,4,5], 5);   // 3

function mergeSort(arr) {
  if (arr.length <= 1) return arr;
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  const merged = [];
  let i = 0, j = 0;
  while (i < left.length && j < right.length) {
    merged.push(left[i] < right[j] ? left[i++] : right[j++]);
  }
  return [...merged, ...left.slice(i), ...right.slice(j)];
}
mergeSort([5,3,8,1,9]);   // [1,3,5,8,9]

class EventEmitter {
  #listeners = new Map();

  on(event, fn) {
    if (!this.#listeners.has(event)) this.#listeners.set(event, []);
    this.#listeners.get(event).push(fn);
  }
  emit(event, ...args) {
    (this.#listeners.get(event) || []).forEach(fn => fn(...args));
  }
}

const bus = new EventEmitter();
bus.on("greet", name => console.log(`Hi, ${name}`));
bus.emit("greet", "Ada");   // "Hi, Ada"

function memoize(fn) {
  const cache = new Map();
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);   // skip recomputation
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}
const slowSquare = n => { for (let i=0;i<1e6;i++); return n*n; };
const fastSquare = memoize(slowSquare);   // second call with same input is instant

async function retry(fn, attempts = 3, delay = 500) {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      if (i === attempts - 1) throw err;
      await new Promise(r => setTimeout(r, delay));
    }
  }
}
// retry(() => fetch("/flaky-api"), 3, 1000)

class LRUCache {
  constructor(capacity) { this.capacity = capacity; this.map = new Map(); }

  get(key) {
    if (!this.map.has(key)) return -1;
    const val = this.map.get(key);
    this.map.delete(key);
    this.map.set(key, val);   // re-insert — Map preserves insertion order
    return val;
  }
  put(key, value) {
    if (this.map.has(key)) this.map.delete(key);
    else if (this.map.size >= this.capacity) {
      this.map.delete(this.map.keys().next().value);   // evict least recently used
    }
    this.map.set(key, value);
  }
}