文本处理工程：Unicode 分词、区域感知大小写映射与可读性度量

不要断开：
  - 基础字符和组合标记之间（e + ◌́ = é）
  - 区域指示符对之间（🇯 + 🇵 = 🇯🇵）
  - Emoji ZWJ 序列中（👨 + ZWJ + 👩 + ZWJ + 👧 = 👨‍👩‍👧）
  - 韩文字母在音节块内
  - CR 和 LF 之间

要断开：
  - 其他所有字符对之间

// 正确：Intl.Segmenter（符合 UAX #29）
function graphemes(str) {
  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
  return [...segmenter.segment(str)].map(s => s.segment);
}

graphemes("👨‍👩‍👧‍👦")  // ["👨‍👩‍👧‍👦"] — 1 个字位簇
graphemes("café")        // ["c", "a", "f", "é"] — 4 个字位簇（NFC）

// 错误：展开运算符（按码位拆分，非字位簇）
[..."👨‍👩‍👧‍👦"]  // ["👨", "‍", "👩", "‍", "👧", "‍", "👦"] — 7 个码位

const segmenter = new Intl.Segmenter('en', { granularity: 'word' });
const words = [...segmenter.segment("I can't believe it's 3:30pm")]
  .filter(s => s.isWordLike)
  .map(s => s.segment);
// ["I", "can't", "believe", "it's", "3:30pm"]

// CJK：需要基于词典的分词
const zhSegmenter = new Intl.Segmenter('zh', { granularity: 'word' });
const zhWords = [...zhSegmenter.segment("今天天气很好")]
  .filter(s => s.isWordLike)
  .map(s => s.segment);
// ["今天", "天气", "很", "好"]（基于词典）

"Dr. Smith earned $3.5M in Q4. Impressive!"
  → 2 句（不是 4 句，尽管有 4 个句号）

规则：
  - 缩写后不断开（Dr., Mr., U.S. 等）
  - 数字内部不断开（3.14, $1,000.00）
  - 省略号内部不断开（...）
  - 句终标点后跟大写字母时要断开

土耳其规则：
  i → İ（U+0130，带点的拉丁大写 I）
  I → ı（U+0131，无点的拉丁小写 i）

英语规则：
  i → I
  I → i

// JavaScript：区域敏感
"FILE".toLocaleLowerCase('tr')  // "fıle"（无点 i）
"FILE".toLocaleLowerCase('en')  // "file"

// Python：casefold() 是区域无关的
"straße".casefold()  // "strasse"（德语 ß → ss）
"straße".lower()     // "straße"（lower() 保留 ß）

text = "straße"
print(len(text))               # 6
print(len(text.upper()))       # 7（"STRASSE"）
print(len(text.casefold()))    # 7（"strasse"）

1. 正规化为 NFD
2. 应用 case folding（toCasefold 映射）
3. 再次正规化为 NFD（case folding 可能引入可分解字符）
4. 逐码位比较

import unicodedata

def case_insensitive_equal(a, b):
    def normalize(s):
        s = unicodedata.normalize('NFD', s)
        s = s.casefold()
        s = unicodedata.normalize('NFD', s)
        return s
    return normalize(a) == normalize(b)

case_insensitive_equal("straße", "STRASSE")  # True
case_insensitive_equal("file", "FILE")        # True（兼容 casefold）

import re

def split_identifier(name: str) -> list[str]:
    """将标识符拆分为词组件。
    
    处理：camelCase、PascalCase、snake_case、kebab-case、
    SCREAMING_SNAKE、dot.case 以及混合模式如 HTMLParser。
    """
    # 在小写后跟大写之前插入边界
    # 但保持连续大写在一起（HTML → [HTML] 不是 [H,T,M,L]）
    name = re.sub(r'([a-z])([A-Z])', r'\1_\2', name)
    name = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', name)
    
    # 按非字母数字字符拆分
    return [w for w in re.split(r'[_\-.\s/]+', name) if w]

def to_camel(words: list[str]) -> str:
    return words[0].lower() + ''.join(w.capitalize() for w in words[1:])

def to_snake(words: list[str]) -> str:
    return '_'.join(w.lower() for w in words)

def to_kebab(words: list[str]) -> str:
    return '-'.join(w.lower() for w in words)

# 示例：
split_identifier("HTMLParser")      # ["HTML", "Parser"]
split_identifier("getHTTPResponse") # ["get", "HTTP", "Response"]
split_identifier("my-kebab-case")   # ["my", "kebab", "case"]

FKGL = 0.39 × (总词数 / 总句数)
     + 11.8 × (总音节数 / 总词数)
     − 15.59

FRE = 206.835
    − 1.015 × (总词数 / 总句数)
    − 84.6 × (总音节数 / 总词数)

CLI = 0.0588 × L − 0.296 × S − 15.8

其中：
  L = 每 100 个词的平均字符数
  S = 每 100 个词的平均句数

def count_syllables(word: str) -> int:
    word = word.lower().strip()
    if len(word) <= 3:
        return 1
    
    # 移除静音 e
    if word.endswith('e') and not word.endswith('le'):
        word = word[:-1]
    
    # 计数元音组
    vowels = 'aeiouy'
    count = 0
    prev_vowel = False
    for char in word:
        is_vowel = char in vowels
        if is_vowel and not prev_vowel:
            count += 1
        prev_vowel = is_vowel
    
    return max(1, count)

# 英语近似精度：~85%
# 生产使用：CMU 发音词典或语音查找

import unicodedata
import re

def slugify(text: str, max_length: int = 80) -> str:
    # NFKD 分解将重音与基础字符分离
    text = unicodedata.normalize('NFKD', text)
    
    # 移除组合标记（重音、变音符号）
    text = ''.join(c for c in text if not unicodedata.combining(c))
    
    # 音译常见非 ASCII 字符
    transliterations = {
        'ß': 'ss', 'æ': 'ae', 'œ': 'oe', 'ø': 'o',
        'đ': 'd', 'ð': 'd', 'þ': 'th', 'ł': 'l',
    }
    for src, dst in transliterations.items():
        text = text.replace(src, dst)
    
    # 小写
    text = text.lower()
    
    # 将非字母数字替换为连字符
    text = re.sub(r'[^a-z0-9]+', '-', text)
    
    # 合并多个连字符并去除首尾
    text = re.sub(r'-+', '-', text).strip('-')
    
    # 在词边界处截断
    if len(text) > max_length:
        text = text[:max_length].rsplit('-', 1)[0]
    
    return text

slugify("Café au lait — Recipe")   # "cafe-au-lait-recipe"
slugify("Ångström unit ≈ 0.1nm")   # "angstrom-unit-0-1nm"
slugify("C++ für Anfänger")        # "c-fur-anfanger"

"银行" → "yín háng"（银行）或 "yín xíng"（行走）取决于上下文
"长城" → "cháng chéng"（长城）

"東京" → "tōkyō"（地名）—— 但汉字有多种读音
"今日" → "kyō"（今天）或 "konnichi"（今日）取决于上下文

21 → "vingt et un"（阳性）/ "vingt et une"（阴性）

21 → "einundzwanzig"（一又二十，单一复合词）

1 рубль, 2 рубля, 5 рублей（1、2-4、5+ 使用不同名词形式）

1本（ippon）、2本（nihon）、3本（sanbon）—— 量词改变发音

123.45 → "壹佰贰拾叁元肆角伍分"（银行大写）

ONES = ['', 'one', 'two', 'three', 'four', 'five',
        'six', 'seven', 'eight', 'nine', 'ten',
        'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',
        'sixteen', 'seventeen', 'eighteen', 'nineteen']
TENS = ['', '', 'twenty', 'thirty', 'forty',
        'fifty', 'sixty', 'seventy', 'eighty', 'ninety']
SCALES = ['', 'thousand', 'million', 'billion', 'trillion']

def number_to_words(n: int) -> str:
    if n == 0:
        return 'zero'
    if n < 0:
        return 'negative ' + number_to_words(-n)
    
    parts = []
    scale_idx = 0
    
    while n > 0:
        chunk = n % 1000
        if chunk:
            chunk_words = _chunk_to_words(chunk)
            if SCALES[scale_idx]:
                chunk_words += ' ' + SCALES[scale_idx]
            parts.append(chunk_words)
        n //= 1000
        scale_idx += 1
    
    return ' '.join(reversed(parts))

def _chunk_to_words(n: int) -> str:
    """将 1-999 转为文字。"""
    if n >= 100:
        return ONES[n // 100] + ' hundred' + (
            ' ' + _chunk_to_words(n % 100) if n % 100 else '')
    if n >= 20:
        return TENS[n // 10] + ('-' + ONES[n % 10] if n % 10 else '')
    return ONES[n]

import re
from typing import NamedTuple

class TextStats(NamedTuple):
    characters: int
    characters_no_spaces: int
    words: int
    sentences: int
    paragraphs: int
    reading_time_minutes: float

def analyze_text(text: str, locale: str = 'en') -> TextStats:
    characters = len(text)
    characters_no_spaces = len(text.replace(' ', '').replace('\t', '').replace('\n', ''))
    
    # 字数：CJK 字符每个计为一词
    cjk_pattern = re.compile(r'[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]')
    cjk_chars = len(cjk_pattern.findall(text))
    
    # 非 CJK 词：按空格拆分
    non_cjk_text = cjk_pattern.sub(' ', text)
    latin_words = len([w for w in non_cjk_text.split() if w.strip()])
    
    words = latin_words + cjk_chars
    
    # 句子：句终标点后跟空格或结尾
    sentences = len(re.findall(r'[.!?。！？]+(?:\s|$)', text)) or 1
    
    # 段落：被空行分隔的块
    paragraphs = len([p for p in text.split('\n\n') if p.strip()])
    
    # 阅读时间：拉丁 200 wpm，CJK 300 cpm
    reading_time = (latin_words / 200) + (cjk_chars / 300)
    
    return TextStats(
        characters=characters,
        characters_no_spaces=characters_no_spaces,
        words=words,
        sentences=sentences,
        paragraphs=paragraphs,
        reading_time_minutes=round(reading_time, 1)
    )

def deduplicate(lines: list[str], ignore_case: bool = False) -> list[str]:
    seen = set()
    result = []
    for line in lines:
        key = line.casefold() if ignore_case else line
        if key not in seen:
            seen.add(key)
            result.append(line)
    return result

import mmh3
from bitarray import bitarray

class BloomFilter:
    def __init__(self, size: int, num_hashes: int):
        self.size = size
        self.num_hashes = num_hashes
        self.bits = bitarray(size)
        self.bits.setall(0)
    
    def add(self, item: str):
        for i in range(self.num_hashes):
            idx = mmh3.hash(item, i) % self.size
            self.bits[idx] = 1
    
    def might_contain(self, item: str) -> bool:
        return all(
            self.bits[mmh3.hash(item, i) % self.size]
            for i in range(self.num_hashes)
        )

# Unix 一行命令去重（保持顺序）：
awk '!seen[$0]++' input.txt > output.txt

# 基于排序（不保持顺序，但处理巨大文件）：
sort -u input.txt > output.txt