Strings

s = "hello"
len(s)  # 5, counts code points
"ell" in s  # True, substring test
s * 2  # 'hellohello'
s < "help"  # True, compares code points
str(42), repr("x")  # ('42', "'x'")
", ".join(["a", "b", "c"])  # 'a, b, c'
", ".join(map(str, [1, 2]))  # join needs str items
 
chars = list(s)  # ['h', 'e', 'l', 'l', 'o']: mutable
chars[0] = "j"
"".join(chars)  # 'jello'

import string
 
s = "leetcode"
counts = [0] * 26
for ch in s:
    counts[ord(ch) - ord("a")] += 1
first_unique = next(
    (ch for ch in s if counts[ord(ch) - ord("a")] == 1), ""
)  # 'l'
present = [
    chr(ord("a") + i) for i, n in enumerate(counts) if n
]  # ['c', 'd', 'e', 'l', 'o', 't']
string.ascii_lowercase.index("e")  # 4
 
 
def caesar(s: str, k: int) -> str:
    a = ord("a")
    return "".join(chr((ord(c) - a + k) % 26 + a) for c in s)
 
 
caesar("xyz", 3)  # 'abc'

s = "hello world"
s.startswith("world", 6)  # True: no copy of s[6:]
s.endswith("lo", 0, 5)  # True: looks at s[0:5]
s[6:11] == "world"  # True, but builds 'world' first
 
 
def is_pal(s: str, i: int, j: int) -> bool:
    while i < j:  # indexes, not s[i:j] copies
        if s[i] != s[j]:
            return False
        i, j = i + 1, j - 1
    return True
 
 
is_pal("xracecarx", 1, 7)  # True

import re
 
"banana".find("an"), "banana".rfind("an")  # (1, 3)
"banana".find("an", 2)  # 3: searching s[2:]
"banana".count("ana")  # 1: non-overlapping
len(re.findall("(?=ana)", "banana"))  # 2: overlapping
 
order = "hlabcdefgijkmnopqrstuvwxyz"  # an alien alphabet
rank = {ch: i for i, ch in enumerate(order)}
words = ["hello", "leetcode"]
words == sorted(words, key=lambda w: [rank[c] for c in w])
# True
sorted(["b", "a", "B"])  # ['B', 'a', 'b']: code points
sorted(["b", "a", "B"], key=str.casefold)  # ['a', 'b', 'B']
 
a = "hello world"
b = "".join(["hello", " world"])
a == b, a is b  # (True, False): compare with ==

import io
 
parts: list[str] = []
for i in range(3):
    parts.append(f"<{i}>")
"".join(parts)  # '<0><1><2>'
 
buf = io.StringIO()
for word in ["a", "b"]:
    buf.write(word.upper())
buf.getvalue()  # 'AB'
 
", ".join(str(n) for n in range(3))  # '0, 1, 2'

import sys
 
sys.getsizeof("a" * 100)  # 141: 1 byte per char
sys.getsizeof("€" * 100)  # 258: 2 bytes per char
sys.getsizeof("😀" * 100)  # 460: 4 bytes per char
sys.getsizeof("a" * 99 + "😀")  # 460: the widest char wins

from collections import Counter, defaultdict
 
 
def longest_unique(s: str) -> int:
    last: dict[str, int] = {}
    lo = best = 0
    for i, ch in enumerate(s):
        if last.get(ch, -1) >= lo:
            lo = last[ch] + 1  # jump past the repeat
        last[ch] = i
        best = max(best, i - lo + 1)
    return best
 
 
print(longest_unique("abcabcbb"))  # 3
 
 
def anagram_groups(words: list[str]) -> list[list[str]]:
    groups: defaultdict[tuple[int, ...], list[str]]
    groups = defaultdict(list)
    for w in words:
        cnt = [0] * 26
        for ch in w:
            cnt[ord(ch) - ord("a")] += 1
        groups[tuple(cnt)].append(w)
    return list(groups.values())
 
 
print(anagram_groups(["eat", "tea", "tan", "ate", "nat"]))
# [['eat', 'tea', 'ate'], ['tan', 'nat']]
Counter("anagram") == Counter("nagaram")  # True
 
 
def word_break(s: str, words: list[str]) -> bool:
    ok = [True] + [False] * len(s)  # ok[i]: s[:i] splits
    for i in range(len(s)):
        if ok[i]:
            for w in words:
                if s.startswith(w, i):  # no slicing
                    ok[i + len(w)] = True
    return ok[-1]
 
 
print(word_break("leetcode", ["leet", "code"]))  # True

import re
 
LINE = re.compile(
    r"""
    (?P<ts>\d{4}-\d{2}-\d{2}T[\d:]+Z) \s+  # timestamp
    (?P<level>INFO|WARN|ERROR) \s+       # level
    (?P<msg>.*)                          # message
    """,
    re.VERBOSE,
)
 
if m := LINE.match("2026-09-25T10:00:00Z ERROR disk full"):
    print(m["level"], m.group("msg"))  # ERROR disk full
    print(m.groupdict()["ts"], m.span("msg"))
 
print(re.findall(r"(\w)=(\d)", "a=1 b=2"))
# [('a', '1'), ('b', '2')]: tuples of groups
print(re.split(r"[,;]\s*", "a, b;c"))  # ['a', 'b', 'c']
print(re.sub(r"(?P<user>\w+)@", r"\g<user> at ", "bob@x"))
 
prices = "apple 1.50, pear 2.25"
doubled = re.sub(
    r"\d+\.\d+",
    lambda m: f"{float(m[0]) * 2:.2f}",  # fn replacement
    prices,
    flags=re.ASCII,  # count/flags: keyword only
)

from datetime import UTC, datetime
 
name, n, price = "Ada", 3, 1234.5
user = {"name": "ann"}
now = datetime(2026, 9, 25, 14, 30, tzinfo=UTC)
 
print(f"{name} has {n} item{'s' if n != 1 else ''}")
print(f"{user["name"]}")  # same quotes (3.12+)
print(f"{'\n'.join(['a', 'b'])}")  # backslash (3.12+)
print(f"{price:,.2f}")  # 1,234.50
print(f"{now:%Y-%m-%d %H:%M}")  # 2026-09-25 14:30
print(f"{name!r}")  # 'Ada': repr()
print(f"{n=}")  # n=3: self-documenting
print(f"{price = :.1f}")  # price = 1234.5
print(f"{{literal braces}}")  # {literal braces}
width = 8
print(f"[{name:>{width}}]")  # nested spec: [     Ada]
print(f"""{
    n * price  # comments allowed inside
}""")

from html import escape
from string.templatelib import (
    Interpolation,
    Template,
    convert,
)
 
 
def html(t: Template) -> str:
    out: list[str] = []
    for item in t:
        match item:
            case str() as text:
                out.append(text)  # trusted literal
            case Interpolation(value, _, conv, spec):
                v = format(convert(value, conv), spec)
                out.append(escape(v))  # untrusted value
    return "".join(out)
 
 
def sql(t: Template) -> tuple[str, list[object]]:
    query = "?".join(t.strings)
    return query, list(t.values)
 
 
evil = "<script>alert(1)</script>"
print(html(t"<p>Hi {evil}!</p>"))
# <p>Hi &lt;script&gt;alert(1)&lt;/script&gt;!</p>
print(sql(t"SELECT * FROM users WHERE id = {42}"))
# ('SELECT * FROM users WHERE id = ?', [42])

import tempfile
from pathlib import Path
 
data = "héllo €".encode("utf-8")
# b'h\xc3\xa9llo \xe2\x82\xac'
text = data.decode("utf-8")
len("€"), len("€".encode())  # (1, 3)
 
b"\xff".decode("utf-8", errors="replace")  # '�'
"é".encode("ascii", errors="ignore")  # b''
"é".encode("ascii", errors="backslashreplace")  # b'\\xe9'
 
b"ab"[0], list(b"ab")  # (97, [97, 98]): ints
bytes.fromhex("dead").hex(":")  # 'de:ad'
bytearray(b"abc").upper()  # mutable variant
 
with tempfile.TemporaryDirectory() as tmp:
    path = Path(tmp) / "notes.txt"
    path.write_text(text, encoding="utf-8")
    path.read_text(encoding="utf-8") == text  # True

def is_palindrome(s: str) -> bool:
    i, j = 0, len(s) - 1
    while i < j:
        if not s[i].isalnum():
            i += 1
        elif not s[j].isalnum():
            j -= 1
        elif s[i].lower() != s[j].lower():
            return False
        else:
            i, j = i + 1, j - 1
    return True
 
 
def longest_palindrome(s: str) -> str:
    best = (0, 0)  # [lo, hi) of the longest so far
    for center in range(2 * len(s) - 1):
        lo = center // 2
        hi = lo + center % 2  # odd length: hi == lo
        while lo >= 0 and hi < len(s) and s[lo] == s[hi]:
            lo, hi = lo - 1, hi + 1
        if hi - lo - 1 > best[1] - best[0]:
            best = (lo + 1, hi)
    return s[best[0] : best[1]]
 
 
phrase = "A man, a plan, a canal: Panama"
print(is_palindrome(phrase))  # True
print(longest_palindrome("babad"))  # bab

from collections import Counter
 
 
def is_anagram(a: str, b: str) -> bool:
    return len(a) == len(b) and Counter(a) == Counter(b)
 
 
def anagram_starts(s: str, p: str) -> list[int]:
    k, need = len(p), Counter(p)
    have = Counter(s[:k])
    out = [0] if have == need else []
    for i in range(k, len(s)):
        have[s[i]] += 1  # char entering the window
        have[s[i - k]] -= 1  # char leaving it
        if have == need:  # zero counts compare as absent
            out.append(i - k + 1)
    return out
 
 
print(is_anagram("listen", "silent"))  # True
print(anagram_starts("cbaebabacd", "abc"))  # [0, 6]

def is_subsequence(s: str, t: str) -> bool:
    it = iter(t)
    return all(ch in it for ch in s)  # `in` consumes it
 
 
print(is_subsequence("ace", "abcde"))  # True
print(is_subsequence("aec", "abcde"))  # False

import os
 
 
def common_prefix(words: list[str]) -> str:
    if not words:
        return ""
    lo, hi = min(words), max(words)  # the extremes
    i = 0
    while i < len(lo) and lo[i] == hi[i]:
        i += 1
    return lo[:i]
 
 
words = ["flower", "flow", "flight"]
print(common_prefix(words))  # fl
print(os.path.commonprefix(words))  # fl

def prefix_function(p: str) -> list[int]:
    pi = [0] * len(p)
    k = 0
    for i in range(1, len(p)):
        while k and p[i] != p[k]:
            k = pi[k - 1]  # fall back to a shorter border
        if p[i] == p[k]:
            k += 1
        pi[i] = k
    return pi
 
 
def find_all(text: str, p: str) -> list[int]:
    if not p:
        return list(range(len(text) + 1))
    pi = prefix_function(p)
    out: list[int] = []
    k = 0
    for i, ch in enumerate(text):
        while k and ch != p[k]:
            k = pi[k - 1]
        if ch == p[k]:
            k += 1
        if k == len(p):
            out.append(i - k + 1)
            k = pi[k - 1]  # keep going: overlaps count
    return out
 
 
print(prefix_function("abab"))  # [0, 0, 1, 2]
print(find_all("aaaa", "aa"))  # [0, 1, 2]

def repeated(s: str, k: int) -> set[str]:
    """Length-k substrings that occur more than once."""
    if not 0 < k <= len(s):
        return set()
    base, mod = 131, (1 << 61) - 1
    top = pow(base, k - 1, mod)  # weight of the oldest char
    seen: dict[int, list[int]] = {}  # hash -> start indexes
    out: set[str] = set()
    h = 0
    for i, ch in enumerate(s):
        if i >= k:  # drop s[i - k] from the window
            h = (h - ord(s[i - k]) * top) % mod
        h = (h * base + ord(ch)) % mod
        if i < k - 1:
            continue
        start = i - k + 1
        bucket = seen.setdefault(h, [])
        for j in bucket:  # compare only on a hash hit
            if s[j : j + k] == s[start : i + 1]:
                out.add(s[j : j + k])
                break
        else:
            bucket.append(start)
    return out
 
 
dna = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
print(sorted(repeated(dna, 10)))
# ['AAAAACCCCC', 'CCCCCAAAAA']

def decode(s: str) -> str:
    stack: list[tuple[list[str], int]] = []
    cur: list[str] = []
    k = 0
    for ch in s:
        if ch.isdecimal():
            k = k * 10 + int(ch)  # counts can be multi-digit
        elif ch == "[":
            stack.append((cur, k))  # save the outer state
            cur, k = [], 0
        elif ch == "]":
            outer, times = stack.pop()
            outer.append("".join(cur) * times)
            cur = outer
        else:
            cur.append(ch)
    return "".join(cur)
 
 
print(decode("3[a2[c]]"))  # accaccacc
print(decode("2[abc]3[cd]ef"))  # abcabccdcdcdef

import re
import unicodedata
 
 
def slugify(text: str, sep: str = "-") -> str:
    norm = unicodedata.normalize("NFKD", text)
    ascii_only = norm.encode("ascii", "ignore").decode()
    words = re.findall(r"[a-z0-9]+", ascii_only.lower())
    return sep.join(words)
 
 
print(slugify("Crème Brûlée: 10 Tips!"))
# creme-brulee-10-tips

import re
 
_WORDS = re.compile(r"[A-Z]?[a-z0-9]+|[A-Z]+(?![a-z])")
 
 
def words(s: str) -> list[str]:
    return [w.lower() for w in _WORDS.findall(s)]
 
 
def snake(s: str) -> str:
    return "_".join(words(s))
 
 
def kebab(s: str) -> str:
    return "-".join(words(s))
 
 
def camel(s: str) -> str:
    first, *rest = words(s) or [""]
    return first + "".join(w.capitalize() for w in rest)
 
 
print(snake("parseHTTPResponse2"), kebab("user_id"))
# parse_http_response2 user-id
print(camel("created-at_utc"))  # createdAtUtc

def parse_kv(text: str) -> dict[str, str]:
    out: dict[str, str] = {}
    for raw in text.splitlines():
        line = raw.strip()
        if not line or line.startswith("#"):
            continue
        key, sep, value = line.partition("=")
        if not sep:
            raise ValueError(f"no '=' in {raw!r}")
        out[key.strip()] = value.strip().strip("\"'")
    return out
 
 
print(parse_kv('# db\nHOST = localhost\nNAME="app"\n'))
# {'HOST': 'localhost', 'NAME': 'app'}

rows = [("apple", 3, 1.5), ("kiwi", 12, 0.25)]
head = ("item", "qty", "price")
w = max(len(r[0]) for r in [*rows, head])
 
print(f"{head[0]:<{w}}  {head[1]:>4}  {head[2]:>7}")
print(f"{'':-<{w}}  {'':->4}  {'':->7}")
for name, qty, price in rows:
    print(f"{name:<{w}}  {qty:>4}  {price:>7,.2f}")

item    qty    price
-----  ----  -------
apple     3     1.50
kiwi     12     0.25