JavaScript: Basic, 41–80

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20function countWords(text) {
  const trimmed = text.trim();
  if (trimmed === '') return 0;          // the case split() gets wrong
  return trimmed.split(/\s+/).length;
}

// The regex route. No empty-string special case, but match returns null.
const countWordsRegex = (text) => (text.match(/\S+/g) ?? []).length;

// The naive version, so the failures are visible.
const naive = (text) => text.split(' ').length;

const samples = ['one two three', '  padded  ', 'double  spaces  here', '', 'one'];

for (const s of samples) {
  console.log(JSON.stringify(s).padEnd(24), countWords(s));
}

console.log('naive on "":', naive(''), '<- claims one word');
console.log('naive on "a  b":', naive('a  b'), '<- claims three');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20function firstUnique(text) {
  const counts = new Map();
  for (const ch of text) counts.set(ch, (counts.get(ch) ?? 0) + 1);

  // Walk the original order, not the map, so ties resolve by position.
  for (const ch of text) if (counts.get(ch) === 1) return ch;
  return null;
}

// Because a Map preserves insertion order, this also works.
function firstUniqueViaMap(text) {
  const counts = new Map();
  for (const ch of text) counts.set(ch, (counts.get(ch) ?? 0) + 1);
  for (const [ch, n] of counts) if (n === 1) return ch;
  return null;
}

for (const s of ['swiss', 'aabbcc', 'x', 'aabbc', '']) {
  console.log(JSON.stringify(s).padEnd(10), '->', JSON.stringify(firstUnique(s)));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24const SMALL = new Set(['a', 'an', 'and', 'as', 'at', 'but', 'by', 'for',
  'in', 'nor', 'of', 'on', 'or', 'the', 'to', 'up', 'via']);

const cap = (w) => (w.length === 0 ? w : w[0].toUpperCase() + w.slice(1).toLowerCase());

function titleCase(sentence) {
  const words = sentence.toLowerCase().split(/\s+/).filter(Boolean);
  return words
    .map((w, i) => {
      // First and last always capitalised; small words in between are not.
      const isEdge = i === 0 || i === words.length - 1;
      return !isEdge && SMALL.has(w) ? w : cap(w);
    })
    .join(' ');
}

const samples = [
  'the lord of the rings',
  'a tale of two cities',
  'gone with the wind',
  'of mice and men',
];

for (const s of samples) console.log(titleCase(s));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20function chunk(values, size) {
  if (!Number.isInteger(size) || size < 1) {
    throw new RangeError(`chunk size must be a whole number of 1 or more, got ${size}`);
  }
  const out = [];
  for (let i = 0; i < values.length; i += size) out.push(values.slice(i, i + size));
  return out;
}

// The same without a mutable accumulator.
const chunkFrom = (values, size) =>
  Array.from({ length: Math.ceil(values.length / size) }, (_, i) =>
    values.slice(i * size, i * size + size));

console.log(chunk([1, 2, 3, 4, 5, 6, 7], 3));
console.log(chunk(['a', 'b', 'c'], 1));

let refused = '';
try { chunk([1, 2], 0); } 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
21
22
23
24const mixed = [1, 'two', 3, null, 4.5, undefined, NaN, Infinity, true, '6'];

// Strict: only real numbers. NaN, Infinity, booleans and numeric strings are out.
const sumStrict = (values) =>
  values.filter((v) => typeof v === 'number' && Number.isFinite(v))
        .reduce((n, v) => n + v, 0);

// Lenient: also accept strings that are entirely a number.
const sumLenient = (values) =>
  values.reduce((n, v) => {
    if (typeof v === 'number' && Number.isFinite(v)) return n + v;
    if (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v))) return n + Number(v);
    return n;
  }, 0);

console.log('strict :', sumStrict(mixed));
console.log('lenient:', sumLenient(mixed));

// Why typeof alone is not enough:
console.log('typeof NaN      :', typeof NaN);
console.log('typeof Infinity :', typeof Infinity);

// And why coercion is a bad default: true would become 1.
console.log('Number(true) is', Number(true));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16function rotate(values, n) {
  const len = values.length;
  if (len === 0) return [];
  // JavaScript's % keeps the sign of the left side, so normalise it.
  const shift = ((n % len) + len) % len;
  return [...values.slice(shift), ...values.slice(0, shift)];
}

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

console.log('by 2 :', rotate(nums, 2));
console.log('by 7 :', rotate(nums, 7), '(same as 2)');
console.log('by -1:', rotate(nums, -1));

// The trap this avoids:
console.log('-1 % 5 in JavaScript is', -1 % 5, '-- not 4');

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
35const normalise = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, '');

// The clear version.
function isAnagram(a, b) {
  const x = normalise(a);
  const y = normalise(b);
  if (x.length !== y.length) return false;
  return [...x].sort().join('') === [...y].sort().join('');
}

// The counting version: one pass each, no sort.
function isAnagramCounted(a, b) {
  const x = normalise(a);
  const y = normalise(b);
  if (x.length !== y.length) return false;
  const counts = new Map();
  for (const ch of x) counts.set(ch, (counts.get(ch) ?? 0) + 1);
  for (const ch of y) {
    const left = counts.get(ch);
    if (left === undefined || left === 0) return false;
    counts.set(ch, left - 1);
  }
  return true;
}

const pairs = [
  ['listen', 'silent'],
  ['Dormitory', 'Dirty Room'],
  ['hello', 'world'],
  ['aab', 'abb'],
];

for (const [a, b] of pairs) {
  console.log(a.padEnd(11), b.padEnd(11), isAnagram(a, b));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18// Always pass the locale: without it the output depends on the machine,
// so the same code prints 1,234.5 for one reader and 1.234,5 for another.
const grouped = (n) => n.toLocaleString('en-NG');

// Reuse a formatter when doing many numbers: constructing one is the slow part.
const naira = new Intl.NumberFormat('en-NG', {
  style: 'currency',
  currency: 'NGN',
  maximumFractionDigits: 0,
});

console.log(grouped(1234567));
console.log(grouped(1234.5));
console.log('as currency:', naira.format(18000));

// The hand-rolled version, for comparison. Works, but only for plain grouping.
const byRegex = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
console.log('by regex:', byRegex(1234567));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21// Deliberately loose. Rejects the obviously broken and accepts the rest.
const looksLikeEmail = (text) =>
  typeof text === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(text.trim());

const samples = [
  'amaka@example.com',
  'chidi.eze+bookings@bus.example.co.uk',
  'no-at-sign.com',
  'two@@example.com',
  'spaces in@example.com',
  'missing@dot',
  '',
];

for (const s of samples) {
  console.log(JSON.stringify(s).padEnd(38), looksLikeEmail(s));
}

// What the check cannot tell you:
console.log('');
console.log('accepted, but almost certainly not a real inbox:', looksLikeEmail('a@b.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
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
54
55
56
57
58
59
60function makeClock() {
  let now = 0;
  const jobs = [];
  return {
    wait(ms) {
      // A promise that resolves when the clock is advanced far enough.
      return new Promise((resolve) => jobs.push({ at: now + ms, resolve }));
    },
    async advance(ms) {
      // Drain first, THEN move the clock. Code that is mid-attempt has not
      // registered its wait yet, and a wait registered after the clock moved
      // would be timed from the wrong "now" and never come due. Letting it
      // settle first is what keeps each wait on the schedule it asked for.
      for (let turn = 0; turn < 20; turn++) await Promise.resolve();
      now += ms;
      for (const j of jobs.filter((j) => j.at <= now)) {
        jobs.splice(jobs.indexOf(j), 1);
        j.resolve();
      }
      for (let turn = 0; turn < 20; turn++) await Promise.resolve();
    },
    get time() { return now; },
  };
}

async function retry(fn, { attempts = 4, baseMs = 100, clock }) {
  const waits = [];
  let lastError;
  for (let attempt = 1; attempt <= attempts; attempt++) {
    try {
      return { value: await fn(attempt), attempt, waits };
    } catch (err) {
      lastError = err;
      if (attempt === attempts) break;
      const wait = baseMs * 2 ** (attempt - 1);   // 100, 200, 400, ...
      waits.push(wait);
      await clock.wait(wait);
    }
  }
  throw lastError;
}

const clock = makeClock();

// Fails twice, then works.
let calls = 0;
const flaky = async () => {
  calls++;
  if (calls < 3) throw new Error('temporarily unavailable');
  return 'payload';
};

const running = retry(flaky, { baseMs: 100, clock });
await clock.advance(100);   // let the first backoff elapse
await clock.advance(200);   // and the second
const result = await running;

console.log('succeeded on attempt', result.attempt);
console.log('waits used:', result.waits);
console.log('total simulated time:', clock.time, 'ms');

1
2
3
4
5
6
7
8
9
10
11
12
13
14// toFixed rounds to a fixed width and returns TEXT, not a number.
const money = (n) => n.toFixed(2);

// Rounding and staying numeric: scale up, round, scale back down.
const roundTo = (n, places) => {
  const factor = 10 ** places;
  return Math.round(n * factor) / factor;
};

console.log('toFixed(2)  ->', money(3.14159), 'type', typeof money(3.14159));
console.log('roundTo(,2) ->', roundTo(3.14159, 2), 'type', typeof roundTo(3.14159, 2));
console.log('padded      ->', (2.5).toFixed(3));
console.log('1.005 to 2 places ->', (1.005).toFixed(2), '<- not 1.01');
console.log('because it is stored as   ', (1.005).toFixed(17));

1
2
3
4
5
6
7
8
9
10
11const ways = (n) => ({
  floor: Math.floor(n),   // down, always
  ceil: Math.ceil(n),     // up, always
  round: Math.round(n),   // to the nearest, ties go up
  trunc: Math.trunc(n),   // fraction dropped, so towards zero
});

console.log('4.7  ->', ways(4.7));
console.log('-4.7 ->', ways(-4.7), '<- floor and trunc disagree');
console.log('ties: 2.5 ->', Math.round(2.5), ' -2.5 ->', Math.round(-2.5));
console.log('Math.round(-0.5) is', Math.round(-0.5), 'and Object.is(-0, 0) is', Object.is(Math.round(-0.5), 0));

1
2
3
4
5
6
7
8
9
10
11const distance = (a, b) => Math.abs(a - b);

// Money in kobo, so the arithmetic is exact.
const balanceA = -450_00;   // overdrawn by 450 naira
const balanceB = 1_200_00;

console.log('abs(-7)      ->', Math.abs(-7));
console.log('sign(-3)     ->', Math.sign(-3), 'sign(3) ->', Math.sign(3), 'sign(0) ->', Math.sign(0));
console.log('gap in kobo  ->', distance(balanceA, balanceB));
console.log('abs of text  ->', Math.abs('-7'), '<- coerced, quietly');
console.log('abs of rubbish ->', Math.abs('lagos'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14const marks = [67, 45, 92, 58, 92, 12];

const highest = Math.max(...marks);
const lowest = Math.min(...marks);

// Safe for a list of any size, and clearer about the empty case.
const smallest = (list) => list.reduce((lo, n) => (n < lo ? n : lo), Infinity);
const largest = (list) => list.reduce((hi, n) => (n > hi ? n : hi), -Infinity);

console.log('marks   ->', marks);
console.log('highest ->', highest, 'lowest ->', lowest);
console.log('spread and reduce agree:', highest === largest(marks));
console.log('Math.min() with nothing ->', Math.min(), '<- so any real number beats it');
console.log('one bad value ->', Math.max(1, 'lagos', 3));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const clamp = (n, low, high) => Math.min(Math.max(n, low), high);

// The strict version refuses a range that makes no sense.
function clampChecked(n, low, high) {
  if (low > high) throw new RangeError('low ' + low + ' is above high ' + high);
  return clamp(n, low, high);
}

console.log('volume 130 ->', clamp(130, 0, 100));
console.log('volume -20 ->', clamp(-20, 0, 100));
console.log('volume 42  ->', clamp(42, 0, 100));
console.log('bounds swapped by mistake: clamp(5, 10, 0) ->', clamp(5, 10, 0));

let refused = '';
try { clampChecked(5, 10, 0); } catch (err) { refused = err.message; }
console.log('refused:', refused);

1
2
3
4
5
6
7
8
9
10const percentOf = (part, total) => (total === 0 ? 0 : (part / total) * 100);
const percentChange = (from, to) => (from === 0 ? null : ((to - from) / from) * 100);

const round1 = (n) => Number(n.toFixed(1));

console.log('45 of 60      ->', percentOf(45, 60), '%');
console.log('1 of 3        ->', round1(percentOf(1, 3)), '%');
console.log('200 to 250    ->', percentChange(200, 250), '%');
console.log('250 back to 200 ->', percentChange(250, 200), '%  <- not -25');
console.log('unguarded 5 / 0 ->', 5 / 0);

1
2
3
4
5
6
7
8
9
10
11
12const scores = [67, 45, 92, 58, 78];

const mean = (xs) => xs.reduce((sum, n) => sum + n, 0) / xs.length;

// The honest version: no average exists for an empty list, so say so.
const meanOrNull = (xs) => (xs.length === 0 ? null : mean(xs));

console.log('scores  ->', scores);
console.log('mean    ->', mean(scores));
console.log('empty   ->', mean([]), '<- 0 / 0');
console.log('is that NaN equal to itself?', mean([]) === mean([]));
console.log('floating point bites here too:', mean([0.1, 0.2, 0.3]));

1
2
3
4
5
6
7
8
9
10
11
12// Truncating pair: matches the sign of the input, like C.
const divmod = (a, b) => [Math.trunc(a / b), a % b];

// Flooring pair: the remainder is never negative, which is what clock and
// calendar arithmetic wants.
const floorDivMod = (a, b) => [Math.floor(a / b), ((a % b) + b) % b];

console.log('137 minutes ->', divmod(137, 60), '(hours, minutes)');
console.log('-17 / 5 truncating ->', divmod(-17, 5));
console.log('-17 / 5 flooring   ->', floorDivMod(-17, 5));
console.log('-7 % 3 ->', -7 % 3, '  7 % -3 ->', 7 % -3);
console.log('3 days before Wednesday (day 3) ->', floorDivMod(3 - 3 - 3, 7)[1]);

1
2
3
4
5
6
7
8
9
10
11const isEven = (n) => n % 2 === 0;
const isOdd = (n) => Math.abs(n % 2) === 1;          // abs, because of negatives

// The tempting shortcuts, and where each one goes wrong.
const oddNaive = (n) => n % 2 === 1;                 // wrong for negatives
const evenBitwise = (n) => (n & 1) === 0;            // wrong for fractions

const sample = [-4, -3, 0, 2.5, 7, 10];
for (const n of sample) {
  console.log(String(n).padStart(5), 'even', isEven(n), ' odd', isOdd(n));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17const digitCount = (n) => String(Math.abs(Math.trunc(n))).length;

function swapEnds(n) {
  const digits = String(Math.abs(n)).split('');
  const last = digits.length - 1;
  [digits[0], digits[last]] = [digits[last], digits[0]];
  return Number(digits.join('')) * Math.sign(n || 1);
}

// The arithmetic route, for comparison. No strings involved.
const digitCountByLog = (n) => (n === 0 ? 1 : Math.floor(Math.log10(Math.abs(n))) + 1);

console.log('digits in 45678 ->', digitCount(45678));
console.log('digits in -1234 ->', digitCount(-1234));
console.log('swap 1234 ->', swapEnds(1234));
console.log('swap 1000 ->', swapEnds(1000), '<- the leading zero is gone');
console.log('digits in 1e21 ->', digitCount(1e21), '<- String(1e21) is "1e+21"');

1
2
3
4
5
6console.log('0.1 + 0.2 =', 0.1 + 0.2);
console.log('to 17 places:', (0.1 + 0.2).toFixed(17));
console.log('0.3 - 0.1 =', 0.3 - 0.1);
console.log('1.1 * 3   =', 1.1 * 3);
console.log('0.5 + 0.25 =', 0.5 + 0.25, '<- exact: both are powers of two');
console.log('in kobo: 10 + 20 =', 10 + 20);

1
2
3
4
5
6
7
8
9
10
11// Absolute tolerance: fine for numbers near 1, useless for very large ones.
const closeAbs = (a, b, tol = Number.EPSILON * 4) => Math.abs(a - b) <= tol;

// Relative tolerance: the allowance grows with the magnitude of the inputs.
const nearly = (a, b, tol = 1e-9) =>
  Math.abs(a - b) <= tol * Math.max(1, Math.abs(a), Math.abs(b));

console.log('0.1 + 0.2 === 0.3 ?', 0.1 + 0.2 === 0.3);
console.log('nearly(0.1 + 0.2, 0.3) ?', nearly(0.1 + 0.2, 0.3));
console.log('EPSILON is', Number.EPSILON);
console.log('1e16 + 1 === 1e16 ?', 1e16 + 1 === 1e16, '<- the gap is bigger than 1 up there');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const toKobo = (naira) => Math.round(naira * 100);
const showNaira = (kobo) => (kobo / 100).toFixed(2);

const basketNaira = [8.7, 0.1, 1.2];        // should come to exactly 10 naira
const basketKobo = basketNaira.map(toKobo);

const totalNaira = basketNaira.reduce((a, b) => a + b, 0);
const totalKobo = basketKobo.reduce((a, b) => a + b, 0);

console.log('prices in naira ->', basketNaira);
console.log('prices in kobo  ->', basketKobo);
console.log('total in naira  ->', totalNaira, '<- look closely');
console.log('total in kobo   ->', totalKobo, '=', showNaira(totalKobo));
console.log('free delivery over 10 naira?', totalNaira >= 10, '<- the customer disagrees');
console.log('trunc instead of round ->', Math.trunc(4.35 * 100), '<- a kobo lost');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const RATE = 0.075;

const vatOn = (kobo) => Math.round(kobo * RATE);
const grossOf = (kobo) => kobo + vatOn(kobo);
const netFromGross = (gross) => Math.round(gross / (1 + RATE));

const lines = [1000, 1000, 1000];      // three items at 10 naira

const perLine = lines.reduce((sum, k) => sum + vatOn(k), 0);
const onTotal = vatOn(lines.reduce((a, b) => a + b, 0));

console.log('VAT on 2,500 naira ->', vatOn(250000), 'kobo');
console.log('gross              ->', grossOf(250000), 'kobo');
console.log('back to net        ->', netFromGross(268750), 'kobo');
console.log('VAT per line', perLine, 'vs VAT on the total', onTotal);

1
2
3
4
5
6
7
8
9
10
11
12const discount = (kobo, percent) => Math.round((kobo * percent) / 100);
const afterDiscount = (kobo, percent) => kobo - discount(kobo, percent);

const price = 1_000_000;               // 10,000 naira

const twenty = afterDiscount(price, 20);
const tenTwice = afterDiscount(afterDiscount(price, 10), 10);

console.log('20% off      ->', twenty, 'kobo');
console.log('10% then 10% ->', tenTwice, 'kobo  <- not the same');
console.log('difference   ->', tenTwice - twenty, 'kobo');
console.log('order does not matter:', afterDiscount(afterDiscount(price, 10), 20), afterDiscount(afterDiscount(price, 20), 10));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const principal = 100_000_00;          // 100,000 naira in kobo
const rate = 0.1;                      // 10% a year

const simpleInterest = (kobo, r, years) => Math.round(kobo * r * years);

const compoundInterest = (kobo, r, years, perYear = 1) => {
  const periods = years * perYear;
  const balance = kobo * (1 + r / perYear) ** periods;
  return Math.round(balance) - kobo;
};

console.log('simple, 3 years   ->', simpleInterest(principal, rate, 3), 'kobo');
console.log('compound, 3 years ->', compoundInterest(principal, rate, 3), 'kobo');
console.log('compound monthly  ->', compoundInterest(principal, rate, 3, 12), 'kobo');
console.log('one year, both    ->', simpleInterest(principal, rate, 1), compoundInterest(principal, rate, 1));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const bmi = (kg, metres) => kg / metres ** 2;

const band = (value) =>
  value < 18.5 ? 'underweight'
  : value < 25 ? 'normal'
  : value < 30 ? 'overweight'
  : 'obese';

// A height above 3 is centimetres, whatever the label on the field said.
const bmiForgiving = (kg, height) => bmi(kg, height > 3 ? height / 100 : height);

console.log('70kg at 1.75m ->', bmi(70, 1.75).toFixed(1), band(bmi(70, 1.75)));
console.log('50kg at 1.75m ->', bmi(50, 1.75).toFixed(1), band(bmi(50, 1.75)));
console.log('in centimetres by mistake ->', bmi(70, 175).toFixed(5));
console.log('forgiving version ->', bmiForgiving(70, 175).toFixed(1));

1
2
3
4
5
6
7
8
9
10const litresPer100 = (litres, km) => (litres / km) * 100;
const kmPerLitre = (litres, km) => km / litres;

const trip = { km: 500, litres: 45 };
const round2 = (n) => Number(n.toFixed(2));

console.log('litres/100km ->', litresPer100(trip.litres, trip.km));
console.log('km/litre     ->', round2(kmPerLitre(trip.litres, trip.km)));
console.log('cost at 900 naira a litre ->', trip.litres * 900_00, 'kobo');
console.log('zero distance ->', litresPer100(45, 0));

1
2
3
4
5
6
7
8
9
10
11const KM_PER_MILE = 1.609344;          // exact, by definition

const toMiles = (km) => km / KM_PER_MILE;
const toKm = (miles) => miles * KM_PER_MILE;

const round2 = (n) => Number(n.toFixed(2));

console.log('100 km ->', round2(toMiles(100)), 'miles');
console.log('Lagos to Ibadan, 128 km ->', round2(toMiles(128)), 'miles');
console.log('a marathon, 26.2 miles ->', round2(toKm(26.2)), 'km');
console.log('rough factor 1.6 would say', round2(100 / 1.6), 'miles');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const KG_PER_LB = 0.45359237;          // exact, by definition
const LB_PER_STONE = 14;

const toPounds = (kg) => kg / KG_PER_LB;
const toKg = (lb) => lb * KG_PER_LB;

function toStonesAndPounds(kg) {
  const totalLb = toPounds(kg);
  const stones = Math.floor(totalLb / LB_PER_STONE);
  return { stones, pounds: Number((totalLb % LB_PER_STONE).toFixed(1)) };
}

const round2 = (n) => Number(n.toFixed(2));

console.log('70 kg ->', round2(toPounds(70)), 'lb');
console.log('70 kg ->', toStonesAndPounds(70));
console.log('a 50kg bag of rice ->', round2(toPounds(50)), 'lb');
console.log('154 lb back to kg  ->', round2(toKg(154)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21const BINARY = ['B', 'KB', 'MB', 'GB', 'TB'];

function human(bytes, step = 1024, units = BINARY) {
  if (bytes < step) return bytes + ' ' + units[0];
  let value = bytes;
  let unit = 0;
  while (value >= step && unit < units.length - 1) {
    value /= step;
    unit++;
  }
  return Number(value.toFixed(1)) + ' ' + units[unit];
}

const DECIMAL = ['B', 'kB', 'MB', 'GB', 'TB'];
const humanDecimal = (bytes) => human(bytes, 1000, DECIMAL);

console.log('0          ->', human(0));
console.log('1023       ->', human(1023));
console.log('1024       ->', human(1024));
console.log('1536       ->', human(1536));
console.log('1e9        ->', human(1e9), 'but the box says', humanDecimal(1e9));

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// Largest first, with the six subtractive pairs sitting in their right places.
const NUMERALS = [
  [1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'],
  [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'],
  [10, 'X'], [9, 'IX'], [5, 'V'], [4, 'IV'], [1, 'I'],
];

function toRoman(n) {
  if (!Number.isInteger(n) || n < 1 || n > 3999) {
    throw new RangeError('Roman numerals cover 1 to 3999, not ' + n);
  }
  let left = n;
  let out = '';
  for (const [value, symbol] of NUMERALS) {
    while (left >= value) {
      out += symbol;
      left -= value;
    }
  }
  return out;
}

for (const n of [4, 9, 14, 40, 1994, 2026]) console.log(String(n).padStart(4), toRoman(n));

let refused = '';
try { toRoman(0); } catch (err) { refused = err.message; }
console.log('zero:', refused);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const VALUE = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000 };

function fromRoman(text) {
  const letters = text.toUpperCase().split('');
  if (letters.some((ch) => !(ch in VALUE))) throw new TypeError('not a numeral: ' + text);

  let total = 0;
  for (let i = 0; i < letters.length; i++) {
    const here = VALUE[letters[i]];
    const next = VALUE[letters[i + 1]] ?? 0;
    total += here < next ? -here : here;   // smaller before larger means subtract
  }
  return total;
}

for (const r of ['IV', 'IX', 'XL', 'MCMXCIV', 'MMXXVI']) console.log(r.padEnd(9), fromRoman(r));

// Same table as exercise 72, so a round trip can be checked.
const NUMERALS = [[1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'], [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'], [10, 'X'], [9, 'IX'], [5, 'V'], [4, 'IV'], [1, 'I']];
const toRoman = (n) => NUMERALS.reduce((out, [v, s]) => { while (n >= v) { out += s; n -= v; } return out; }, '');

const roundTrips = Array.from({ length: 3999 }, (_, i) => i + 1).every((n) => fromRoman(toRoman(n)) === n);
console.log('every number from 1 to 3999 round-trips:', roundTrips);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const SIGN = '\u20a6';                  // the naira sign

function formatKobo(kobo) {
  if (!Number.isInteger(kobo)) throw new TypeError('kobo must be a whole number');

  const negative = kobo < 0;
  const size = Math.abs(kobo);
  const naira = Math.trunc(size / 100);
  const rest = size % 100;

  const grouped = naira.toLocaleString('en-NG');
  return (negative ? '-' : '') + SIGN + grouped + '.' + String(rest).padStart(2, '0');
}

for (const k of [250000, 1, 99, 123456789, -1234500]) console.log(String(k).padStart(10), formatKobo(k));

let refused = '';
try { formatKobo(4.35); } catch (err) { refused = err.message; }
console.log('a fractional kobo:', refused);

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
26const ONES = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
  'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen',
  'eighteen', 'nineteen'];
const TENS = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];

function inWords(n) {
  if (!Number.isInteger(n) || n < 0 || n > 9999) {
    throw new RangeError('this version covers 0 to 9999, not ' + n);
  }
  if (n < 20) return ONES[n];
  if (n < 100) {
    const rest = n % 10;
    return TENS[Math.floor(n / 10)] + (rest ? '-' + ONES[rest] : '');
  }
  if (n < 1000) {
    const rest = n % 100;
    return ONES[Math.floor(n / 100)] + ' hundred' + (rest ? ' and ' + inWords(rest) : '');
  }
  const rest = n % 1000;
  const thousands = inWords(Math.floor(n / 1000)) + ' thousand';
  if (rest === 0) return thousands;
  // "and" joins a remainder under a hundred; above that it reads as a list.
  return thousands + (rest < 100 ? ' and ' : ' ') + inWords(rest);
}

for (const n of [0, 13, 42, 105, 1005, 2026, 9999]) console.log(String(n).padStart(4), inWords(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
28const fares = [200_00, 350_00, 150_00];        // kobo, three stops

// for...of hands you each value.
const values = [];
for (const fare of fares) values.push(fare);

// for...in hands you each KEY, and an array's keys are strings.
const keys = [];
for (const i in fares) keys.push(i);

// Which is why this looks like addition and is not.
let joined = '';
for (const i in fares) joined += i;

// A stray property rides along in for...in, but not in for...of.
const tagged = [1, 2, 3];
tagged.note = 'from the depot';
const taggedKeys = [];
for (const key in tagged) taggedKeys.push(key);
const taggedValues = [];
for (const value of tagged) taggedValues.push(value);

// entries() is the one that gives both, with a number index.
const pairs = [];
for (const [i, fare] of fares.entries()) pairs.push(i + ':' + fare);

console.log('for...in keys:', keys, 'first is a', typeof keys[0]);
console.log('with a stray property:', taggedKeys);

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
35function ticketsWhile(count) {
  const printed = [];
  let n = 0;
  while (n < count) {
    printed.push('T' + (n + 1));
    n++;
  }
  return printed;
}

function ticketsDoWhile(count) {
  const printed = [];
  let n = 0;
  do {
    printed.push('T' + (n + 1));
    n++;
  } while (n < count);
  return printed;
}

// Halve an amount until it is under a limit. The body has to run once, which is
// the case do...while is for -- and also the case where it bites.
function halveUntilUnder(kobo, limit) {
  let value = kobo;
  let rounds = 0;
  do {
    value = Math.floor(value / 2);
    rounds++;
  } while (value > limit);
  return { value, rounds };
}

console.log('while, 0 tickets:', ticketsWhile(0));
console.log('do...while, 0 tickets:', ticketsDoWhile(0));
console.log('already under the limit:', halveUntilUnder(5000, 20000));

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
54const plates = ['LSD-114-AB', 'KJA-902-XY', 'BDG-771-KM', 'KJA-330-ZZ'];

// break stops the loop dead. The counter proves it.
function firstFrom(list, prefix) {
  let found = null;
  let looked = 0;
  for (const plate of list) {
    looked++;
    if (plate.startsWith(prefix)) {
      found = plate;
      break;
    }
  }
  return { found, looked };
}

// continue abandons this turn only.
function without(list, prefix) {
  const kept = [];
  for (const plate of list) {
    if (plate.startsWith(prefix)) continue;
    kept.push(plate);
  }
  return kept;
}

// In a for loop, continue still runs the i++ in the header.
let oddSum = 0;
for (let i = 1; i <= 10; i++) {
  if (i % 2 === 0) continue;
  oddSum += i;
}

// In a while loop the increment is yours, so it must come BEFORE the continue.
function oddsWhile(limit) {
  const odds = [];
  let i = 0;
  while (i < limit) {
    i++;                        // first, always, or this never finishes
    if (i % 2 === 0) continue;
    odds.push(i);
  }
  return odds;
}

// forEach cannot be broken out of. return here behaves like continue.
let calls = 0;
plates.forEach((plate) => {
  calls++;
  if (plate.startsWith('KJA')) return;
});

console.log('break:', firstFrom(plates, 'KJA'));
console.log('forEach visited', calls, 'plates');

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
54
55
56
57const ROWS = ['A', 'B', 'C'];
const PER_ROW = 4;

function chartOf(rows, perRow) {
  const out = [];
  for (const row of rows) {
    const line = [];
    for (let seat = 1; seat <= perRow; seat++) line.push(row + seat);
    out.push(line);
  }
  return out;
}

const chart = chartOf(ROWS, PER_ROW);

// The body of a nested loop runs rows x seats times. Worth knowing before the
// numbers get large.
let visits = 0;
for (const row of ROWS) {
  for (let seat = 1; seat <= PER_ROW; seat++) visits++;
}

// A labelled break leaves BOTH loops.
function firstFree(taken) {
  let found = null;
  search:
  for (const row of ROWS) {
    for (let seat = 1; seat <= PER_ROW; seat++) {
      const label = row + seat;
      if (!taken.includes(label)) {
        found = label;
        break search;
      }
    }
  }
  return found;
}

// The same walk with a plain break: it only ends the row, so the outer loop
// carries on and overwrites the answer with a later row's first free seat.
function firstFreeBuggy(taken) {
  let found = null;
  for (const row of ROWS) {
    for (let seat = 1; seat <= PER_ROW; seat++) {
      const label = row + seat;
      if (!taken.includes(label)) {
        found = label;
        break;
      }
    }
  }
  return found;
}

const taken = ['A1', 'A2', 'A3', 'A4', 'B1'];
console.log(chart.map((row) => row.join(' ')).join('\n'));
console.log('labelled break:', firstFree(taken), '| plain break:', firstFreeBuggy(taken));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23function leftTriangle(rows) {
  const lines = [];
  for (let i = 1; i <= rows; i++) lines.push('*'.repeat(i));
  return lines;
}

function pyramid(rows) {
  const lines = [];
  for (let i = 1; i <= rows; i++) {
    lines.push(' '.repeat(rows - i) + '*'.repeat(2 * i - 1));
  }
  return lines;
}

let refused = false;
try {
  '*'.repeat(-1);
} catch {
  refused = true;
}

console.log(leftTriangle(4).join('\n'));
console.log(pyramid(4).join('\n'));