JavaScript: Basic, 1–40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];

// The date is an argument, which is the only way this can be asserted.
function dayAndTime(date) {
  const day = DAYS[date.getDay()];

  const h24 = date.getHours();
  const suffix = h24 >= 12 ? 'PM' : 'AM';
  const h12 = h24 % 12 === 0 ? 12 : h24 % 12;   // 0 and 12 both mean 12

  const pad = (n) => String(n).padStart(2, '0');

  return `Today is ${day}. Current time is ${h12} ${suffix} : ${pad(date.getMinutes())} : ${pad(date.getSeconds())}`;
}

// A fixed date so the output is predictable. Wednesday, 22:30:38.
const sample = new Date(2026, 8, 2, 22, 30, 38);
console.log(dayAndTime(sample));

// And the real use, which cannot be asserted because it changes every second:
console.log('right now:', dayAndTime(new Date()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34// The original is one line:
//
//   window.print();
//
// That opens the browser's print dialogue. It cannot be asserted, and running it
// here would interrupt your reading. So instead: gather what is on the page.

function describePage(doc) {
  if (!doc) return 'no document available';

  const title = doc.title || '(untitled)';
  const headings = doc.body ? doc.body.getElementsByTagName('h1').length : 0;
  const links = doc.body ? doc.body.getElementsByTagName('a').length : 0;

  return `"${title}" with ${headings} h1 and ${links} link(s)`;
}

// A stand-in document, so the function can be tested without a browser.
const fakeDoc = {
  title: 'Exercises',
  body: {
    getElementsByTagName(tag) {
      const counts = { h1: 1, a: 4 };
      return { length: counts[tag] ?? 0 };
    },
  },
};

console.log(describePage(fakeDoc));
console.log(describePage(null));

// In a real browser you would call it with the real thing:
const real = typeof document === 'undefined' ? 'not in a browser' : describePage(document);
console.log('real document:', real);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function formats(date) {
  const pad = (n) => String(n).padStart(2, '0');

  const yyyy = date.getFullYear();
  const mm = pad(date.getMonth() + 1);   // zero-based, so +1
  const dd = pad(date.getDate());        // getDate is the day of the month

  // Build the pieces once, then arrange them.
  return {
    'mm-dd-yyyy': [mm, dd, yyyy].join('-'),
    'mm/dd/yyyy': [mm, dd, yyyy].join('/'),
    'dd-mm-yyyy': [dd, mm, yyyy].join('-'),
    'dd/mm/yyyy': [dd, mm, yyyy].join('/'),
  };
}

const out = formats(new Date(2026, 8, 2));   // 2 September 2026
for (const [label, value] of Object.entries(out)) console.log(label, '->', value);

// A single-digit day and month, to prove the padding.
const padded = formats(new Date(2026, 0, 5));
console.log('5 January:', padded['dd/mm/yyyy']);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19function triangleArea(a, b, c) {
  // Any two sides must together exceed the third, or there is no triangle.
  if (a + b <= c || b + c <= a || a + c <= b) {
    throw new RangeError(`no triangle has sides ${a}, ${b}, ${c}`);
  }
  const s = (a + b + c) / 2;               // half the perimeter
  return Math.sqrt(s * (s - a) * (s - b) * (s - c));
}

const area = triangleArea(5, 6, 7);
console.log('sides 5, 6, 7 ->', area);
console.log('rounded       ->', area.toFixed(4));

// A right triangle, where the answer is easy to check by hand: 3*4/2 = 6.
console.log('sides 3, 4, 5 ->', triangleArea(3, 4, 5));

let refused = '';
try { triangleArea(1, 2, 10); } catch (err) { refused = err.message; }
console.log('refused:', refused);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21function rotateRight(text) {
  if (text.length < 2) return text;
  return text.slice(-1) + text.slice(0, -1);
}

function rotations(text) {
  const steps = [];
  let current = text;
  for (let i = 0; i < text.length; i++) {
    current = rotateRight(current);
    steps.push(current);
  }
  return steps;
}

const steps = rotations('w3resource');
for (const s of steps) console.log(s);

// The original uses setInterval to animate this in the page. Same sequence,
// but returning it means it can be asserted:
//   setInterval(() => { el.textContent = rotateRight(el.textContent); }, 200);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const MS_PER_DAY = 24 * 60 * 60 * 1000;

// Strip the time so we compare whole days, not moments.
function atMidnight(date) {
  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
}

function daysBetween(from, to) {
  const a = atMidnight(from);
  const b = atMidnight(to);
  // Math.round, not floor: a daylight-saving change makes some days 23 hours.
  return Math.round((b - a) / MS_PER_DAY);
}

const today = new Date(2026, 8, 2);          // 2 September 2026
const christmas = new Date(2026, 11, 25);    // 25 December 2026

console.log('days to Christmas:', daysBetween(today, christmas));
console.log('days since new year:', daysBetween(new Date(2026, 0, 1), today));

// Why the time must be stripped: without it, these two would differ.
const morning = new Date(2026, 8, 2, 9, 0);
const evening = new Date(2026, 8, 2, 23, 0);
console.log('same day, different times ->', daysBetween(morning, evening));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23function compareDates(a, b) {
  // Less-than and greater-than work, because a Date converts to a number.
  if (a < b) return 'earlier';
  if (a > b) return 'later';
  return 'the same';
}

const first = new Date(2026, 8, 2);
const second = new Date(2026, 11, 25);
const duplicate = new Date(2026, 8, 2);

console.log(compareDates(first, second));
console.log(compareDates(second, first));
console.log(compareDates(first, duplicate));

// The trap: equality does NOT work on the objects themselves.
console.log('=== on two equal dates :', first === duplicate);   // false
console.log('getTime comparison     :', first.getTime() === duplicate.getTime());

// Which is why sorting needs a subtraction, not a comparison of objects:
const dates = [second, first, new Date(2026, 5, 1)];
const sorted = dates.slice().sort((x, y) => x - y).map((d) => d.getMonth() + 1);
console.log('sorted months:', sorted);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23// The problem, first. This is real and it bites people constantly:
console.log('0.1 + 0.2 =', 0.1 + 0.2);
console.log('is that 0.3?', 0.1 + 0.2 === 0.3);

// So work in whole kobo and divide only at the very end.
function bill(pricesInKobo, taxRate = 0.075) {
  const subtotal = pricesInKobo.reduce((n, p) => n + p, 0);
  const tax = Math.round(subtotal * taxRate);      // round once, to a whole unit
  return {
    subtotal,
    tax,
    total: subtotal + tax,
    display: `₦${((subtotal + tax) / 100).toFixed(2)}`,
  };
}

// Three items at 1200.00, 850.50 and 99.99 naira, written in kobo.
const out = bill([120000, 85050, 9999]);

console.log('subtotal kobo:', out.subtotal);
console.log('tax kobo     :', out.tax);
console.log('total kobo   :', out.total);
console.log('for the eye  :', out.display);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function isLeapYear(year) {
  // Divisible by 4, except centuries, except centuries divisible by 400.
  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}

// The naive version, for comparison.
function naive(year) {
  return year % 4 === 0;
}

for (const y of [2024, 2025, 1900, 2000, 2100]) {
  console.log(y, isLeapYear(y) ? 'is a leap year' : 'is not');
}

console.log('where the naive version goes wrong:');
console.log('  1900 correct:', isLeapYear(1900), ' naive:', naive(1900));
console.log('  2000 correct:', isLeapYear(2000), ' naive:', naive(2000));

// A cross-check against the calendar itself: February has 29 days in a leap year.
function februaryDays(year) {
  return new Date(year, 2, 0).getDate();   // day 0 of March is the last of February
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];

function dayName(date) {
  return DAY_NAMES[date.getDay()];      // getDay: 0..6, Sunday first
}

// Whereas getDate is the day of the MONTH. Different question entirely.
function describe(date) {
  return `${dayName(date)} the ${date.getDate()}`;
}

const dates = [
  new Date(2026, 8, 2),     // Wednesday 2 September 2026
  new Date(2026, 0, 1),     // Thursday 1 January 2026
  new Date(2000, 0, 1),     // Saturday 1 January 2000
];

for (const d of dates) console.log(describe(d));

// Weekday or weekend, using the numbering directly.
function isWeekend(date) {
  const n = date.getDay();
  return n === 0 || n === 6;
}

console.log('2 Sep 2026 a weekend?', isWeekend(dates[0]));
console.log('5 Sep 2026 a weekend?', isWeekend(new Date(2026, 8, 5)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const toFahrenheit = (c) => (c * 9) / 5 + 32;
const toCelsius = (f) => ((f - 32) * 5) / 9;

for (const c of [-40, 0, 37, 100]) {
  console.log(`${c}°C = ${toFahrenheit(c)}°F`);
}

// A round trip should return the original, but floating point means "should"
// needs a tolerance rather than an equals sign.
const close = (a, b, tolerance = 1e-9) => Math.abs(a - b) < tolerance;

const roundTrip = toCelsius(toFahrenheit(36.6));
console.log('36.6 there and back:', roundTrip);
console.log('exactly equal?', roundTrip === 36.6);
console.log('close enough?  ', close(roundTrip, 36.6));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20function randomBetween(min, max) {
  if (min > max) throw new RangeError(`min ${min} is above max ${max}`);
  // The + 1 is what makes max reachable. Without it, max never appears.
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// The common wrong version, for comparison.
function exclusiveOfMax(min, max) {
  return Math.floor(Math.random() * (max - min)) + min;
}

const rolls = Array.from({ length: 600 }, () => randomBetween(1, 6));
const seen = new Set(rolls);

console.log('first ten rolls:', rolls.slice(0, 10).join(', '));
console.log('distinct values:', [...seen].sort().join(', '));

// Prove the wrong version never reaches the top of the range.
const wrong = new Set(Array.from({ length: 600 }, () => exclusiveOfMax(1, 6)));
console.log('the buggy version produced:', [...wrong].sort().join(', '));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21function reverseNumber(n) {
  const sign = n < 0 ? -1 : 1;
  const digits = String(Math.abs(n)).split('').reverse().join('');
  return sign * Number(digits);
}

// The arithmetic version, with no text conversion at all.
function reverseByMaths(n) {
  const sign = n < 0 ? -1 : 1;
  let left = Math.abs(n);
  let out = 0;
  while (left > 0) {
    out = out * 10 + (left % 10);
    left = Math.floor(left / 10);
  }
  return sign * out;
}

for (const n of [32243, -1234, 1200, 7, 0]) {
  console.log(n, '->', reverseNumber(n), '| by maths:', reverseByMaths(n));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33function normalise(text) {
  return text.toLowerCase().replace(/[^a-z0-9]/g, '');
}

function isPalindrome(text) {
  const clean = normalise(text);
  return clean === clean.split('').reverse().join('');
}

// The two-pointer version: no reversed copy, so no extra allocation.
function isPalindromeTwoPointer(text) {
  const clean = normalise(text);
  let left = 0;
  let right = clean.length - 1;
  while (left < right) {
    if (clean[left] !== clean[right]) return false;
    left++;
    right--;
  }
  return true;
}

const samples = [
  'madam',
  'A man, a plan, a canal: Panama',
  'No lemon, no melon',
  'hello',
  '12321',
];

for (const s of samples) {
  console.log(JSON.stringify(s), '->', isPalindrome(s));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const VOWELS = new Set(['a', 'e', 'i', 'o', 'u']);   // y is not counted here

function countVowels(text) {
  let n = 0;
  for (const ch of text.toLowerCase()) {
    if (VOWELS.has(ch)) n++;
  }
  return n;
}

// The one-liner. Note the ?? 0: match returns null, not [], when nothing hits.
function countVowelsRegex(text) {
  return (text.match(/[aeiou]/gi) ?? []).length;
}

const samples = ['w3resource', 'JavaScript is fun', 'rhythm', ''];

for (const s of samples) {
  console.log(JSON.stringify(s), '->', countVowels(s));
}

// The trap in the one-liner, made visible:
console.log("'rhythm'.match(/[aeiou]/gi) is", 'rhythm'.match(/[aeiou]/gi));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function isPrime(n) {
  if (!Number.isInteger(n) || n < 2) return false;   // 0, 1 and negatives are not prime
  if (n === 2) return true;
  if (n % 2 === 0) return false;                     // every other even number is out

  // Only up to the square root: any factor above it has a partner below it.
  const limit = Math.sqrt(n);
  for (let d = 3; d <= limit; d += 2) {
    if (n % d === 0) return false;
  }
  return true;
}

const upTo30 = [];
for (let n = 0; n <= 30; n++) if (isPrime(n)) upTo30.push(n);

console.log('primes to 30:', upTo30.join(', '));
console.log('97 prime?', isPrime(97));
console.log('91 prime?', isPrime(91), '(7 x 13)');

// Why the square root is enough: 91's factors are 7 and 13, and 7 < sqrt(91) < 13.
console.log('sqrt(91) is about', Math.sqrt(91).toFixed(2));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16function sortThree(a, b, c) {
  return [a, b, c].sort((x, y) => x - y);     // the comparator is not optional
}

console.log(sortThree(3, 1, 2));
console.log(sortThree(10, 9, 100));

// The default sort compares as text, which is almost never what you want:
const numbers = [10, 9, 100, 1];
console.log('with a comparator:', numbers.slice().sort((a, b) => a - b));
console.log('without one      :', numbers.slice().sort());

// And sort mutates, which surprises people. slice() above is what protects it.
const original = [3, 1, 2];
const sorted = original.sort((a, b) => a - b);
console.log('same array?', original === sorted);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const largestOfThree = (a, b, c) => Math.max(a, b, c);

// For any number of values, spread the array in.
function largest(values) {
  if (values.length === 0) throw new RangeError('largest needs at least one value');
  return Math.max(...values);
}

console.log(largestOfThree(3, 9, 5));
console.log(largest([3, 9, 5, 22, 7]));

// The edge nobody expects:
console.log('Math.max() with nothing:', Math.max());

// And the limit of spreading: a very large array can exceed the argument limit,
// so reduce is the safe choice for those.
const bigSafe = [5, 1, 9, 3].reduce((best, n) => (n > best ? n : best), -Infinity);
console.log('via reduce:', bigSafe);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26// The version where order matters, and the both-case must come first.
function fizzbuzzOrdered(n) {
  if (n % 15 === 0) return 'FizzBuzz';
  if (n % 3 === 0) return 'Fizz';
  if (n % 5 === 0) return 'Buzz';
  return String(n);
}

// The version where order cannot go wrong, because the word is built up.
function fizzbuzz(n) {
  let out = '';
  if (n % 3 === 0) out += 'Fizz';
  if (n % 5 === 0) out += 'Buzz';
  return out || String(n);
}

const upTo20 = Array.from({ length: 20 }, (_, i) => fizzbuzz(i + 1));
console.log(upTo20.join(' '));

// The classic mistake: checking 3 before 15, so 15 comes out as just Fizz.
function buggy(n) {
  if (n % 3 === 0) return 'Fizz';
  if (n % 15 === 0) return 'FizzBuzz';
  return String(n);
}
console.log('buggy version on 15:', buggy(15));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21// Return the data...
function table(n, upTo = 10) {
  return Array.from({ length: upTo }, (_, i) => ({
    multiplier: i + 1,
    product: n * (i + 1),
  }));
}

// ...and format it separately.
function formatTable(n, upTo = 10) {
  return table(n, upTo)
    .map((row) => `${String(n).padStart(2)} x ${String(row.multiplier).padStart(2)} = ${String(row.product).padStart(3)}`)
    .join('\n');
}

console.log(formatTable(7));
console.log('');
console.log(formatTable(12, 5));

const seven = table(7);
const products = seven.map((r) => r.product);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25// The one you should write.
function swapModern(a, b) {
  [a, b] = [b, a];
  return [a, b];
}

// The interview-trivia version. Numbers only, and it can overflow.
function swapArithmetic(a, b) {
  a = a + b;
  b = a - b;
  a = a - b;
  return [a, b];
}

console.log('destructuring:', swapModern(1, 2));
console.log('arithmetic   :', swapArithmetic(1, 2));

// Works for anything, because it does not do maths:
console.log('text  :', swapModern('first', 'second'));
console.log('mixed :', swapModern(1, 'one'));

// Where the arithmetic version quietly goes wrong:
const big = Number.MAX_SAFE_INTEGER;
const [x, y] = swapArithmetic(big, 2);
console.log('big numbers swapped:', x, y, '-- expected 2 and', big);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19// The starting value is the identity: 0 for addition, 1 for multiplication.
const sum = (values) => values.reduce((total, n) => total + n, 0);
const product = (values) => values.reduce((total, n) => total * n, 1);

const nums = [1, 2, 3, 4, 5];

console.log('sum    :', sum(nums));
console.log('product:', product(nums));
console.log('empty sum    :', sum([]));
console.log('empty product:', product([]));

// Without a starting value, reduce throws on an empty array:
let threw = false;
try {
  [].reduce((a, b) => a + b);
} catch (err) {
  threw = true;
  console.log('no starting value on []:', err.constructor.name);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23function words(sentence) {
  return sentence
    .split(/\s+/)                      // any run of whitespace, not just one space
    .map((w) => w.replace(/[^\p{L}\p{N}'-]/gu, ''))   // drop punctuation, keep hyphens
    .filter((w) => w.length > 0);
}

// > keeps the FIRST of equal-length words. >= would keep the last.
function longestWord(sentence) {
  return words(sentence).reduce((best, w) => (w.length > best.length ? w : best), '');
}

function allLongest(sentence) {
  const list = words(sentence);
  const max = Math.max(0, ...list.map((w) => w.length));
  return list.filter((w) => w.length === max);
}

const s = 'Web  development  tutorial, and  well-being.';

console.log('words        :', words(s));
console.log('longest      :', longestWord(s));
console.log('all longest  :', allLongest('one three four'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17function capitalise(word) {
  if (word.length === 0) return word;         // guard, or word[0] is undefined
  return word[0].toUpperCase() + word.slice(1).toLowerCase();
}

function titleCase(sentence) {
  return sentence.split(' ').map(capitalise).join(' ');
}

// The regex version, which handles any whitespace and keeps it intact.
function titleCaseRegex(sentence) {
  return sentence.replace(/\S+/g, capitalise);
}

console.log(titleCase('the quick brown fox'));
console.log(titleCase('hELLO wORLD'));
console.log(titleCaseRegex('spaced   out   words'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29// A Map has no inherited keys, so nothing can collide.
function countChars(text) {
  const counts = new Map();
  for (const ch of text) {
    counts.set(ch, (counts.get(ch) ?? 0) + 1);
  }
  return counts;
}

// The plain-object version, and the trap it carries.
function countCharsObject(text) {
  const counts = {};
  for (const ch of text) counts[ch] = (counts[ch] ?? 0) + 1;
  return counts;
}

const counts = countChars('hello world');
console.log([...counts.entries()]);

// Why a bare object is risky: these keys already exist on Object.prototype.
const bare = {};
console.log('bare.constructor is', typeof bare.constructor);
console.log('so "constructor" in {} is', 'constructor' in bare);

// Object.create(null) has no prototype, so it behaves like a Map here.
const safe = Object.create(null);
console.log('safe.constructor is', safe.constructor);

const most = [...counts.entries()].reduce((best, e) => (e[1] > best[1] ? e : best));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25const unique = (values) => [...new Set(values)];

console.log(unique([1, 2, 2, 3, 1, 4]));
console.log(unique(['a', 'b', 'a']));

// Order is preserved: a Set iterates in insertion order.
console.log('order kept:', unique([3, 1, 3, 2]));

// Objects are compared by identity, so look-alikes are not duplicates.
const shared = { id: 1 };
console.log('same object twice :', unique([shared, shared]).length);
console.log('two equal objects :', unique([{ id: 1 }, { id: 1 }]).length);

// To dedupe objects by content, pick a key.
function uniqueBy(values, keyOf) {
  const seen = new Map();
  for (const v of values) if (!seen.has(keyOf(v))) seen.set(keyOf(v), v);
  return [...seen.values()];
}

console.log('deduped by id:', uniqueBy([{ id: 1 }, { id: 1 }, { id: 2 }], (o) => o.id));

// The NaN oddity: Set considers it equal to itself, === does not.
console.log('NaN === NaN     :', NaN === NaN);
console.log('unique([NaN,NaN]):', unique([NaN, NaN]).length);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29// Order matters.
function sameOrder(a, b) {
  if (a.length !== b.length) return false;
  return a.every((v, i) => v === b[i]);
}

// Order does not matter. Sort copies, never the originals.
function sameContents(a, b) {
  if (a.length !== b.length) return false;
  const x = [...a].sort();
  const y = [...b].sort();
  return x.every((v, i) => v === y[i]);
}

const a = [1, 2, 3];
const b = [1, 2, 3];
const c = [3, 2, 1];

console.log('=== on two equal arrays:', a === b);
console.log('sameOrder(a, b)   :', sameOrder(a, b));
console.log('sameOrder(a, c)   :', sameOrder(a, c));
console.log('sameContents(a, c):', sameContents(a, c));

// The JSON shortcut works but is order-sensitive and slow on big arrays:
console.log('via JSON:', JSON.stringify(a) === JSON.stringify(b));

// sameContents sorts copies, so the inputs are untouched:
sameContents(a, c);
console.log('c after comparing:', c);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28// Second distinct value.
function secondLargest(values) {
  const distinct = [...new Set(values)].sort((a, b) => b - a);
  if (distinct.length < 2) return undefined;
  return distinct[1];
}

// One pass, no sorting, no extra array.
function secondLargestOnePass(values) {
  let best = -Infinity;
  let second = -Infinity;
  for (const n of values) {
    if (n > best) {
      second = best;
      best = n;
    } else if (n < best && n > second) {
      second = n;
    }
  }
  return second === -Infinity ? undefined : second;
}

console.log(secondLargest([10, 5, 8, 10, 3]));
console.log('one pass agrees:', secondLargestOnePass([10, 5, 8, 10, 3]));

// The trap: sorting without deduping gives 10 again.
const naive = [...[10, 5, 8, 10, 3]].sort((a, b) => b - a)[1];
console.log('without deduping:', naive);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18function digitSum(n) {
  return String(Math.abs(n))
    .split('')
    .reduce((total, d) => total + Number(d), 0);
}

function digitalRoot(n) {
  let value = Math.abs(n);
  while (value >= 10) value = digitSum(value);
  return value;
}

// The closed-form shortcut, for cross-checking.
const rootFormula = (n) => (n === 0 ? 0 : 1 + ((Math.abs(n) - 1) % 9));

for (const n of [1234, 99, 9875, 0, -456]) {
  console.log(n, 'digits sum to', digitSum(n), '-> root', digitalRoot(n));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26function factorialLoop(n) {
  if (!Number.isInteger(n) || n < 0) throw new RangeError(`factorial needs a whole number 0 or above, got ${n}`);
  let out = 1;
  for (let i = 2; i <= n; i++) out *= i;
  return out;
}

function factorialRecursive(n) {
  if (n < 0) throw new RangeError('no factorial for negatives');
  return n <= 1 ? 1 : n * factorialRecursive(n - 1);
}

// Exact for any size, because BigInt does not lose precision.
function factorialBig(n) {
  let out = 1n;
  for (let i = 2n; i <= BigInt(n); i++) out *= i;
  return out;
}

console.log('5! =', factorialLoop(5));
console.log('0! =', factorialLoop(0));
console.log('20! =', factorialLoop(20), '(still exact)');
console.log('21! =', factorialLoop(21), '(no longer exact)');
console.log('21! =', factorialBig(21).toString(), '(BigInt, exact)');

console.log('is 21! safe as a Number?', factorialLoop(21) <= Number.MAX_SAFE_INTEGER);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31let naiveCalls = 0;

function fibNaive(n) {
  naiveCalls++;
  return n < 2 ? n : fibNaive(n - 1) + fibNaive(n - 2);
}

// Remember what you have already worked out.
function fibMemo(n, seen = new Map()) {
  if (n < 2) return n;
  const cached = seen.get(n);
  if (cached !== undefined) return cached;
  const value = fibMemo(n - 1, seen) + fibMemo(n - 2, seen);
  seen.set(n, value);
  return value;
}

// No recursion, no memory: keep the last two and walk forward.
function fibLoop(n) {
  let [a, b] = [0, 1];
  for (let i = 0; i < n; i++) [a, b] = [b, a + b];
  return a;
}

const first10 = Array.from({ length: 10 }, (_, i) => fibLoop(i));
console.log('first ten:', first10.join(', '));

naiveCalls = 0;
fibNaive(25);
console.log('fibNaive(25) made', naiveCalls, 'calls');
console.log('fibLoop(25) is', fibLoop(25), 'with 25 steps');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23function gcd(a, b) {
  a = Math.abs(a);
  b = Math.abs(b);
  while (b !== 0) [a, b] = [b, a % b];
  return a;
}

// Divide first, then multiply, so the intermediate value stays smaller.
function lcm(a, b) {
  if (a === 0 || b === 0) return 0;
  return Math.abs(a / gcd(a, b) * b);
}

console.log('gcd(12, 18) =', gcd(12, 18));
console.log('gcd(17, 5)  =', gcd(17, 5), '(coprime)');
console.log('lcm(4, 6)   =', lcm(4, 6));

// Works for a whole list by folding.
const gcdAll = (values) => values.reduce(gcd);
const lcmAll = (values) => values.reduce(lcm);

console.log('gcd of [12, 18, 24] =', gcdAll([12, 18, 24]));
console.log('lcm of [2, 3, 4]    =', lcmAll([2, 3, 4]));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24function bases(n) {
  return {
    binary: n.toString(2),
    octal: n.toString(8),
    hex: n.toString(16).toUpperCase(),
  };
}

const out = bases(255);
console.log('255 in binary:', out.binary);
console.log('255 in octal :', out.octal);
console.log('255 in hex   :', out.hex);

// Reading back. The base argument is not optional in practice.
console.log('parseInt("11111111", 2) =', parseInt('11111111', 2));
console.log('parseInt("FF", 16)      =', parseInt('FF', 16));

// Why the base matters: without it, behaviour depends on the text.
console.log('parseInt("0x1A")     =', parseInt('0x1A'));      // hex, guessed
console.log('parseInt("0x1A", 10) =', parseInt('0x1A', 10));  // stops at the x

// And Number() is stricter than parseInt: it refuses partial input.
console.log('Number("12abc") =', Number('12abc'));
console.log('parseInt("12abc", 10) =', parseInt('12abc', 10));

1
2
3
4
5
6
7
8
9
10
11
12const values = [[], {}, 'text', 42, null, undefined, new Date(), /re/];

// typeof cannot tell an array from an object, or from null.
for (const v of values) {
  console.log(String(typeof v).padEnd(10), Array.isArray(v) ? 'array' : 'not an array');
}

// The general-purpose version, for when you need the exact built-in.
const kindOf = (v) => Object.prototype.toString.call(v).slice(8, -1).toLowerCase();

console.log('');
for (const v of values) console.log(kindOf(v));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const nested = [1, [2, 3], [4, [5, [6, 7]]], 8];

console.log('one level  :', nested.flat());
console.log('all the way:', nested.flat(Infinity));

// The hand-written version, so the mechanism is visible.
function flatten(values) {
  const out = [];
  for (const v of values) {
    if (Array.isArray(v)) out.push(...flatten(v));
    else out.push(v);
  }
  return out;
}

console.log('by hand    :', flatten(nested));

// flatMap: map then flatten one level. Useful for one-to-many.
const words = ['hello world', 'good morning'];
console.log('flatMap:', words.flatMap((s) => s.split(' ')));

// Empty slots vanish, which is occasionally surprising:
console.log('flat removes holes:', [1, , 3].flat());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45// Fisher-Yates. Walk backwards, swap with a random index at or before i.
function shuffle(values) {
  const out = [...values];
  for (let i = out.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [out[i], out[j]] = [out[j], out[i]];
  }
  return out;
}

// The popular one-liner. Looks fine, is not uniform.
const badShuffle = (values) => [...values].sort(() => Math.random() - 0.5);

console.log('shuffled:', shuffle([1, 2, 3, 4, 5]).join(', '));

/* Measuring the bias needs care. With five elements the sort version is only a
   few points off, which hides in the noise of a few thousand runs. With TEN it
   keeps the first element first about twice as often as it should, which is
   unmistakable. So the measurement uses ten. */
const TEN = Array.from({ length: 10 }, (_, i) => i + 1);
const RUNS = 20000;

function firstStaysFirst(fn) {
  let count = 0;
  for (let i = 0; i < RUNS; i++) if (fn(TEN)[0] === 1) count++;
  return count / RUNS;
}

// Stronger still: where does element 1 land? Every position should be 1 in 10.
function positionSpread(fn) {
  const seen = Array(10).fill(0);
  for (let i = 0; i < RUNS; i++) seen[fn(TEN).indexOf(1)]++;
  return Math.max(...seen.map((n) => Math.abs(n / RUNS - 0.1)));
}

const fair = firstStaysFirst(shuffle);
const biased = firstStaysFirst(badShuffle);
const fairSpread = positionSpread(shuffle);
const biasedSpread = positionSpread(badShuffle);

console.log('with ten elements, every position should be 10.0%');
console.log('fair shuffle keeps 1 first', (fair * 100).toFixed(1) + '% of the time');
console.log('sort shuffle keeps 1 first', (biased * 100).toFixed(1) + '% of the time  <- about double');
console.log('worst position error, fair:', (fairSpread * 100).toFixed(1) + ' points');
console.log('worst position error, sort:', (biasedSpread * 100).toFixed(1) + ' points');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21function truncate(text, max, suffix = '\u2026') {
  if (text.length <= max) return text;
  if (max <= suffix.length) return suffix.slice(0, max);
  // The suffix has to fit inside the limit, not be added on top of it.
  return text.slice(0, max - suffix.length) + suffix;
}

// A tidier cut: back up to the last space so words stay whole.
function truncateWords(text, max, suffix = '\u2026') {
  if (text.length <= max) return text;
  const cut = text.slice(0, max - suffix.length);
  const lastSpace = cut.lastIndexOf(' ');
  const base = lastSpace > 0 ? cut.slice(0, lastSpace) : cut;
  return base + suffix;
}

const long = 'The quick brown fox jumps over the lazy dog';

console.log(truncate(long, 20));
console.log(truncateWords(long, 20));
console.log('short text:', truncate('hi', 20));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33const buses = [
  { plate: 'LAG-441-XA', route: 'Lagos - Abuja', tier: 'luxury' },
  { plate: 'ABJ-772-KM', route: 'Lagos - Abuja', tier: 'economy' },
  { plate: 'ENU-318-PH', route: 'Lagos - Kano', tier: 'luxury' },
  { plate: 'KAN-905-BD', route: 'Lagos - Kano', tier: 'economy' },
];

function groupBy(items, keyOf) {
  const out = new Map();
  for (const item of items) {
    const key = keyOf(item);
    const bucket = out.get(key) ?? [];
    bucket.push(item);
    out.set(key, bucket);
  }
  return out;
}

const byRoute = groupBy(buses, (b) => b.route);
const byTier = groupBy(buses, (b) => b.tier);

for (const [route, list] of byRoute) {
  console.log(route, '->', list.map((b) => b.plate).join(', '));
}

// Counting is the same shape with a number instead of an array.
function countBy(items, keyOf) {
  const out = new Map();
  for (const item of items) out.set(keyOf(item), (out.get(keyOf(item)) ?? 0) + 1);
  return out;
}

console.log('per tier:', [...countBy(buses, (b) => b.tier).entries()]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53// A clock we drive by hand, so the test does not have to wait.
function makeClock() {
  let now = 0;
  let next = 1;
  const jobs = new Map();
  return {
    setTimeout(fn, delay) {
      const id = next++;
      jobs.set(id, { at: now + delay, fn });
      return id;
    },
    clearTimeout(id) { jobs.delete(id); },
    advance(ms) {
      now += ms;
      for (const [id, job] of [...jobs.entries()]) {
        if (job.at <= now) { jobs.delete(id); job.fn(); }
      }
    },
  };
}

function debounce(fn, wait, clock) {
  let timer = null;
  return (...args) => {
    if (timer !== null) clock.clearTimeout(timer);   // cancel the previous one
    timer = clock.setTimeout(() => fn(...args), wait);
  };
}

const clock = makeClock();
const calls = [];
const save = debounce((value) => calls.push(value), 100, clock);

save('a');
save('b');
save('c');           // only this one should survive

// Snapshots have to be taken at the moment they describe, not at the end.
const immediately = calls.length;

clock.advance(99);
const justBefore = calls.length;

clock.advance(1);
const afterWait = [...calls];

save('d');
clock.advance(100);

console.log('immediately        :', immediately);
console.log('after 99ms         :', justBefore);
console.log('after the full wait:', afterWait);
console.log('and a later call   :', calls);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27const original = {
  plate: 'LAG-441-XA',
  seats: { total: 14, sold: 9 },
  serviced: new Date('2026-01-15T00:00:00Z'),
  tags: ['aircon', 'wifi'],
  notes: undefined,
};

// One level only. The nested object is shared.
const shallow = { ...original };
shallow.seats.sold = 999;
console.log('after editing the shallow copy, original sold =', original.seats.sold);
original.seats.sold = 9;                 // put it back

// Deep, but lossy.
const viaJson = JSON.parse(JSON.stringify(original));
console.log('date became a', typeof viaJson.serviced);
console.log('undefined key survived?', 'notes' in viaJson);

// Deep and faithful.
const deep = structuredClone(original);
deep.seats.sold = 1;
deep.tags.push('tv');

console.log('original sold after deep edit:', original.seats.sold);
console.log('original tags after deep edit:', original.tags);
console.log('date is still a Date:', deep.serviced instanceof Date);