Strings

const s = "hello";
s.length; // 5: UTF-16 code units
s.includes("ell"); // true
s.repeat(2); // "hellohello"
s < "help"; // true: compares code units
String(42); // "42"
["a", "b", "c"].join(", "); // "a, b, c"
[1, 2].join(", "); // "1, 2": join converts items
 
const chars = [...s]; // ["h", "e", "l", "l", "o"]
chars[0] = "j";
chars.join(""); // "jello"
 
// @ts-expect-error: TS2542, strings are read-only
s[0] = "j"; // TypeError at runtime in a module

const esc = (s: string) =>
  s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
 
function html(
  strings: TemplateStringsArray,
  ...values: unknown[]
): string {
  return strings.reduce((out, s, i) => {
    const v =
      i < values.length ? esc(String(values[i])) : "";
    return out + s + v;
  }, "");
}
 
html`<p>${"<b>"}</p>`; // "<p>&#60;b&#62;</p>"
String.raw`C:\new\t${1 + 1}`; // "C:\\new\\t2"

const s = "leetcode";
const counts = new Int32Array(26);
for (let i = 0; i < s.length; i++) {
  counts[s.charCodeAt(i) - 97]++;
}
 
let firstUnique = "";
for (const ch of s) {
  if (counts[ch.charCodeAt(0) - 97] === 1) {
    firstUnique = ch;
    break;
  }
}
firstUnique; // "l"
 
const present = [...counts.keys()]
  .filter((k) => counts[k] > 0)
  .map((k) => String.fromCharCode(97 + k));
// ["c", "d", "e", "l", "o", "t"]
 
const caesar = (s: string, k: number) =>
  [...s]
    .map((c) => ((c.charCodeAt(0) - 97 + k) % 26) + 97)
    .map((code) => String.fromCharCode(code))
    .join("");
caesar("xyz", 3); // "abc"

const s = "a😀b";
s.length; // 4: the emoji is two code units
s[1]; // "\ud83d": half of a surrogate pair
s.charCodeAt(1); // 55357
s.codePointAt(1); // 128512
s.codePointAt(2); // 56832: the low half alone
[...s]; // ["a", "😀", "b"]
s.slice(0, 2).isWellFormed(); // false

const s = "python";
s.slice(1, 4); // "yth"
s.slice(-3); // "hon"
s.slice(4, 1); // ""
s.substring(4, 1); // "yth"
s.substring(-3); // "python"
s.slice(10); // ""
s[10]; // undefined
[...s].filter((_, i) => i % 2 === 0).join(""); // "pto"

const s = "hello world";
s.startsWith("world", 6); // true: no slice built
s.endsWith("lo", 5); // true: looks at s.slice(0, 5)
s.slice(6, 11) === "world"; // true, after building a slice
 
function isPal(s: string, i: number, j: number): boolean {
  while (i < j) {
    if (s.charCodeAt(i) !== s.charCodeAt(j)) return false;
    i++;
    j--;
  }
  return true;
}
isPal("xracecarx", 1, 7); // true

const line = "id, name ,  email";
line.split(",").map((c) => c.trim());
// ["id", "name", "email"]
" a  b ".trim().split(/\s+/); // ["a", "b"]
"a,b,,c".split(","); // ["a", "b", "", "c"]
"".split(","); // [""]
"a😀".split("").length; // 3: code units
"7".padStart(3, "0"); // "007"
"a-b-c".replace("-", "+"); // "a+b-c": first only
"a-b-c".replaceAll("-", "+"); // "a+b+c"
"Straße".toUpperCase(); // "STRASSE": longer
 
const [user, domain = ""] = "ada@example.com".split("@");
domain; // "example.com"
"photo.final.jpg".split(".").at(-1); // "jpg"

"banana".indexOf("an"); // 1
"banana".lastIndexOf("an"); // 3
"banana".indexOf("an", 2); // 3: searching from index 2
"banana".split("ana").length - 1; // 1: non-overlapping
[..."banana".matchAll(/(?=ana)/g)].length; // 2: overlapping
 
["b", "a", "B"].sort(); // ["B", "a", "b"]: code units
["b", "a", "B"].sort((x, y) => x.localeCompare(y));
// ["a", "b", "B"]
 
// < compares code units, not code points: the emoji's
// high surrogate 0xd83d sorts before U+FF5E
"😀" < "\uff5e"; // true

const collator = new Intl.Collator("en", {
  numeric: true, // "file2" before "file10"
  sensitivity: "base", // ignore case and accents
});
["file10", "File2", "file1"].sort(collator.compare);
// ["file1", "File2", "file10"]
collator.compare("Résumé", "resume"); // 0
 
// Alien dictionary: is words sorted in this alphabet?
const order = "hlabcdefgijkmnopqrstuvwxyz";
const rank = new Int32Array(26);
for (let i = 0; i < 26; i++) {
  rank[order.charCodeAt(i) - 97] = i;
}
const alien = (a: string, b: string): number => {
  const n = Math.min(a.length, b.length);
  for (let i = 0; i < n; i++) {
    const d =
      rank[a.charCodeAt(i) - 97] -
      rank[b.charCodeAt(i) - 97];
    if (d !== 0) return d;
  }
  return a.length - b.length;
};
const words = ["hello", "leetcode"];
words.every(
  (w, i) => i === 0 || alien(words[i - 1], w) <= 0,
); // true

let s = "";
for (let i = 0; i < 3; i++) s += `<${i}>`;
s; // "<0><1><2>"
 
const parts: string[] = [];
for (const w of ["a", "b"]) parts.push(w.toUpperCase());
parts.join(""); // "AB"
 
// Remove adjacent duplicates with a stack of characters:
// reading a string after each += flattens it every time
function dedupe(s: string): string {
  const st: string[] = [];
  for (const ch of s) {
    if (st.at(-1) === ch) st.pop();
    else st.push(ch);
  }
  return st.join("");
}
dedupe("abbaca"); // "ca"

function longestUnique(s: string): number {
  const last = new Map<string, number>();
  let lo = 0;
  let best = 0;
  for (let i = 0; i < s.length; i++) {
    const ch = s.charAt(i);
    const prev = last.get(ch) ?? -1;
    if (prev >= lo) lo = prev + 1; // jump past the repeat
    last.set(ch, i);
    best = Math.max(best, i - lo + 1);
  }
  return best;
}
longestUnique("abcabcbb"); // 3
 
function groupAnagrams(words: string[]): string[][] {
  const groups = new Map<string, string[]>();
  for (const w of words) {
    const cnt = new Int32Array(26);
    for (let i = 0; i < w.length; i++) {
      cnt[w.charCodeAt(i) - 97]++;
    }
    const key = cnt.join(","); // a string compares by value
    const group = groups.get(key);
    if (group) group.push(w);
    else groups.set(key, [w]);
  }
  return [...groups.values()];
}
groupAnagrams(["eat", "tea", "tan", "ate", "nat"]);
// [["eat", "tea", "ate"], ["tan", "nat"]]
 
function wordBreak(s: string, words: string[]): boolean {
  // ok[i]: s.slice(0, i) splits into words
  const ok = new Uint8Array(s.length + 1);
  ok[0] = 1;
  for (let i = 0; i < s.length; i++) {
    if (!ok[i]) continue;
    for (const w of words) {
      // startsWith at an offset: no slice is built
      if (s.startsWith(w, i)) ok[i + w.length] = 1;
    }
  }
  return ok[s.length] === 1;
}
wordBreak("leetcode", ["leet", "code"]); // true

const date = /(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/d;
const r = date.exec("on 2026-09-25");
r?.groups?.y; // "2026"
r?.indices?.groups?.m; // [8, 10]
 
const log = "GET /a 200, POST /b 404";
log.match(/\d{3}/g); // ["200", "404"]
const hits = [...log.matchAll(/([A-Z]+) (\S+) (\d+)/g)];
hits.map((m) => `${m[1]}:${m.index}`);
// ["GET:0", "POST:12"]
 
/\d+(?=px)/.exec("12px 3em")?.[0]; // "12"
/(?<=\$)\d+/.exec("cost $40")?.[0]; // "40"
/[\p{L}--[a-z]]/v.test("B"); // true: a letter, not a-z
 
const re = /a/g;
re.test("a"); // true
re.test("a"); // false: lastIndex was 1
 
const safe = RegExp.escape("1+1=2?"); // ES2025
new RegExp(`^${safe}$`).test("1+1=2?"); // true

"2026-09-25".replace(/(\d+)-(\d+)-(\d+)/, "$3/$2/$1");
// "25/09/2026"
"price: $5".replace("$5", "$$10"); // "price: $10"
 
// A function replacer gets (match, ...groups, offset, input)
"a-b_c d".replace(/[-_ ](\w)/g, (_, c: string) =>
  c.toUpperCase(),
); // "aBCD"

const seg = new Intl.Segmenter("en", {
  granularity: "grapheme", // also "word", "sentence"
});
const graphemes = (s: string) =>
  Array.from(seg.segment(s), (x) => x.segment);
 
graphemes("👨‍👩‍👧!").length; // 2
const reverse = (s: string) =>
  graphemes(s).toReversed().join(""); // emoji-safe
reverse("a👍🏽b") === "b👍🏽a"; // true
 
const words = Array.from(
  new Intl.Segmenter("en", { granularity: "word" })
    .segment("Hi, you!"),
)
  .filter((x) => x.isWordLike)
  .map((x) => x.segment);
// ["Hi", "you"]
 
const nfc: string = "\u00e9";
const nfd: string = "e\u0301";
nfc === nfd; // false: same look, different code units
nfc === nfd.normalize("NFC"); // true
"a\ud83d".isWellFormed(); // false: a lone surrogate

const usd = new Intl.NumberFormat("en-US", {
  style: "currency",
  currency: "USD",
});
usd.format(1234.5); // "$1,234.50"
 
const compact = new Intl.NumberFormat("en", {
  notation: "compact",
});
compact.format(1_234_567); // "1.2M"
 
const d = new Date(Date.UTC(2026, 8, 25, 14, 30));
new Intl.DateTimeFormat("en-US", {
  dateStyle: "medium",
  timeStyle: "short",
  timeZone: "America/New_York",
}).format(d); // "Sep 25, 2026, 10:30 AM"
 
const rtf = new Intl.RelativeTimeFormat("en", {
  numeric: "auto",
});
rtf.format(-1, "day"); // "yesterday"
 
new Intl.ListFormat("en", { type: "disjunction" })
  .format(["tea", "coffee"]); // "tea or coffee"
 
const ordinal = new Intl.PluralRules("en", {
  type: "ordinal",
});
const suffix: Record<Intl.LDMLPluralRule, string> = {
  zero: "th", one: "st", two: "nd",
  few: "rd", many: "th", other: "th",
};
const nth = (n: number) =>
  `${n}${suffix[ordinal.select(n)]}`;
[1, 22, 11].map(nth); // ["1st", "22nd", "11th"]

type Method = "GET" | "POST";
let m: Method = "GET";
 
// @ts-expect-error: "PUT" is not a Method
m = "PUT";
 
const verb = "GET"; // type "GET": const infers the literal
let v2 = "GET"; // type string: let widens
 
type Px = `${number}px`;
const w: Px = "12px";
 
// @ts-expect-error: "12em" does not match `${number}px`
const bad: Px = "12em";
 
type UiEvent = "click" | "focus";
type Handler = `on${Capitalize<UiEvent>}`;
// "onClick" | "onFocus"
 
type Axis = "x" | "y";
type Prop = `${Axis}${"Min" | "Max"}`;
// "xMin" | "xMax" | "yMin" | "yMax"

type Param<S extends string> =
  S extends `${string}:${infer P}/${infer Rest}`
    ? P | Param<`/${Rest}`>
    : S extends `${string}:${infer P}`
      ? P
      : never;
 
type P = Param<"/users/:id/posts/:postId">;
// "id" | "postId"
 
type Getters<T> = {
  [K in keyof T & string as `get${Capitalize<K>}`]:
    () => T[K];
};
type G = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

const s = "abc";
const a = s[5]; // string | undefined with the flag
const b = s.charAt(5); // always string: ""
const c = s.charCodeAt(5); // always number: NaN
[a, b, c]; // [undefined, "", NaN]

type Email = string & { readonly __brand: "Email" };
 
function toEmail(s: string): Email {
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s)) {
    throw new Error(`Invalid email: ${s}`);
  }
  return s as Email;
}
 
function send(to: Email): string {
  return to.toLowerCase(); // string methods still work
}
 
send(toEmail("Ada@example.com")); // "ada@example.com"
// @ts-expect-error: a plain string is not an Email
send("ada@example.com");

const isAlnum = (c: number) =>
  (c >= 48 && c <= 57) || // 0-9
  (c >= 65 && c <= 90) || // A-Z
  (c >= 97 && c <= 122); // a-z
const lower = (c: number) =>
  c >= 65 && c <= 90 ? c + 32 : c; // A-Z to a-z
 
function isPalindrome(s: string): boolean {
  let i = 0;
  let j = s.length - 1;
  while (i < j) {
    const a = s.charCodeAt(i);
    const b = s.charCodeAt(j);
    if (!isAlnum(a)) i++;
    else if (!isAlnum(b)) j--;
    else if (lower(a) !== lower(b)) return false;
    else {
      i++;
      j--;
    }
  }
  return true;
}
 
function longestPalindrome(s: string): string {
  let bestLo = 0;
  let bestHi = 0; // [bestLo, bestHi) is the best so far
  for (let center = 0; center < 2 * s.length - 1; center++) {
    let lo = center >> 1;
    let hi = lo + (center & 1); // odd length: hi === lo
    while (lo >= 0 && hi < s.length && s[lo] === s[hi]) {
      lo--;
      hi++;
    }
    if (hi - lo - 1 > bestHi - bestLo) {
      bestLo = lo + 1;
      bestHi = hi;
    }
  }
  return s.slice(bestLo, bestHi);
}
 
isPalindrome("A man, a plan, a canal: Panama"); // true
longestPalindrome("babad"); // "bab"
longestPalindrome("cbbd"); // "bb"

function isAnagram(a: string, b: string): boolean {
  if (a.length !== b.length) return false;
  const cnt = new Int32Array(26);
  for (let i = 0; i < a.length; i++) {
    cnt[a.charCodeAt(i) - 97]++;
    cnt[b.charCodeAt(i) - 97]--;
  }
  return cnt.every((x) => x === 0);
}
 
function anagramStarts(s: string, p: string): number[] {
  const k = p.length;
  const diff = new Int32Array(26); // window count - p count
  let off = 0; // slots where diff is not 0
  const bump = (code: number, by: number) => {
    const slot = code - 97;
    if (diff[slot] === 0) off++;
    diff[slot] += by;
    if (diff[slot] === 0) off--;
  };
  for (let i = 0; i < k; i++) bump(p.charCodeAt(i), -1);
  const out: number[] = [];
  for (let i = 0; i < s.length; i++) {
    bump(s.charCodeAt(i), 1); // entering the window
    if (i >= k) bump(s.charCodeAt(i - k), -1); // leaving
    if (i >= k - 1 && off === 0) out.push(i - k + 1);
  }
  return out;
}
 
isAnagram("listen", "silent"); // true
anagramStarts("cbaebabacd", "abc"); // [0, 6]

function minWindow(s: string, t: string): string {
  const need = new Map<string, number>();
  for (const ch of t) need.set(ch, (need.get(ch) ?? 0) + 1);
  let missing = t.length; // characters still to cover
  let bestLo = 0;
  let bestLen = Infinity;
  let lo = 0;
  for (let hi = 0; hi < s.length; hi++) {
    const ch = s.charAt(hi);
    const n = need.get(ch);
    if (n !== undefined) {
      if (n > 0) missing--;
      need.set(ch, n - 1); // negative: a surplus
    }
    while (missing === 0) {
      if (hi - lo + 1 < bestLen) {
        bestLo = lo;
        bestLen = hi - lo + 1;
      }
      const out = s.charAt(lo++);
      const m = need.get(out);
      if (m !== undefined) {
        need.set(out, m + 1);
        if (m + 1 > 0) missing++;
      }
    }
  }
  return bestLen === Infinity
    ? ""
    : s.slice(bestLo, bestLo + bestLen);
}
 
minWindow("ADOBECODEBANC", "ABC"); // "BANC"
minWindow("a", "aa"); // ""

function isSubsequence(s: string, t: string): boolean {
  let i = 0;
  for (let j = 0; j < t.length && i < s.length; j++) {
    if (s.charCodeAt(i) === t.charCodeAt(j)) i++;
  }
  return i === s.length;
}
 
isSubsequence("ace", "abcde"); // true
isSubsequence("aec", "abcde"); // false

function commonPrefix(words: string[]): string {
  if (words.length === 0) return "";
  let lo = words[0];
  let hi = words[0];
  for (const w of words) {
    if (w < lo) lo = w;
    if (w > hi) hi = w;
  }
  let i = 0;
  while (i < lo.length && lo[i] === hi[i]) i++;
  return lo.slice(0, i);
}
 
commonPrefix(["flower", "flow", "flight"]); // "fl"
commonPrefix(["dog", "racecar"]); // ""

function prefixFunction(p: string): number[] {
  const pi = new Array<number>(p.length).fill(0);
  let k = 0;
  for (let i = 1; i < p.length; i++) {
    // on a mismatch, fall back to a shorter border
    while (k > 0 && p[i] !== p[k]) k = pi[k - 1];
    if (p[i] === p[k]) k++;
    pi[i] = k;
  }
  return pi;
}
 
function findAll(text: string, p: string): number[] {
  if (p === "") {
    return [...Array(text.length + 1).keys()];
  }
  const pi = prefixFunction(p);
  const out: number[] = [];
  let k = 0;
  for (let i = 0; i < text.length; i++) {
    while (k > 0 && text[i] !== p[k]) k = pi[k - 1];
    if (text[i] === p[k]) k++;
    if (k === p.length) {
      out.push(i - k + 1);
      k = pi[k - 1]; // keep going: overlaps count
    }
  }
  return out;
}
 
prefixFunction("abab"); // [0, 0, 1, 2]
prefixFunction("ababaca"); // [0, 0, 1, 2, 3, 0, 1]
findAll("aaaa", "aa"); // [0, 1, 2]

function repeated(s: string, k: number): string[] {
  if (k <= 0 || k > s.length) return [];
  // Every product stays below 2 ** 53, so it stays exact
  const B = 131;
  const M = 1_000_000_007;
  let top = 1; // B ** (k - 1) % M: the oldest char's weight
  for (let i = 1; i < k; i++) top = (top * B) % M;
  const seen = new Map<number, number[]>(); // hash -> starts
  const out = new Set<string>();
  let h = 0;
  for (let i = 0; i < s.length; i++) {
    if (i >= k) {
      const old = (s.charCodeAt(i - k) * top) % M;
      h = (h - old + M) % M; // drop s[i - k]
    }
    h = (h * B + s.charCodeAt(i)) % M;
    if (i < k - 1) continue;
    const start = i - k + 1;
    const bucket = seen.get(h);
    if (bucket === undefined) {
      seen.set(h, [start]);
      continue;
    }
    const w = s.slice(start, i + 1);
    // compare only on a hash hit, so collisions are harmless
    if (bucket.some((j) => s.startsWith(w, j))) out.add(w);
    else bucket.push(start);
  }
  return [...out];
}
 
repeated("AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT", 10);
// ["AAAAACCCCC", "CCCCCAAAAA"]
 
const M = 1_000_000_007;
Number.isSafeInteger((M - 1) * 131 + 65535); // true
Number.isSafeInteger((2 ** 61 - 2) * 131); // false
2 ** 53 + 1 === 2 ** 53; // true: rounded away