字符串规则模拟

import sys

lines = sys.stdin.read().split("\n")
n, q, m = map(int, lines[0].split())
records = lines[1:1 + n]                 # 当前数据集：保持先后顺序的列表
rules = lines[1 + n:1 + n + q]           # q 个规则名，按输入顺序执行（q 可以是 0）

for rule in rules:
    if rule == "dedup":                  # 按「当前」字符串值去重，保留首次出现
        seen = set()
        kept = []
        for r in records:
            if r not in seen:
                seen.add(r)
                kept.append(r)
        records = kept
    elif rule == "dropna":               # 恰好等于 NULL 或 -（区分大小写）才删
        records = [r for r in records if r != "NULL" and r != "-"]
    elif rule == "short":                # 长度小于 3 才删
        records = [r for r in records if len(r) >= 3]
    elif rule == "lower":                # 只改大写字母，其他字符不变
        records = [r.lower() for r in records]

out = [str(len(records))] + records[:m]  # 第一行条数，再输出前 min(r, m) 条
print("\n".join(out))

自测用例：题面两个样例，以及第 09 节练习 1、2 的输入。n 到 10⁵、q 到 10，每条规则整表扫一遍，总量 10⁶ 级别，按量级估算在 2.5 秒时限内；实际耗时以判题结果为准。

import sys

k = int(sys.stdin.readline())
s = sys.stdin.readline().rstrip("\n")

words = []                # 切出的命令字
cur = []                  # 当前正在累积的命令字（按字符收集）
inq = False               # 是否在一对双引号之内
started = False           # 当前命令字是否已经开始（用来区分「空命令字」和「还没有命令字」）
for ch in s:
    if ch == '"':
        inq = not inq     # 引号翻转状态；引号本身保留在命令字里
        cur.append(ch)
        started = True
    elif ch == "_" and not inq:
        if started:       # 引号外的下划线是分隔符：收下当前命令字
            words.append("".join(cur))
            cur = []
            started = False
        # 连续的下划线只算一个分隔：没有开始的命令字就什么都不做
    else:
        cur.append(ch)
        started = True
if started:               # 收尾：最后一个命令字还留在 cur 里
    words.append("".join(cur))

if k >= len(words):
    print("ERROR")
else:
    words[k] = "******"
    print("_".join(words))

自测用例：题面两个样例、第 05 节表里 K=1/4/5/6 的四组变式。题目页参考题解用「遇下划线就新开一个空串、最后过滤空串」的写法，结果相同。started 变量区分「空命令字」与「还没有命令字」：两个紧挨的引号让它为真，所以空命令字被收下；连续下划线之间它为假，所以不会收下多余的空串。

import sys

s = sys.stdin.readline().rstrip("\n")
out = []                  # 逐字符构建结果，最后一次拼接
depth = 0                 # 方括号嵌套深度：大于 0 表示在方括号内
for i, ch in enumerate(s):
    if ch == "_" and depth == 0 and (i == 0 or s[i - 1] != "\\"):
        out.append("(^|$|[,+])")      # 两个例外都不命中，才替换
    else:
        out.append(ch)
        if ch == "[":
            depth += 1
        elif ch == "]":
            depth -= 1
print("".join(out))

自测用例：题面两个示例与上面两个手算例。逐字符构建、用列表收集最后一次拼接（长度到 10⁴ 时在循环里做字符串拼接也能过，但列表拼接是稳妥写法）。

import sys

k = int(sys.stdin.readline())
s = sys.stdin.readline().rstrip("\n")

parts = s.split("-")
first = parts[0]                          # 第一段原样保留
rest = "".join(parts[1:])                 # 其余段拼成一串，再每 K 个字符切组

def convert(group):
    lower = sum(1 for ch in group if ch.islower())
    upper = sum(1 for ch in group if ch.isupper())
    if lower > upper:
        return group.lower()
    if upper > lower:
        return group.upper()
    return group                          # 相等：不转换（第三个分支不能漏）

groups = [convert(rest[i:i + k]) for i in range(0, len(rest), k)]
print("-".join([first] + groups))

自测用例：题面示例，以及第 08 节表里「相等不转换」的反例。convert 里三个分支缺了「相等不转换」就会把 4aB 错改。