Strings

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15let s = 'hello';

// In strict mode, which is every module and every panel here, this throws.
// In an old sloppy-mode script it was ignored in silence, which was worse.
try {
  s[0] = 'H';
} catch (err) {
  console.log(err.name + ':', err.message);
}
console.log('s is unchanged:', s);

s = 'H' + s.slice(1);             // a brand new string
console.log('after rebuilding:', s);

console.log('length:', s.length, '| char at 1:', s[1], '| charAt:', s.charAt(1));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21function buildBad(n) {
  let out = '';
  let charsCopied = 0;
  for (let i = 0; i < n; i++) {
    charsCopied += out.length;     // the whole string is copied each time
    out += 'x';
  }
  return { length: out.length, charsCopied };
}

function buildGood(n) {
  const parts = [];
  for (let i = 0; i < n; i++) parts.push('x');
  return { length: parts.join('').length, charsCopied: n };
}

for (const n of [100, 400, 800]) {
  console.log('n =', String(n).padStart(3),
    '| concat copies:', String(buildBad(n).charsCopied).padStart(7),
    '| join copies:', buildGood(n).charsCopied);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14const text = 'the quick brown fox';

console.log('slice(4, 9):     ', text.slice(4, 9));
console.log('slice(-3):       ', text.slice(-3));
console.log('includes:        ', text.includes('brown'));
console.log('indexOf:         ', text.indexOf('brown'));
console.log('startsWith:      ', text.startsWith('the'));
console.log('split(" "):      ', text.split(' '));
console.log('join back:       ', text.split(' ').join('-'));
console.log('toUpperCase:     ', text.toUpperCase());
console.log('trim:            ', '  padded  '.trim() + '|');
console.log('repeat:          ', 'ab'.repeat(3));
console.log('padStart:        ', '7'.padStart(3, '0'));
console.log('replaceAll:      ', text.replaceAll('o', '0'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17console.log("'a' code:", 'a'.charCodeAt(0), "| 'z' code:", 'z'.charCodeAt(0));
console.log("'A' code:", 'A'.charCodeAt(0), "| '0' code:", '0'.charCodeAt(0));

// The alphabet index trick: 0 for 'a', 25 for 'z'.
const idx = (ch) => ch.charCodeAt(0) - 97;
console.log('index of c:', idx('c'), '| index of z:', idx('z'));

// And back again.
console.log('code 97 is:', String.fromCharCode(97), '| 65 is:', String.fromCharCode(65));

// A 26-slot counter, the standard tool for anagram questions.
function letterCounts(word) {
  const counts = new Array(26).fill(0);
  for (const ch of word) counts[idx(ch)]++;
  return counts;
}
console.log('counts for "banana":', letterCounts('banana').filter(c => c > 0), '(a=3, b=1, n=2)');

1
2
3
4
5
6
7
8
9const isDigit  = (ch) => ch >= '0' && ch <= '9';
const isLower  = (ch) => ch >= 'a' && ch <= 'z';
const isUpper  = (ch) => ch >= 'A' && ch <= 'Z';
const isLetter = (ch) => isLower(ch) || isUpper(ch);
const isAlnum  = (ch) => isLetter(ch) || isDigit(ch);

for (const ch of ['7', 'k', 'K', '!', ' ']) {
  console.log(JSON.stringify(ch), '→ digit:', isDigit(ch), 'letter:', isLetter(ch), 'alnum:', isAlnum(ch));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24// The readable way: normalise, reverse, compare. O(n) time, O(n) space.
function isPalindromeSimple(s) {
  const clean = s.toLowerCase().replace(/[^a-z0-9]/g, '');
  return clean === [...clean].reverse().join('');
}

// The interview way: two pointers, no extra string. O(n) time, O(1) space.
function isPalindromeTwoPointer(s) {
  const ok = (ch) => /[a-z0-9]/.test(ch);
  let i = 0, j = s.length - 1;
  const low = s.toLowerCase();
  while (i < j) {
    while (i < j && !ok(low[i])) i++;
    while (i < j && !ok(low[j])) j--;
    if (low[i] !== low[j]) return false;
    i++; j--;
  }
  return true;
}

for (const s of ['A man, a plan, a canal: Panama', 'race a car', '', '.,']) {
  console.log(JSON.stringify(s.slice(0, 22)).padEnd(26),
    'simple:', isPalindromeSimple(s), '| two-pointer:', isPalindromeTwoPointer(s));
}

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 groupAnagrams(words) {
  const groups = new Map();
  for (const word of words) {
    // Sorted letters is the canonical form: 'eat' and 'tea' both become 'aet'.
    const key = [...word].sort().join('');
    if (!groups.has(key)) groups.set(key, []);
    groups.get(key).push(word);
  }
  return [...groups.values()];
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat']));

// A counting key avoids the sort: O(n * k) instead of O(n * k log k).
function groupAnagramsCounting(words) {
  const groups = new Map();
  for (const word of words) {
    const counts = new Array(26).fill(0);
    for (const ch of word) counts[ch.charCodeAt(0) - 97]++;
    const key = counts.join(',');
    if (!groups.has(key)) groups.set(key, []);
    groups.get(key).push(word);
  }
  return [...groups.values()];
}
console.log(groupAnagramsCounting(['eat', 'tea', 'tan', 'ate', 'nat', 'bat']));

1
2
3
4
5
6
7const emoji = 'a\u{1F600}b';        // a, a grinning face, b

console.log('length says:', emoji.length, 'but there are 3 characters');
console.log('emoji[1] is half a character:', JSON.stringify(emoji[1]));
console.log('spread splits correctly:', [...emoji], '→', [...emoji].length);
console.log('so reverse via spread is safe:', [...emoji].reverse().join(''));
console.log('codePointAt:', emoji.codePointAt(1).toString(16));