Pinellia Blog

GNU Screen 仅保留 Ctrl+A Ctrl+D，其余按键透传

Wed, 16 Sep 2026 00:00:00 GMT

GNU Screen 默认使用 Ctrl+A 作为命令前缀。因此，进入 Screen 后，很多以 Ctrl+A 开头的按键序列会被 Screen 截获，例如：

Ctrl+A C：创建窗口
Ctrl+A N：切换到下一个窗口
Ctrl+A K：关闭窗口
Ctrl+A Ctrl+A：切换窗口

这会影响 Screen 内部程序对 Ctrl+A 及其后续按键的使用。

目标是：

仅保留 Ctrl+A Ctrl+D，用于 detach 当前 Screen；
其他按键尽量原样传递给 Screen 内运行的程序；
不修改、不重载、不终止当前已经运行的 Screen 服务进程；
如果现有 Screen 版本能实现，就不额外安装新版本。

环境

验证时使用：

GNU Screen 4.09.00

该版本已经支持所需的 escape、bindkey 和 stuff/输入映射机制，因此不需要在 ~/.local/bin 中安装新版 Screen，也不需要替换系统的 /usr/bin/screen。

核心原理

1. 不能只解除默认按键绑定

一个容易想到的方案是解除 Screen 的默认快捷键，例如：

bind c
bind n
bind k

但这种方式只会让 Screen 不再执行相应命令，并不保证完整的按键序列被传递给内部程序。Screen 已经截获了命令前缀 Ctrl+A，所以单纯 unbind 可能导致按键被吞掉。

2. 将 Screen 自身的命令前缀移走

Screen 的 escape 配置格式是：

escape xy

其中：

x 是 Screen 命令前缀；
y 是用于输入字面命令前缀的 meta 字符；
默认值相当于 Ctrl+A 和 A。

为了不让 Screen 默认截获 Ctrl+A，把 Screen 的内部命令前缀设置为终端键盘通常不会发送的字节 0xff：

escape \377\377

这里的 \377 是八进制写法，对应十六进制 0xff。

这样，默认的 Ctrl+A 命令体系不再占用常规键盘输入。

3. 单独绑定 `Ctrl+A Ctrl+D`

然后使用 Screen 的输入序列映射功能，单独识别两个连续字节：

\001：Ctrl+A
\004：Ctrl+D

配置如下：

bindkey "\001\004" detach

Screen 收到该序列时执行 detach；其他输入则继续发送给 Screen 内运行的程序。

最终配置

在 ~/.screenrc 中加入：

# Pass keyboard input through to applications, except Ctrl-A Ctrl-D (detach).
# 0xff is used as Screen's otherwise-unused internal command/meta prefix so
# Ctrl-A is no longer captured by Screen's default command key. bindkey still
# recognizes the two-byte detach sequence; a lone Ctrl-A is forwarded after
# Screen's short sequence-disambiguation timeout.
#
# This file is read when a Screen server starts. Existing Screen processes keep
# their current bindings and are intentionally unaffected by this change.
escape \377\377
bindkey "\001\004" detach

本机修改后的完整 ~/.screenrc 为：

# Advertise only the color depth that this GNU Screen build can render.
# Screen 4.09 misparses 24-bit SGR colors as bold/underline/reverse attributes,
# so do not inherit a truecolor hint from the outer terminal.
term screen-256color
unsetenv COLORTERM
setenv PI_TRUE_COLOR 0

# Pass keyboard input through to applications, except Ctrl-A Ctrl-D (detach).
# 0xff is used as Screen's otherwise-unused internal command/meta prefix so
# Ctrl-A is no longer captured by Screen's default command key. bindkey still
# recognizes the two-byte detach sequence; a lone Ctrl-A is forwarded after
# Screen's short sequence-disambiguation timeout.
#
# This file is read when a Screen server starts. Existing Screen processes keep
# their current bindings and are intentionally unaffected by this change.
escape \377\377
bindkey "\001\004" detach

# Keep native scrollback and enable bracketed paste while Screen is attached.
# Most modern terminals (VS Code, GNOME Terminal, Kitty, WezTerm, iTerm2, etc.)
# identify as an xterm variant and understand these sequences.
termcapinfo xterm* ti=\E[?2004h:te=\E[?2004l

其中颜色和 bracketed paste 配置是本机原有设置，与本次按键修改没有直接关系。真正与本次需求相关的只有：

escape \377\377
bindkey "\001\004" detach

为什么单独按 `Ctrl+A` 会有短暂延迟

Screen 收到 Ctrl+A 后，无法立即知道用户接下来是否会按 Ctrl+D。

因此它必须短暂等待：

如果后续是 Ctrl+D，执行 detach；
如果后续不是 Ctrl+D，则将输入交给内部程序；
如果没有后续按键，等待序列判定超时后，将单独的 Ctrl+A 传入内部程序。

这是识别多字节快捷键时不可避免的消歧过程。延迟只影响可能构成该序列开头的 Ctrl+A，普通按键不受影响。

配置中没有给 bindkey 添加 -t。这是有意为之：Screen 使用短暂的字符间超时进行序列判定，使单独的 Ctrl+A 最终能够被转发。如果使用 bindkey -t 禁用字符间计时，可能导致单独的 Ctrl+A 一直等待后续字符。

不影响现有 Screen 会话的方法

~/.screenrc 在新的 Screen 服务进程启动时读取。直接修改该文件，不会自动修改已经运行的 Screen 服务进程。

因此安全操作原则是：

只修改 ~/.screenrc；
不对现有会话执行 screen -X source ~/.screenrc；
不向现有会话发送其他 screen -X 配置命令；
不关闭或重启现有 Screen 服务；
使用一个全新且唯一命名的临时会话测试配置。

结果是：

已经运行的 Screen 服务继续使用旧按键配置；
修改后新启动的 Screen 服务使用新按键配置；
老会话自然结束后，新配置会逐步成为默认行为。

需要注意，Screen 的服务进程和窗口可能长期存在。连接到一个已经存在的老 Screen 服务时，使用的仍可能是该服务启动时加载的旧配置；只有新建的 Screen 服务进程才能自然加载新配置。

修改前备份

修改前执行：

cp -a ~/.screenrc \
  ~/.screenrc.backup-before-pass-through-$(date +%Y%m%d-%H%M%S)

本次实际备份文件是：

~/.screenrc.backup-before-pass-through-20260916-213152

验证思路

为了避免误操作正在运行的会话，验证时应新建唯一命名的临时 Screen 会话，并在内部运行一个读取原始终端字节的小程序。

主要验证点：

普通字符原样传入；
方向键等 ANSI 转义序列原样传入；
Ctrl+C 等控制字符原样传入；
原 Screen 快捷键，例如 Ctrl+A C、Ctrl+A N、Ctrl+A K，作为字节原样传入；
单独的 Ctrl+A 在短暂等待后传入；
Ctrl+A Ctrl+D 不传入内部程序，而是 detach；
测试结束后只清理该临时测试会话。

本次字节级测试结果：

pass_through_ok=true
detach_ok=true

测试确认：

Ctrl+A C、Ctrl+A N、Ctrl+A K 均被原样传给内部程序；
普通字符、Ctrl+C、方向键转义序列均保持不变；
单独的 Ctrl+A 在短暂超时后被传入；
只有 Ctrl+A Ctrl+D 被 Screen 捕获并执行 detach。

日常使用

修改之后启动一个全新的 Screen 服务：

screen -S example

退出并保留内部任务：

Ctrl+A，然后按 Ctrl+D

重新连接：

screen -r example

在新会话中，Screen 原有的其他 Ctrl+A 管理快捷键不再可用。这是本方案的预期行为，因为目标就是只保留 detach 功能。

如果后续确实需要执行其他 Screen 管理命令，可以在 Screen 外部通过命令行针对会话操作，例如：

screen -ls
screen -S example -X quit

使用 quit 会结束对应 Screen 会话及其窗口，必须谨慎执行。

回滚

若要恢复修改前的配置，可以用备份覆盖：

cp -a \
  ~/.screenrc.backup-before-pass-through-20260916-213152 \
  ~/.screenrc

同样，回滚后的配置只会由以后新启动的 Screen 服务自然加载。不要为了立即应用而重载或重启仍在执行任务的现有 Screen 服务。

也可以只删除以下两行，恢复 Screen 默认命令前缀行为：

escape \377\377
bindkey "\001\004" detach

最终结果

这套方案不逐个解除 Screen 的默认快捷键，而是：

将 Screen 自身命令前缀从 Ctrl+A 移到通常不会由键盘产生的 0xff；
使用 bindkey 仅识别 Ctrl+A Ctrl+D；
让其余输入尽量保持原始字节并传递给内部程序；
仅通过修改 ~/.screenrc 影响未来的新 Screen 服务，不触碰当前正在运行的服务。

核心配置只有两行：

escape \377\377
bindkey "\001\004" detach

使用 YubiKey 配置 OpenPGP：密钥生成、备份与日常使用

Tue, 11 Aug 2026 00:00:00 GMT

把 OpenPGP 私钥放进 YubiKey 一类的智能卡，核心价值不是“免密码”，而是让私钥不再以可直接复制的文件形式长期留在电脑中。签名、解密和身份认证都由卡片内部完成，即使电脑遭到入侵，攻击者也很难直接导出私钥。

下面从密钥结构设计开始，依次完成备份验证、迁移入卡、Git 签名、SSH 登录和灾难恢复准备。文中的身份、邮箱、指纹、文件名和公钥地址均为脱敏示例，使用时需要替换成自己的实际信息：

Example User <user@example.com>

主密钥指纹统一使用以下占位符表示：

<PRIMARY_KEY_FINGERPRINT>

[!IMPORTANT] OpenPGP 公钥、完整指纹和卡片序列号不是同一种东西。公钥和完整指纹可以公开；私钥、PIN、Reset Code 和私钥备份绝不能公开。本文不会记录真实 PIN、Reset Code 或设备序列号。

最终要得到什么

OpenPGP 卡提供三个相互独立的私钥槽：

卡槽	能力	用途
Signature	`S`	文件、邮件和 Git commit 签名
Encryption	`E`	解密发给自己的数据
Authentication	`A`	SSH 等身份认证

本文复现当前已经使用的结构：

主密钥      [SC]  → Signature 槽
加密子密钥   [E]  → Encryption 槽
认证子密钥   [A]  → Authentication 槽

其中 S、C、E、A 分别表示 Sign、Certify、Encrypt 和 Authenticate。

还有一种隔离更严格的结构：让主密钥只具有 [C] 能力并永久离线，另外创建 [S]、[E]、[A] 三把子密钥放入卡片。这样日常使用的卡片无法直接签发新子密钥或修改身份，适合长期维护的重要身份。本文采用 [SC] + [E] + [A]，优点是结构简单、能够复现当前配置；如果以后准备重建长期身份，可以再评估离线 [C] 方案。

[!WARNING] keytocard 会在保存后把当前钥匙环里的对应私钥材料替换为智能卡引用。卡内私钥不能再导出，所以必须在迁移之前完成完整私钥备份，并实际验证备份可以恢复。

1. 准备 GnuPG 与卡片

macOS

使用 Homebrew 安装 GnuPG 和图形化 PIN 输入程序：

brew install gnupg pinentry-mac

检查版本：

gpg --version

如果终端无法弹出 PIN 输入窗口，可以在 ~/.gnupg/gpg-agent.conf 中加入实际路径：

pinentry-program /opt/homebrew/bin/pinentry-mac

Intel Mac 的路径通常是 /usr/local/bin/pinentry-mac，以 command -v pinentry-mac 的输出为准。修改后重启 agent：

gpgconf --kill gpg-agent

Linux

Debian 或 Ubuntu 可以安装：

sudo apt update
sudo apt install gnupg scdaemon pcscd

部分发行版还需要启动 PC/SC 服务：

sudo systemctl enable --now pcscd

检查 OpenPGP 应用

插入设备后执行：

gpg --card-status

应能看到以下字段：

Application type .: OpenPGP
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]

如果卡槽里已经有指纹，不要继续覆盖，先确认它们是否属于仍在使用的密钥。

本文使用的设备在 Reader 字段中显示为 LibreKeys ... yubikey，而不是标准的 Yubico 厂商名称。因此，算法、触摸确认和 KDF 等能力一律以 gpg --card-status 的实际结果及固件文档为准，不能只根据 USB 名称推断。

2. 先规划算法与有效期

当前卡片报告的属性是：

Key attributes ...: rsa2048 rsa2048 rsa2048

因此本文统一使用 RSA-2048，优先保证导入成功和客户端兼容性。不要在没有确认固件支持的情况下直接修改 key-attr。如果使用的是明确支持 RSA-3072、RSA-4096 或 ECC 的设备，可以在创建身份之前重新评估算法，但三把待迁移密钥必须与对应卡槽兼容。

本文把有效期设为 0，即 OpenPGP 元数据中的“永不过期”。这不表示算法和设备会永远安全，只表示 GnuPG 不会因为日期自动判定密钥失效。长期身份仍应定期评估算法、设备状态和备份介质。

3. 创建主密钥与子密钥

先创建具有认证和签名能力的主密钥：

gpg --quick-generate-key \
  "Example User <user@example.com>" \
  rsa2048 cert,sign 0

为本地私钥设置一条足够强、且与卡片 PIN 不同的保护密码。

查看完整指纹：

gpg --list-secret-keys \
  --keyid-format long \
  --with-subkey-fingerprint \
  "user@example.com"

复制 sec 下一行的 40 位完整主密钥指纹，并设置变量：

FPR='<PRIMARY_KEY_FINGERPRINT>'

不要使用只有 8 位或 16 位的短 Key ID。先验证变量确实指向预期身份：

gpg --list-secret-keys --keyid-format long "$FPR"

添加加密子密钥和认证子密钥：

gpg --quick-add-key "$FPR" rsa2048 encrypt 0
gpg --quick-add-key "$FPR" rsa2048 auth 0

再次检查结构：

gpg --list-secret-keys \
  --keyid-format long \
  --with-subkey-fingerprint \
  "$FPR"

此时应类似：

sec   rsa2048/... [SC]
ssb   rsa2048/... [E]
ssb   rsa2048/... [A]

4. 在迁移前制作完整备份

把下面的目录改为加密移动硬盘或其他离线介质上的真实路径：

BACKUP_DIR="/Volumes/EncryptedBackup/openpgp-backup"
install -d -m 700 "$BACKUP_DIR"

导出公钥、完整私钥、子密钥和 ownertrust：

gpg --armor \
  --output "$BACKUP_DIR/example-public.asc" \
  --export "$FPR"

gpg --armor \
  --output "$BACKUP_DIR/example-secret-full.asc" \
  --export-secret-keys "$FPR"

gpg --armor \
  --output "$BACKUP_DIR/example-secret-subkeys.asc" \
  --export-secret-subkeys "$FPR"

gpg --export-ownertrust \
  > "$BACKUP_DIR/ownertrust.txt"

--export-ownertrust 应通过 Shell 重定向保存；某些 GnuPG 版本不会把这个命令的输出写入 --output 指定的文件。如果信任记录直接打印在终端里，应检查 ownertrust.txt 是否真的存在。

GnuPG 通常会在生成主密钥时自动创建吊销证书。把它复制到备份介质：

cp "$HOME/.gnupg/openpgp-revocs.d/$FPR.rev" \
  "$BACKUP_DIR/example-revocation-certificate.rev"

chmod 600 "$BACKUP_DIR"/*
ls -la "$BACKUP_DIR"

备份目录至少应包含：

example-public.asc
example-secret-full.asc
example-secret-subkeys.asc
example-revocation-certificate.rev
ownertrust.txt

推荐保存两份加密离线备份，并放在不同地点。私钥保护密码、卡片 PIN 和 Reset Code 不要与备份介质放在一起。

实际验证备份

“文件存在”不等于“能够恢复”。创建一个隔离的临时 GnuPG 主目录：

VERIFY_HOME="$(mktemp -d)"
chmod 700 "$VERIFY_HOME"

导入完整私钥备份：

gpg --homedir "$VERIFY_HOME" \
  --import "$BACKUP_DIR/example-secret-full.asc"

gpg --homedir "$VERIFY_HOME" \
  --list-secret-keys \
  --keyid-format long \
  --with-subkey-fingerprint \
  "$FPR"

进行一次签名测试。不要把待签名内容通过管道传给 GnuPG，否则 pinentry 可能无法从当前终端读取保护密码，并报错 Inappropriate ioctl for device：

export GPG_TTY="$(tty)"

VERIFY_FILE="$(mktemp /tmp/openpgp-backup-verification.XXXXXX)"
VERIFY_SIGNATURE="$BACKUP_DIR/$(basename "$VERIFY_FILE").asc"
printf 'OpenPGP backup verification\n' > "$VERIFY_FILE"

gpg --homedir "$VERIFY_HOME" \
  --local-user "$FPR" \
  --armor \
  --clearsign \
  --output "$VERIFY_SIGNATURE" \
  "$VERIFY_FILE"

gpg --homedir "$VERIFY_HOME" \
  --verify "$VERIFY_SIGNATURE"

只有看到 Good signature，并确认临时钥匙环中存在 [SC]、[E]、[A] 的完整私钥后，才能继续。临时环境中 UID 显示 [未知] 只是因为没有导入 ownertrust，不表示备份损坏，也不影响签名验证。

5. 修改卡片 PIN

进入卡片编辑模式：

gpg --card-edit

依次进入管理模式和 PIN 菜单：

admin
passwd

通常可以看到：

1 - change PIN
2 - unblock PIN
3 - change Admin PIN
4 - set the Reset Code
Q - quit

至少完成以下三项：

修改用户 PIN；
修改管理员 PIN；
设置独立的 Reset Code。

标准原厂 YubiKey 的默认用户 PIN 通常为 123456，管理员 PIN 通常为 12345678，但兼容设备不一定相同。以厂商文档为准，不要连续猜测，因为每类 PIN 通常只有三次重试机会。

Max. PIN lengths 显示的是最大长度，不是最小长度。标准 OpenPGP 卡通常要求用户 PIN 至少 6 位、管理员 PIN 和 Reset Code 至少 8 位；兼容固件还可能有更严格的字符限制。为了兼容性，本文建议使用 8 位以上的用户 PIN，以及 12～16 位 ASCII 字母和数字组成的管理员 PIN、Reset Code，不要使用 4 位数字 PIN。

修改 PIN 时，pinentry 会先收集当前 PIN、新 PIN 和重复的新 PIN，最后才一次性交给卡片验证。因此，看到“输入新 PIN”的界面不代表当前 PIN 已经通过验证。如果最终提示 Bad PIN 或“损坏的 PIN”，先退出并运行 gpg --card-status：管理员 PIN 对应 PIN retry counter 的最后一位；若计数没有减少，更可能是新 PIN 太短或格式不受支持，若计数减少则说明当前 PIN 错误。

三类凭据的用途不同：

用户 PIN：执行签名、解密和认证；
管理员 PIN：修改卡片设置、写入或删除密钥；
Reset Code：用户 PIN 被锁定后的恢复凭据。

6. 把三把私钥迁移到卡片

进入密钥编辑界面：

gpg --edit-key "$FPR"

先输入：

list

主密钥迁移到 Signature 槽

刚进入编辑界面时不要选择任何子密钥，直接执行：

keytocard

选择：

也就是 Signature key。

GnuPG 会询问“真的要移动主密钥吗”，确认后可能显示：

Note: the local copy of the secret key will only be deleted with "save".

这表示主密钥已经写入卡片，而钥匙环中的本地副本要到最后执行 save 才会移除。此时先继续迁移 [E] 和 [A]，不要提前保存。

`[E]` 子密钥迁移到 Encryption 槽

如果 [E] 是第一把子密钥：

key 1
list

确认只有 [E] 子密钥前面出现 *，然后执行：

keytocard

选择：

迁移完成后取消选择：

key 1

`[A]` 子密钥迁移到 Authentication 槽

如果 [A] 是第二把子密钥：

key 2
list

确认只有 [A] 子密钥前面出现 *，然后执行：

keytocard

选择：

可以再输入一次 key 2 取消选择，然后运行 list，确认没有误选其他子密钥，最后保存：

key 2
list
save

[!CAUTION] key N 是切换第 N 把子密钥的选择状态，不是把选择直接切换过去；再次输入同一个命令才会取消其前面的 *。如果 [E] 和 [A] 前面同时出现 *，先对不需要的那一把再执行一次 key N。子密钥编号取决于实际钥匙环，以 [E] 和 [A] 标志为准，不要盲目照搬编号。执行 save 前再次确认卡槽选择正确。

7. 验证卡片状态

查看 OpenPGP 卡：

gpg --card-status

配置成功后应同时出现三把指纹：

Signature key ....: <PRIMARY_KEY_FINGERPRINT>
Encryption key....: <ENCRYPTION_SUBKEY_FINGERPRINT>
Authentication key: <AUTH_SUBKEY_FINGERPRINT>

再查看本地钥匙环：

gpg --list-secret-keys \
  --keyid-format long \
  --with-subkey-fingerprint \
  "$FPR"

预期类似：

sec>  rsa2048/... [SC]
ssb>  rsa2048/... [E]
ssb>  rsa2048/... [A]

> 表示私钥操作由智能卡完成，本地只保留卡片引用。它不表示私钥已经被公开或可以从卡中导出。

8. 分别测试三个卡槽

签名与验证

export GPG_TTY="$(tty)"

SIGN_TEST="$(mktemp /tmp/openpgp-card-signing.XXXXXX)"
SIGNATURE="${SIGN_TEST}.sig.asc"
printf 'OpenPGP smartcard signing test: %s\n' \
  "$(date '+%Y-%m-%dT%H:%M:%S%z')" \
  > "$SIGN_TEST"

gpg --local-user "$FPR" \
  --armor \
  --detach-sign \
  --output "$SIGNATURE" \
  "$SIGN_TEST"

gpg --verify "$SIGNATURE" "$SIGN_TEST"

printf '测试文件：%s\n签名文件：%s\n' \
  "$SIGN_TEST" "$SIGNATURE"

预期看到：

Good signature from "Example User <user@example.com>"

加密与解密

printf 'OpenPGP smartcard encryption test\n' \
  > /tmp/openpgp-plaintext.txt

gpg --armor \
  --recipient "$FPR" \
  --output /tmp/openpgp-encrypted.asc \
  --encrypt /tmp/openpgp-plaintext.txt

gpg --decrypt /tmp/openpgp-encrypted.asc

加密只需要公钥，因此拔掉卡片仍可加密；解密必须使用卡片中的 [E] 私钥。可以拔卡后再尝试解密，确认操作确实依赖设备。

导出 SSH 公钥

gpg --export-ssh-key "$FPR"

应得到类似：

ssh-rsa AAAA... openpgp:0x...

这只能证明认证子密钥可以转换为 SSH 公钥。完整 SSH 登录配置见后文。

9. 配置 Git commit 签名

让 Git 使用这把 OpenPGP 密钥：

git config --global user.signingkey "$FPR"
git config --global commit.gpgsign true
git config --global tag.gpgSign true
git config --global gpg.program "$(command -v gpg)"

进行一次本地测试：

mkdir /tmp/gpg-git-sign-test
cd /tmp/gpg-git-sign-test
git init
git commit --allow-empty -m "test OpenPGP signing"
git log --show-signature -1

要让 GitHub 显示 Verified，还需要：

把 user@example.com 添加到 GitHub 账号并完成验证；
在 GitHub 的 SSH and GPG keys 页面添加 ASCII 公钥；
commit 的作者邮箱必须属于该账号。

导出可粘贴到 GitHub 的公钥：

gpg --armor --export "$FPR"

10. 把认证子密钥用于 SSH

在 ~/.gnupg/gpg-agent.conf 中加入：

enable-ssh-support

重启 gpg-agent：

gpgconf --kill gpg-agent
gpgconf --launch gpg-agent

当前终端指向 GnuPG 提供的 SSH agent socket：

export SSH_AUTH_SOCK="$(gpgconf --list-dirs agent-ssh-socket)"

把同一行写入 ~/.zshrc 或 ~/.bashrc，然后重新打开终端。检查 agent 是否识别卡片：

ssh-add -L

也可以直接导出公钥保存：

gpg --export-ssh-key "$FPR" > ~/.ssh/openpgp-backup.pub

把这行公钥添加到服务器的 ~/.ssh/authorized_keys 或 GitHub 的 SSH keys 页面，再执行实际登录测试：

ssh -T git@github.com

拔掉卡后再次连接，应当无法使用这把私钥完成认证。

11. 发布公钥与指纹

导出公开版本：

gpg --armor \
  --output example-public.asc \
  --export "$FPR"

可以把它发布到个人网站，例如：

https://example.com/pgp.asc

这个地址必须直接返回 example-public.asc 的 ASCII 公钥内容。OpenPGP 卡的公钥 URL 是单个字符串字段，只支持一个 URL；如果需要多个镜像，应使用一个长期稳定的地址，再由服务器通过 HTTP 重定向到当前镜像。

设置卡片上的公钥 URL：

gpg --card-edit

admin
url
https://example.com/pgp.asc
quit

上传后检查服务器返回的指纹：

curl -fsSL https://example.com/pgp.asc |
  gpg --show-keys --fingerprint

只能公开 example-public.asc。不要上传整个备份目录，也不要公开 example-secret-full.asc、example-secret-subkeys.asc、吊销证书或 ownertrust.txt；备份签名测试文件也不是公钥。

完整指纹应通过另一个独立渠道公开，供别人核对：

<PRIMARY_KEY_FINGERPRINT>

还可以把公钥上传到支持的密钥服务器：

gpg --keyserver hkps://keys.openpgp.org \
  --send-keys "$FPR"

密钥服务器上的记录通常无法像普通文件一样彻底删除，只能通过吊销来声明失效。上传前应确认 UID 中的邮箱适合长期公开；使用 keys.openpgp.org 时，还需要按邮件完成 UID 验证，其他人才可按邮箱搜索到它。

12. 可选的卡片安全设置

每次签名都重新验证 PIN

当前状态如果显示：

Signature PIN ....: 非强制

表示一次成功验证后，同一会话中的后续签名可能不再要求 PIN。重要发布密钥可以切换为强制：

gpg --card-edit

输入：

admin
forcesig
quit

forcesig 是切换命令，再执行一次会恢复原状态。频繁签 Git commit 时，非强制更方便；签软件发布包或重要文件时，强制更稳妥。

物理触摸确认 UIF

如果设备明确支持触摸确认，可以先单独测试签名槽：

gpg --card-edit

admin
uif 1 on
quit

确认签名能在触摸后成功，再按需启用解密和认证：

uif 2 on
uif 3 on

对应关系为：

UIF 1 = Sign
UIF 2 = Decrypt
UIF 3 = Auth

启用 Sign=on 后，签名流程通常仍会先要求用户 PIN；PIN 窗口关闭后，GnuPG 可能只是在终端中静默等待，并不会再弹出“请按键”窗口。此时直接触摸设备即可。可以故意暂时不触摸：若签名命令持续等待，说明 UIF 正在生效；若签名立即完成，先确认 gpg --list-secret-keys 中签名主密钥显示为 sec>。如果确实是 sec> 且无需触摸也能签名，说明兼容固件虽然报告 Sign=on，但没有实际执行触摸策略。

[!CAUTION] 兼容卡未必实现了与原厂 YubiKey 相同的触摸行为。先用 on 测试，不要直接设为 permanent；永久模式通常无法关闭，只能重置 OpenPGP 应用并清空密钥。

KDF

OpenPGP Card KDF 会先在客户端对 PIN 进行加盐和迭代派生，再把结果交给卡片。它可以强化 PIN 处理，但要求所有客户端和固件都正确支持。

当前兼容设备的状态是：

KDF setting ......: off

在固件来源、旧客户端兼容性和恢复流程都没有验证之前，建议保持关闭。KDF 不是越多越好的通用开关，错误启用可能导致旧设备无法验证 PIN。

卡片元数据

name、lang、login 和公钥 URL 都只是元数据，不决定密钥安全。可以在以下界面按需设置：

gpg --card-edit
admin
name
lang
login
url
quit

只有当 ASCII 公钥已经长期托管在稳定的 HTTPS 地址时，才建议填写 URL。URL 指向的只能是公钥，绝不能是私钥备份。

13. 在新电脑上恢复使用

新电脑不需要导入完整私钥，只需导入公钥并让 GnuPG 学习卡片：

gpg --import example-public.asc
gpg --card-status

如果本地没有正确建立卡片引用，可以执行：

gpg-connect-agent "scd serialno" "learn --force" /bye

然后重新检查：

gpg --list-secret-keys \
  --keyid-format long \
  --with-subkey-fingerprint \
  "$FPR"

需要 SSH 时，再配置 enable-ssh-support 和 SSH_AUTH_SOCK。不要为了日常使用而把完整私钥备份导入联网电脑；那会抵消智能卡隔离私钥的主要价值。

14. 卡片丢失、损坏或 PIN 锁定

用户 PIN 锁定

如果用户 PIN 的重试次数降到 0，可以使用事先设置的 Reset Code 或管理员 PIN 解锁。不要继续猜测，以免管理员 PIN 也被锁定。

卡片损坏但身份仍需继续使用

从经过验证的完整私钥备份恢复到隔离环境，准备一枚新卡，再将密钥写入新卡。因为原 OpenPGP 私钥并没有从旧卡中导出，而是从迁移前的备份重新获得，所以备份是整个恢复流程的唯一可靠基础。

卡片丢失或怀疑已被复制使用

如果无法确认卡片仍在自己控制下，应使用离线保存的吊销证书吊销主密钥，并尽快发布更新后的公钥状态。吊销代表整套身份失效；如果只是轮换某一把子密钥，则需要使用认证主密钥吊销旧子密钥、添加新子密钥并重新发布公钥。

导入自动生成的吊销证书前，应先阅读文件头部的说明。GnuPG 生成的 .rev 文件通常会在 Armor 开头故意加入一个冒号，防止误导入；正式使用时需要按文件内说明去掉该字符，再导入并发布吊销后的公钥。

[!WARNING] 吊销通常不可逆。只有在密钥确实需要作废时才执行，不要把“测试吊销证书”放在真实钥匙环或公开密钥服务器上。

15. 日常检查清单

定期执行 gpg --card-status，确认三个卡槽指纹和 PIN 重试次数正常；
每次修改 UID、有效期或子密钥后，重新导出并发布公钥；
至少每年检查两份离线备份是否仍可读取；
保持 GnuPG、scdaemon、pinentry 和设备固件更新；
不把私钥备份、保护密码、PIN 与 Reset Code 放在同一位置；
保留一枚备用兼容卡，或至少记录经过验证的换卡流程；
“永不过期”不等于永远安全，定期重新评估算法和设备寿命。

验收结果

完成配置后，应得到类似以下结构：

主密钥 [SC]
<PRIMARY_KEY_FINGERPRINT>

加密子密钥 [E]
<ENCRYPTION_SUBKEY_FINGERPRINT>

认证子密钥 [A]
<AUTH_SUBKEY_FINGERPRINT>

仅看到三把指纹还不算完成。最终验收应同时满足：离线备份已在隔离钥匙环中成功导入并签名，签名与解密均需要卡片，SSH 已完成一次真实登录，sec> / ssb> 显示本地只保留卡片引用，公钥和完整指纹也已发布到稳定位置。可选安全开关应在这些基础流程通过后再逐项启用。

参考资料

从 giffgaff 转入 VOXI：eSIM 激活、APN 排障与保号说明

Mon, 10 Aug 2026 00:00:00 GMT

最近 giffgaff 账号异常、封停的讨论变多，不少人开始把英国号码转到 VOXI。论坛里已经有开卡、eSIM 激活和携号转入的成功案例，但相关信息散落在不同帖子中，而且 APN、PAYG 和保号规则的说法并不完全一致。

下面按实际操作顺序整理：先开通 VOXI eSIM，处理可能出现的无服务问题，再使用 PAC 将 giffgaff 号码转入 VOXI。文中的时效和排障参数来自社区实测，不代表运营商承诺；正式操作前仍应以 VOXI 和 giffgaff 当时显示的规则为准。

[!WARNING] 携号转入成功后，VOXI 开卡时分配的新号码会被原 giffgaff 号码覆盖。转号期间还可能暂时收不到电话和短信，不要把银行、邮箱等关键验证码操作安排在同一天。

开始前需要准备什么

至少确认以下条件：

手机支持 eSIM，且没有运营商网络锁；
有一个可以正常收信的邮箱；
有 VOXI 接受的付款方式，账单资料与付款信息保持真实、匹配；
仍能登录 giffgaff，或至少能在账号受限后的可操作期限内申请 PAC；
VOXI eSIM 已经能够连接网络或接收短信，再开始携号转入。

教育优惠码、首月减免等活动可能随时变化，并不是携号转入的必要条件。论坛里出现的代购和优惠码属于第三方交易，本文不作推荐。

第一步：开通并写入 VOXI eSIM

在 VOXI 官网选择 eSIM 套餐，按页面要求填写资料并完成付款。社区帖子提到，订单提交后通常几分钟就能在邮箱中收到 eSIM 邮件，附件是一份带二维码的 PDF。

开通过程中有几个细节容易踩坑：

尽量一次完成订单，不要在支付阶段反复返回、刷新或重复提交；
不要开启浏览器的整页翻译，部分用户遇到过翻译扩展改变表单参数的问题；
记住开户时填写的出生日期，社区案例中它会用于解锁 eSIM PDF；
使用真实的个人、地址和付款资料，不要照搬论坛中的随机地址做法；
二维码通常只能安全写入一次，确认要安装的设备后再扫描。

在 iPhone 上打开“设置 → 蜂窝网络 → 添加 eSIM”，扫描 PDF 中的二维码并按提示完成安装。安装后先等待一段时间，社区案例中从写入到收到网络欢迎短信约需 30 分钟，但实际时间可能更长。

如果需要确认 VOXI 分配的新号码，可以登录 VOXI 账户查看。登录过程可能向 eSIM 发送一次性验证码；有信号后也可以尝试拨打：

*#100#

eSIM 写入后一直无服务怎么办

先完成最基础的检查：

确认 VOXI 线路已经启用；
开关一次飞行模式，并等待 1～2 分钟；
重启手机；
暂时关闭 VPN 或代理；
在“网络选择”中恢复自动选择。

仍然无服务时，可以尝试修改 APN。现有帖子给出了两套不同的成功参数，它们来自不同设备或 eSIM 配置，不能视为 VOXI 的统一官方设置。

方案 A：只修改 LTE APN

奶昔论坛的 iPhone 成功案例只修改了“LTE 设置（选填）”：

APN: 3internet
用户名: 留空
密码: 留空

路径为“设置 → 蜂窝网络 → VOXI 线路 → 蜂窝数据网络”。保存后开关一次飞行模式，再观察能否完成激活。

方案 B：填写 Talkmobile APN

另一篇 NodeSeek 帖子给出的方案是将可见的 APN 项（包括 LTE 选填项）改为：

APN: payg.talkmobile.uk
用户名: wap
密码: wap

同样需要在修改后开关飞行模式并等待一会儿。

[!IMPORTANT] 两套参数不要混填。建议先记录原值，每次只测试一套；无效就恢复原设置，再尝试下一套。APN 主要影响数据注册和联网，出现信号并不等于语音、短信或 Wi-Fi Calling 一定可用。

第二步：从 giffgaff 获取 PAC

PAC（Porting Authorisation Code）是英国手机号携号转网所需的授权码。先在 giffgaff 账户中申请 PAC，再到 VOXI 提交转入。

原帖特别提醒：如果 giffgaff 账号已经被封，应尽快处理，并称需要在封停后的 14 天内申请。这里的“14 天”是帖子针对受限账号给出的经验窗口，不要把它和 PAC 自身的有效期混为一谈；页面显示的截止日期才是最终依据。

申请后先保存好以下信息：

要转入的 giffgaff 手机号；
PAC；
PAC 的到期时间；
giffgaff 和 VOXI 两边的账户资料。

第三步：在 VOXI 提交携号转入

打开 VOXI 官方转号页面：

https://voxi.co.uk/account/settings/transfer/confirmation

该链接会先要求登录 VOXI 账户。登录后按照页面要求填写原号码、PAC 和计划转入日期，再确认提交。不要在 VOXI eSIM 还无法收短信时急着转号，因为登录和确认过程可能需要一次性验证码。

转号完成后通常会收到确认短信，同时发生两件事：

原 giffgaff 号码转到 VOXI；
VOXI 开卡时临时分配的号码被覆盖，不再继续保留。

提交后如果暂时失去服务，先等待运营商完成切换，再重启手机或开关飞行模式。不要因为短时间无信号就重复提交 PAC。

套餐取消、PAYG 与保号

这部分是社区讨论中分歧最大的地方。

有成功案例称，取消 VOXI 的月度 Plan 后会转为按量付费，并以“180 天内产生一次余额变化”作为保号依据；但也有用户从客服处得到“只有实体卡能够转 PAYG，且需要联系客服”的答复。eSIM 能否直接取消套餐并进入 PAYG，不能仅凭一个案例下结论。

更稳妥的做法是：

在 VOXI 账户中确认取消套餐后的明确状态；
如果页面没有显示 PAYG，直接联系 VOXI 客服确认 eSIM 是否支持转换；
免费月或当前套餐结束后保留少量余额；
不要卡在第 179 天才充值或消费，提前完成一次可计费活动；
确认该活动确实改变了余额，而不只是手机显示“短信已发送”。

论坛中有人提醒，零余额号码可能在 180 天之前就被回收。因此，“180 天余额变化”更适合作为最长检查周期，而不是可以放心拖到最后一天的保证。

在中国大陆长期使用时，保号通常还依赖短信或通话能否正常走 Wi-Fi Calling。仅修改 APN 获得 4G/5G 信号，并不能证明可以发短信完成余额变动。

长期漫游风险

VOXI 本质上是面向英国用户的移动服务，社区也提到其条款不鼓励长期漫游。当前能够在境外激活、收短信或维持一段时间，不代表以后不会触发风控。

如果这个号码绑定了重要账户，至少准备以下备份：

为银行、邮箱和双重验证预留第二种恢复方式；
不把 VOXI 作为唯一验证码号码；
定期登录账户检查余额、套餐和号码状态；
保存开户资料、PAC 记录和客服沟通记录；
关注 VOXI 对漫游、PAYG 和停机回收规则的调整。

常见问题速查

现象	优先检查	不要急着做
扫码后无服务	等待、飞行模式、重启、自动选网	重复扫描 eSIM 二维码
有信号但不能上网	记录原值后逐一测试 APN	混用两套 APN 参数
有数据但不能发短信	Wi-Fi Calling、账户余额、线路能力	认为 APN 能解决所有语音短信问题
VOXI 登录失败	eSIM 是否能收一次性验证码	反复提交转号申请
转号后 VOXI 新号消失	这是携号转入后的预期结果	试图同时保留两个号码
想取消月租长期保号	账户状态与客服确认	默认 eSIM 一定会自动转 PAYG

参考资料

[!NOTE] 本文整理于 2026 年 8 月。论坛帖子能够证明“有人按此方法成功”，不能证明运营商长期支持同样的套餐、漫游或保号策略。涉及重要号码时，以账户页面和客服书面答复为准。

不安装 Android Studio 也能开发 Android

Mon, 20 Jul 2026 00:00:00 GMT

Android Studio 不是 Android 开发的必需品。真正参与构建的只有：

JDK；
Android SDK；
Gradle Wrapper；
ADB。

编辑代码可以使用 VS Code、Neovim 或其他文本编辑器。下面以 Kotlin 原生 Android 项目为例，使用项目内工具链完成测试、打包和真机安装。

准备环境

以 compileSdk = 35 的项目为例，需要：

JDK 17；
Android SDK Command-line Tools；
Platform 35；
Build-Tools 35.0.0；
Platform-Tools。

下载 Command-line Tools 后，将其放入项目目录：

.android-toolchain/sdk/cmdline-tools/latest/

然后安装 SDK 组件：

export ANDROID_SDK_ROOT="$PWD/.android-toolchain/sdk"
export ANDROID_HOME="$ANDROID_SDK_ROOT"
export ANDROID_USER_HOME="$PWD/.android-user-home"
export GRADLE_USER_HOME="$PWD/.gradle-user-home"

SDKMANAGER="$ANDROID_SDK_ROOT/cmdline-tools/latest/bin/sdkmanager"

yes | "$SDKMANAGER" --sdk_root="$ANDROID_SDK_ROOT" --licenses
"$SDKMANAGER" --sdk_root="$ANDROID_SDK_ROOT" \
  "platforms;android-35" \
  "build-tools;35.0.0" \
  "platform-tools"

在项目根目录创建不提交到 Git 的 local.properties：

sdk.dir=/absolute/path/to/project/.android-toolchain/sdk

构建与测试

项目应提交 Gradle Wrapper，因此无需全局安装 Gradle：

./gradlew testDebugUnitTest assembleDebug

生成的 Debug APK 位于：

app/build/outputs/apk/debug/app-debug.apk

只需要打包时执行：

./gradlew assembleDebug

安装到真机

在手机上启用“开发者选项”和“USB 调试”，连接后确认设备已授权：

.android-toolchain/sdk/platform-tools/adb devices -l

覆盖安装 APK：

.android-toolchain/sdk/platform-tools/adb install -r \
  app/build/outputs/apk/debug/app-debug.apk

看到 Success 即安装完成。

注意事项

将 .android-toolchain/、.android-user-home/、.gradle-user-home/、local.properties 和构建目录加入 .gitignore。
Debug APK 不需要额外签名；发布 APK 或 AAB 时，仍需使用 keytool 创建 keystore 并配置 Release 签名。

完成测试、APK 构建和真机安装后，这套命令行工具链就已验证可用。Android Studio 仍可用于布局预览和性能分析，但不是构建项目的前置条件。

远程服务器 Codex 使用本地 AiMaMi 中转服务指南

Sat, 18 Jul 2026 00:00:00 GMT

我的实际场景是：Codex 运行在远程服务器上，而 AiMaMi 中转服务运行在本地电脑。为了让服务器上的 Codex 使用本地中转，需要先通过 SSH 反向隧道连接两端，再在服务器上配置 Provider 和模型切换方式。

完成后，远程服务器上的 Codex 既可以使用官方模型，也可以按需切换到本地 AiMaMi 智能路由，不必每次手工修改 ~/.codex/config.toml。

以 AiMaMi 智能路由为例，可以选择两条路线：

使用 Codex Profile，在启动 CLI 时选择配置层；
使用 Shell 脚本，原地启用或禁用全局配置块，并按需关闭 app-server 使配置生效。

两条路线解决的是同一个问题，但适用范围不同：Profile 更干净，适合 CLI；脚本会修改全局配置，更适合 Codex 桌面 App 或常驻 app-server。

[!WARNING] 不要使用 cc-switch-cli 切换本文涉及的 Codex 配置。它可能改写或接管配置状态，导致不同 Codex 进程读取到不一致的配置，最终出现会话不同步。本文只使用 Codex 原生 Profile 或定向开关脚本；会话记录同步则单独使用 codex-provider-sync。

配置结构与切换边界

智能路由的开关配置位于 ~/.codex/config.toml 顶部：

# >>> aimami-relay codex-router top start (DO NOT EDIT MANUALLY)
# Codex 智能路由：使用 HTTP-only 自定义 provider，避开内建 openai WebSocket 路径
# 菜单模型来自 model_catalog_json；官方 / 中转分流由本地 proxy 决定
# 在 AiMaMi 里关闭智能路由开关后，本段会被自动移除
model_provider = "aimai1"
model_catalog_json = "/sdc/home/<username>/.codex/model-catalogs/codex_router_catalog.json"
# <<< aimami-relay codex-router top end

具体的自定义 Provider 可以继续放在公共配置中：

[model_providers.aimai1]
name = "AiMaMi 智能路由"
base_url = "http://127.0.0.1:25123/codex/router/v1"
wire_api = "responses"
requires_openai_auth = true
supports_websockets = false

这里要区分两类配置：

[model_providers.aimai1] 只是定义 Provider，可以长期保留；
顶层的 model_provider 和 model_catalog_json 决定本次使用哪个 Provider 和模型目录，是实际需要切换的部分。

[!IMPORTANT] config.toml 是 TOML 文件，不是 Shell 脚本。model_catalog_json = "$HOME/..." 或 model_catalog_json = "$CODEX_HOME/..." 通常不会展开环境变量，应填写真实绝对路径。

在本机单独运行 SSH 反向转发

在服务器上的 Codex 访问本地 AiMaMi 路由之前，需要把服务器的 127.0.0.1:25123 反向转发到本机的 127.0.0.1:25817：

服务器 Codex
    ↓ 127.0.0.1:25123
SSH 反向隧道
    ↓
本机 AiMaMi：127.0.0.1:25817

当前环境无法依赖 SSH Config 自动建立这条转发，因此更推荐在运行 AiMaMi 的本机单独打开一个终端，直接执行：

ssh -N -R 127.0.0.1:25123:127.0.0.1:25817 服务器

参数含义如下：

-N：只建立隧道，不在服务器执行远程命令；
-R：创建反向端口转发；
127.0.0.1:25123：服务器侧监听地址；
127.0.0.1:25817：本机 AiMaMi 服务地址；
服务器：SSH 主机名、别名或 user@host。

这个终端只负责维持隧道，不要关闭，也不需要在其中执行其他命令。终端断开或 SSH 进程退出后，反向转发会立即失效；此时服务器上的 Codex 也就无法继续访问本地 AiMaMi。需要恢复时，重新打开一个终端并再次运行该命令即可。

[!NOTE] 我当前无法通过 ~/.ssh/config 中的 RemoteForward 正常使用这条隧道，所以本文不再把 SSH Config 作为可用方案。主机地址、用户名、密钥等常规连接信息仍可由 SSH Config 提供，但反向转发本身使用命令行中的 -R 显式创建。

如果服务器上的 AiMaMi Provider 通过该反向隧道连接本机，对应地址应使用：

base_url = "http://127.0.0.1:25123/codex/router/v1"

本机直接访问 AiMaMi 时则使用：

base_url = "http://127.0.0.1:25817/codex/router/v1"

建立隧道之后，再从下面两种 Codex 配置切换方案中选择一种。

方案 A：使用 Codex Profile

Profile 如何工作

Profile 是 Codex 启动时加载的配置覆盖层。执行：

codex --profile aimami-router

Codex 会先读取：

~/.codex/config.toml

再叠加：

~/.codex/aimami-router.config.toml

因此，公共配置保留在主配置中，只有存在差异的字段才需要写进 Profile。

从 Codex 0.134.0 开始，每个 Profile 应使用独立文件，并通过 --profile 指定，不再推荐写成 config.toml 中的 [profiles.xxx] 表，也不能通过顶层 profile = "xxx" 自动选择。

调整主配置

从 ~/.codex/config.toml 顶部移除以下两个选择项：

model_provider = "aimai1"
model_catalog_json = "/sdc/home/<username>/.codex/model-catalogs/codex_router_catalog.json"

Provider 定义仍然保留：

[model_providers.aimai1]
name = "AiMaMi 智能路由"
base_url = "http://127.0.0.1:25123/codex/router/v1"
wire_api = "responses"
requires_openai_auth = true
supports_websockets = false

这样主配置只保存公共设置，不再强制所有 Codex 实例经过智能路由。

创建官方模型 Profile

创建 ~/.codex/official.config.toml：

model_provider = "openai"
model = "gpt-5.6-sol"
model_reasoning_effort = "high"

交互式启动：

codex --profile official

非交互任务也可以使用相同 Profile：

codex exec --profile official "检查当前代码改动"

创建智能路由 Profile

创建 ~/.codex/aimami-router.config.toml：

model_provider = "aimai1"
model_catalog_json = "/sdc/home/<username>/.codex/model-catalogs/codex_router_catalog.json"
model = "gpt-5.6-sol"
model_reasoning_effort = "high"

启动方式相同：

codex --profile aimami-router
codex exec --profile aimami-router "检查当前代码改动"

添加便捷别名

可以在 ~/.bashrc 或 ~/.zshrc 中加入：

alias codex-official='codex --profile official'
alias codex-router='codex --profile aimami-router'

以后直接执行：

codex-official
codex-router

Profile 的优缺点

优点：

不需要反复修改主配置；
不同终端可以同时运行不同 Profile；
切换只影响新启动的 Codex 进程；
适合 CLI 和 codex exec 自动化任务。

限制：

Profile 是 CLI 启动参数，不等于修改桌面 App 的全局配置；
已经运行的 Codex 进程不会自动切换；
每次启动必须指定 --profile，或者使用别名封装。

方案 B：使用脚本切换全局配置

如果主要使用 Codex 桌面 App，或者希望所有新会话统一切换到同一条路由，可以直接修改全局 config.toml。

这里不删除配置块，而是给块内有效 TOML 行添加专用注释：

# aimami-router-disabled: model_provider = "aimai1"
# aimami-router-disabled: model_catalog_json = "/sdc/home/<username>/.codex/model-catalogs/codex_router_catalog.json"

重新开启时，脚本只移除 # aimami-router-disabled: 前缀。原有说明注释、块标记和块外配置都不会被修改。

完整 Linux 脚本

将下面的内容保存为 ~/codex-switch.sh：

#!/bin/sh

set -eu

START_MARKER='# >>> aimami-relay codex-router top start (DO NOT EDIT MANUALLY)'
END_MARKER='# <<< aimami-relay codex-router top end'
DISABLED_PREFIX='# aimami-router-disabled: '

CONFIG_FILE=${AIMAMI_CODEX_CONFIG:-"$HOME/.codex/config.toml"}
ACTION=toggle
ASSUME_YES=0

usage() {
    printf '%s\n' \
        "用法: $(basename "$0") [-y] [on|off|toggle|status]" \
        '' \
        "默认配置: $CONFIG_FILE" \
        '也可通过 AIMAMI_CODEX_CONFIG 指定其他 config.toml。' \
        '-y：修改后不询问，直接关闭 Codex app-server。'
}

ACTION_SET=0
for ARG in "$@"; do
    case "$ARG" in
        -y|--yes)
            ASSUME_YES=1
            ;;
        on|off|toggle|status)
            if [ "$ACTION_SET" -eq 1 ]; then
                printf '错误: 只能指定一个操作。\n' >&2
                usage >&2
                exit 2
            fi
            ACTION=$ARG
            ACTION_SET=1
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        *)
            printf '错误: 未知参数: %s\n' "$ARG" >&2
            usage >&2
            exit 2
            ;;
    esac
done

if [ ! -f "$CONFIG_FILE" ]; then
    printf '错误: 配置文件不存在: %s\n' "$CONFIG_FILE" >&2
    exit 1
fi

get_state() {
    awk -v start="$START_MARKER" -v end="$END_MARKER" -v prefix="$DISABLED_PREFIX" '
        $0 == start {
            starts++
            if (inside) bad = 1
            inside = 1
            next
        }
        $0 == end {
            ends++
            if (!inside) bad = 1
            inside = 0
            next
        }
        inside {
            if (index($0, prefix) == 1) disabled++
            else if ($0 !~ /^[[:space:]]*($|#)/) active++
        }
        END {
            if (inside || starts != 1 || ends != 1 || bad) {
                print "错误: 路由块的起止标记缺失、重复或顺序错误" > "/dev/stderr"
                exit 1
            }
            if (active && disabled) {
                print "错误: 路由块同时含有启用和禁用的配置行" > "/dev/stderr"
                exit 1
            }
            if (disabled) print "off"
            else if (active) print "on"
            else print "empty"
        }
    ' "$CONFIG_FILE"
}

STATE=$(get_state)

if [ "$ACTION" = status ]; then
    printf 'aimami-relay codex-router: %s\n' "$STATE"
    exit 0
fi

if [ "$ACTION" = toggle ]; then
    case "$STATE" in
        on) ACTION=off ;;
        off) ACTION=on ;;
        *)
            printf '错误: 路由块中没有可切换的配置行\n' >&2
            exit 1
            ;;
    esac
fi

if [ "$ACTION" = "$STATE" ]; then
    printf 'aimami-relay codex-router 已经是 %s，无需修改。\n' "$STATE"
    exit 0
fi

TEMP_FILE=$(mktemp "${CONFIG_FILE}.tmp.XXXXXX")
trap 'rm -f "$TEMP_FILE"' EXIT HUP INT TERM

awk -v start="$START_MARKER" -v end="$END_MARKER" \
    -v prefix="$DISABLED_PREFIX" -v action="$ACTION" '
    $0 == start { inside = 1; print; next }
    $0 == end { inside = 0; print; next }
    inside && action == "off" && $0 !~ /^[[:space:]]*($|#)/ {
        print prefix $0
        next
    }
    inside && action == "on" && index($0, prefix) == 1 {
        print substr($0, length(prefix) + 1)
        next
    }
    { print }
' "$CONFIG_FILE" > "$TEMP_FILE"

if ! FILE_MODE=$(stat -c '%a' "$CONFIG_FILE" 2>/dev/null); then
    printf '错误: 无法读取配置文件权限: %s\n' "$CONFIG_FILE" >&2
    exit 1
fi
chmod "$FILE_MODE" "$TEMP_FILE"
mv "$TEMP_FILE" "$CONFIG_FILE"
trap - EXIT HUP INT TERM

printf 'aimami-relay codex-router 已切换为 %s。\n' "$ACTION"

SHOULD_STOP=0
if [ "$ASSUME_YES" -eq 1 ]; then
    SHOULD_STOP=1
else
    printf '是否关闭 Codex app-server 以使配置生效？[y/N] '
    if ! read -r ANSWER; then
        ANSWER=
    fi
    case "$ANSWER" in
        y|Y|yes|YES|Yes) SHOULD_STOP=1 ;;
    esac
fi

if [ "$SHOULD_STOP" -eq 1 ]; then
    if pkill -u "$(id -u)" -TERM -f '[c]odex.*app-server'; then
        printf '已向 Codex app-server 发送 TERM 信号。\n'
    else
        printf '未找到正在运行的 Codex app-server。\n'
    fi
else
    printf '已保留当前 Codex app-server。\n'
fi

添加执行权限：

chmod +x ~/codex-switch.sh

使用方法

# 查看当前状态
~/codex-switch.sh status

# 开启、关闭或反转智能路由
~/codex-switch.sh on
~/codex-switch.sh off
~/codex-switch.sh toggle

修改后，脚本会询问是否结束当前用户的 Codex app-server：

是否关闭 Codex app-server 以使配置生效？[y/N]

在自动化脚本中，可以使用 -y 跳过确认：

~/codex-switch.sh -y on
~/codex-switch.sh -y off
~/codex-switch.sh -y toggle

实际执行的结束命令是：

pkill -u "$(id -u)" -TERM -f '[c]odex.*app-server'

它只匹配当前用户的 Codex app-server，并发送 TERM 信号。当前会话可能因此中断，所以执行前应保存尚未完成的工作。

如需操作其他配置文件，可以临时指定：

AIMAMI_CODEX_CONFIG=/path/to/config.toml ~/codex-switch.sh status

脚本的安全边界

脚本包含几项保护：

起止标记必须各出现一次且顺序正确；
不允许块内同时出现启用和禁用的配置行；
使用同目录临时文件生成结果，再原子替换原配置；
保留原配置文件权限；
只处理标记块内的有效 TOML 行；
status 不修改配置，也不结束服务；
重复执行同一状态不会再次修改文件或结束服务。

[!NOTE] 该版本使用 GNU stat -c，面向 Linux，不兼容 macOS/BSD。

同步会话记录

Provider 配置切换与会话记录同步是两个独立操作：

配置切换：使用 Codex Profile 或 codex-switch.sh；
记录同步：使用 codex-provider-sync；
不要使用 cc-switch-cli 代替上述任一流程。

首次使用时，通过 npm 从 GitHub 全局安装：

npm install -g git+https://github.com/Dailin521/codex-provider-sync.git

需要同步记录时执行：

codex-provider sync

推荐的完整顺序是：

使用 codex --profile ... 启动所需 Profile，或者用 codex-switch.sh 切换全局配置；
如果使用脚本方案，按提示关闭旧的 app-server，再重新启动 Codex；
执行 codex-provider sync 同步会话记录。

这样可以让配置切换和记录同步各自使用专门工具，避免其他切换器额外改写 Codex 状态。

如何选择

使用场景	推荐方案	原因
Codex CLI 交互使用	Profile	启动时选择，不修改全局状态
`codex exec` 自动化任务	Profile	命令中可以显式声明运行环境
两个终端同时使用不同路由	Profile	每个进程拥有独立配置层
Codex 桌面 App	开关脚本	桌面 App 主要读取全局配置
希望所有新会话统一切换	开关脚本	直接改变全局 `config.toml`
无人值守切换并刷新服务	开关脚本配合 `-y`	可修改配置并结束旧 `app-server`

主要使用 CLI 时优先选择 Profile；主要依赖桌面 App 或常驻服务时，使用脚本更直接。

最终目录结构

采用 Profile 方案时：

~/.codex/
├── config.toml
├── official.config.toml
├── aimami-router.config.toml
└── model-catalogs/
    └── codex_router_catalog.json

采用脚本方案时：

~/.codex/
├── config.toml
└── model-catalogs/
    └── codex_router_catalog.json

~/codex-switch.sh

参考资料

macOS 读写 NTFS 移动硬盘：从只读 FSKit 到 macFUSE

Fri, 17 Jul 2026 00:00:00 GMT

Windows 常用的 NTFS 移动硬盘接到 macOS 后，文件通常可以读取，却不能新建、修改或删除。下面记录一次把 WD elements 移动硬盘从系统默认的只读挂载，切换为 NTFS-3G 可写挂载的过程。

[!IMPORTANT] 这不是“开启 macOS 原生 NTFS 写入”。本文实测环境中的 mount_ntfs 来自 Homebrew 安装的 ntfs-3g-mac，底层依赖 macFUSE。macOS 自带的 NTFS 支持仍以只读为主。

实测环境

macOS 26.5.1
Apple FSKit 默认只读挂载
ntfs-3g-mac 2022.10.3
macFUSE
NTFS 分区：/dev/disk8s1
卷标：WD elements

磁盘编号会随连接顺序变化，/dev/disk8s1 只适用于这次实测。执行命令前一定要先确认自己的设备编号，不要直接照抄。

先确认 `mount_ntfs` 来自哪里

参考文章写于较早的 macOS 版本，其测试系统为 10.13.6。较新的 macOS 不应再把 mount_ntfs 理解为系统自带的可写 NTFS 驱动。

先检查当前实际调用的程序：

command -v mount_ntfs
readlink "$(command -v mount_ntfs)"

本机输出指向：

/opt/homebrew/sbin/mount_ntfs
../Cellar/ntfs-3g-mac/2022.10.3/sbin/mount_ntfs

这说明命令是 NTFS-3G 的 Homebrew 包装脚本。重新挂载后，mount 显示的文件系统类型也会从 ntfs 变成 macfuse。

如果提示 command not found: mount_ntfs，需要先安装 macFUSE 和 NTFS-3G：

brew tap gromgit/fuse
brew install --cask macfuse
brew install gromgit/fuse/ntfs-3g-mac

安装 macFUSE 后，按系统提示在“系统设置 → 隐私与安全性”中允许其扩展，并在需要时重新启动。不要为了省事直接关闭 SIP；若系统要求调整 Apple 芯片 Mac 的启动安全策略，应以 macFUSE 官方说明为准。

第一步：识别 NTFS 分区

插入移动硬盘后，先列出外置磁盘并核对分区信息：

diskutil list external
diskutil info /dev/disk8s1

确认设备编号无误后，查看当前挂载参数：

mount | grep ntfs

本次输出为：

/dev/disk8s1 on /Volumes/WD elements (ntfs, local, nodev, nosuid, read-only, noowners, noatime, fskit)

其中几个关键字段是：

ntfs：分区文件系统为 NTFS；
read-only：当前明确以只读方式挂载；
fskit：当前走的是 macOS 的 FSKit 挂载路径；
noowners：不在该卷上执行常规的所有者权限检查。

第二步：卸载系统的只读挂载

卸载分区不会清除数据，但执行前仍应关闭正在访问移动硬盘的 Finder 窗口、终端和应用。

sudo umount /dev/disk8s1

也可以让 Disk Utility 框架处理：

diskutil unmount /dev/disk8s1

这里只是卸载文件系统，不是把物理硬盘弹出。设备节点仍然存在，下一步可以立即重新挂载。

第三步：建立挂载目录

这里把挂载点放在桌面，名称为 md1：

mkdir -p "$HOME/Desktop/md1"

挂载目录必须已经存在，而且应当是空目录。路径中如果包含空格，记得加引号。

第四步：以可写方式重新挂载

sudo mount_ntfs -o rw,nobrowse /dev/disk8s1 "$HOME/Desktop/md1"

参数含义如下：

rw：请求以读写模式挂载；
nobrowse：不把该挂载点作为普通磁盘显示在 Finder 侧边栏；
/dev/disk8s1：需要挂载的 NTFS 分区；
"$HOME/Desktop/md1"：访问该分区的新入口。

命令成功时通常没有输出，这是正常现象。因为使用了 nobrowse，可以直接打开挂载目录：

open "$HOME/Desktop/md1"

第五步：验证是否真的可写

不要只看 mount_ntfs 是否报错。先检查实际挂载类型：

mount | grep '/Desktop/md1'

本机重新挂载后的结果为：

/dev/disk8s1 on /Users/<username>/Desktop/md1 (macfuse, local, synchronous, noatime, nobrowse)

初始状态中的 read-only 已经消失，并且文件系统类型变成了 macfuse。最后创建一个临时文件，验证真实写入：

test_file="$HOME/Desktop/md1/.ntfs-write-test"
touch "$test_file" && rm "$test_file" && echo "NTFS 写入测试通过"

只有这一步成功，才能确认当前分区确实可写。

安全卸载与恢复默认挂载

使用完毕后，不要直接拔出移动硬盘。先卸载 macFUSE 挂载：

sudo umount "$HOME/Desktop/md1"

然后弹出整块物理磁盘。注意这里使用 disk8，而不是分区 disk8s1：

diskutil eject /dev/disk8

如果只是想退出可写模式，并恢复 macOS 默认的只读挂载，可以执行：

sudo umount "$HOME/Desktop/md1"
rmdir "$HOME/Desktop/md1"
diskutil mount /dev/disk8s1

手动挂载不会永久修改 NTFS 分区；移动硬盘重新插入后，macOS 通常仍会按默认只读方式挂载。

常见问题

Finder 中看不到移动硬盘

这是 nobrowse 的预期行为，不代表挂载失败。使用下面的命令打开即可：

open "$HOME/Desktop/md1"

如果希望它作为普通卷显示，可以尝试去掉 nobrowse，但手动挂载点的位置与 Finder 展示效果可能因系统版本而异。

提示 `Resource busy`

通常是原来的只读卷尚未卸载，或者某个应用仍在使用它。先关闭相关 Finder 窗口和文件，再检查：

mount | grep disk8s1

确认旧挂载消失后再执行 mount_ntfs。

提示 macFUSE 不可用

检查 macFUSE 是否已安装、系统扩展是否获准，以及安装后是否完成重启。还可以确认 NTFS-3G 是否存在：

brew list --versions ntfs-3g-mac
command -v mount_ntfs

Windows 休眠或快速启动导致拒绝写入

如果 NTFS-3G 提示卷处于 hibernated、unclean 或 unsafe state，不要强制挂载。把硬盘接回 Windows，关闭“快速启动”和休眠，执行完整关机；必要时先运行：

chkdsk X: /f

将 X: 替换为移动硬盘的盘符，修复完成并正常弹出后再回到 macOS。

是否适合长期使用

NTFS-3G + macFUSE 适合临时兼容已有的 NTFS 硬盘，但性能、系统升级兼容性和异常断电后的恢复能力都需要谨慎对待。重要数据应保留备份；需要长期高频写入时，可以考虑成熟的商业 NTFS 驱动。若硬盘可以重新格式化且主要在 Windows 与 macOS 间交换文件，exFAT 往往更省心，但格式化前必须先备份全部数据。

操作结论

这次操作的状态变化可以概括为：

macOS FSKit 只读挂载
        ↓ 卸载
NTFS-3G + macFUSE 可写挂载
        ↓ 安全卸载
重新插入后恢复系统默认行为

最重要的不是记住 disk8s1，而是每次先确认设备编号；也不要因为 mount_ntfs 没有输出就默认成功，始终用 mount 和一次真实的临时文件写入完成验证。

参考资料

怎样在苹果电脑上用移动硬盘（使用 NTFS 格式硬盘）？：原文测试于 macOS 10.13.6，提供了“卸载后重新挂载”的基本思路。
macFUSE
NTFS-3G
gromgit/homebrew-fuse

Claude Code 斜杠命令使用指南

Fri, 12 Jun 2026 00:00:00 GMT

Claude Code 是 Anthropic 的终端编程工具。多数任务可以直接用自然语言描述；以 / 开头的斜杠命令更适合会话管理、配置、代码审查和项目初始化等需要明确控制的操作。

下面按使用场景整理命令。命令集合会随版本变化，实际可用项以当前客户端的 /help 为准。

1. 会话管理

控制当前对话会话的状态与生命周期。

命令	功能	示例 / 说明
`/clear`	清空当前会话上下文	开始全新对话，不影响项目文件和设置。适合切换话题或上下文过长时使用
`/compact`	压缩会话上下文	将对话历史总结为摘要以释放 token 空间。压缩前确保重要内容已落地到文件中
`/rename`	重命名当前会话标题	`/rename "修复登录页面布局问题"`
`/resume`	恢复之前的会话	继续之前的对话
`/export`	导出当前会话记录	支持多种格式，用于存档、分享或审计
`/prompt`	显示当前系统提示词	查看 CLAUDE.md 注入的项目上下文、记忆、环境信息等

2. 配置与偏好

调整 Claude Code 的外观、行为和模型偏好。

命令	功能	示例 / 说明
`/config`	打开设置界面	修改主题、模型、权限策略、hooks 等。等价于编辑 `~/.claude/settings.json` 和 `.claude/settings.json`
`/theme`	切换终端颜色主题	暗色 / 亮色 / 系统跟随
`/statusline`	配置状态栏显示项	选择显示模型名、分支、token 用量等信息
`/model`	切换 AI 模型	可用模型取决于订阅计划和最新模型列表
`/fast`	切换 Fast 模式	使用 Opus 模型并加速输出，适合需要快速响应的场景

3. 项目初始化与记忆

命令	功能	示例 / 说明
`/init`	生成项目的 CLAUDE.md	分析项目结构，自动生成包含技术栈、目录结构、常用命令的文档。建议每个项目根目录运行一次
`/memory`	管理持久记忆	`/memory 记住：这个项目使用 Biome 格式化代码`。记忆存储在 `.claude/projects/<path>/memory/`
`/recall`	检索相关记忆	`/recall 代码格式化工具`。Claude Code 启动时自动加载 `MEMORY.md` 索引

4. 代码审查与质量

命令	功能	示例 / 说明
`/review`	审查当前 Pull Request	`/review --effort high` 指定审查强度；覆盖正确性、安全性、性能、可维护性
`/security-review`	安全漏洞专项审查	覆盖 OWASP Top 10：注入、认证绕过、敏感信息泄露、不安全反序列化等
`/simplify`	审查并自动简化代码	识别可简化、复用、提效的代码模式并自动修复，侧重质量而非 bug
`/code-review`	分级代码审查	`/code-review --effort low`（仅高置信度）/ `max`（全面）/ `--comment`（发布到 PR）

5. 开发与调试

命令	功能	示例 / 说明
`/run`	启动并驱动项目应用	`/run "测试登录功能是否正常"`。自动检测项目类型并选择运行方式
`/verify`	验证变更实际效果	`/verify "检查导航栏响应式布局是否修复"`。运行应用并观察行为来确认

6. 任务与后台管理

命令	功能	示例 / 说明
`/tasks`	查看任务列表	显示每个任务的状态（pending / in_progress / completed）和依赖关系
`/bashes`	列出后台 Shell 任务	查看所有运行中的后台任务及其状态
`/terminate`	终止后台任务	`/terminate <task-id>`

7. 自动化与工作流

命令	功能	示例 / 说明
`/loop`	按固定间隔循环执行命令	`/loop 5m /run "检查 Vercel 最新部署状态"`（每 5 分钟）；默认间隔 10 分钟
`/workflows`	查看和管理多 Agent 编排工作流	支持 `parallel()`、`pipeline()`、`phase()` 等编排原语，用 JS 编写脚本

8. 扩展与集成

命令	功能	示例 / 说明
`/mcp`	管理 MCP 服务器连接	`/mcp add <server-name>` 添加外部工具/数据源（数据库、API 等）
`/ide`	管理 IDE 集成	与 VS Code、JetBrains 等协作，在 IDE 中打开文件、定位到指定行
`/add-dir`	添加额外工作区目录	`/add-dir /path/to/another-project`，允许操作多个目录下的文件

9. 技能类命令（Skills）

Skills 是扩展 Claude Code 能力边界的专业化模块：

命令	功能
`/deep-research`	多源深度调研：自动搜索、交叉验证并生成带引用的报告
`/claude-api`	Claude API / Anthropic SDK 参考：模型 ID、定价、参数、token 计算等
`/update-config`	通过 settings.json 配置 hooks、权限、环境变量等自动化行为
`/keybindings-help`	自定义键盘快捷键
`/fewer-permission-prompts`	分析操作历史，生成权限白名单以减少重复授权弹窗
`/run`	启动并驱动项目应用以观察变更效果
`/verify`	验证代码变更是否达到预期效果
`/code-review`	对当前 diff 进行分级审查
`/simplify`	审查变更代码的质量优化点并自动修复
`/review`	审查 Pull Request
`/security-review`	安全审查
`/init`	初始化项目 CLAUDE.md
`/loop`	定时循环执行任务

Skills 列表会随版本更新持续扩展。使用 /help 可查看当前可用的完整 Skills 列表。

10. 信息与帮助

命令	功能	示例 / 说明
`/help`	显示帮助信息和命令概览	遇到不熟悉的命令时的第一站
`/cost`	查看 token 用量及费用	当前会话和累计明细，帮助控制 API 消费
`/doctor`	系统健康检查	验证安装完整性、依赖项（Node.js、pnpm 等）、配置文件有效性

11. 账户管理

命令	功能	示例 / 说明
`/login`	登录或切换 Anthropic 账户	暂无
`/logout`	登出当前账户	暂无

12. 实用技巧

12.1 命令组合

多个命令可以串联达到高效 workflow：先 /review 审查，再 /simplify 自动修复；先 /init 初始化，再 /config 自定义。

12.2 善用 `/prompt` 排查问题

当 Claude Code 的行为不符合预期时，用 /prompt 查看它实际「看到」了哪些指令，包括 CLAUDE.md、memory、系统提示词等。

12.3 `/compact` 的时机

当出现以下情况时建议执行压缩：

上下文 token 使用率超过 80%
对话中已完成多个独立任务
响应速度明显下降

12.4 项目级 vs 用户级配置

级别	路径	作用范围
用户级	`~/.claude/settings.json`	适用于所有项目的全局设置
项目级	`.claude/settings.json`	仅对当前项目生效，覆盖用户级设置

使用 /config 编辑时注意区分两者的作用范围。

12.5 Memory 的最佳实践

记录项目特有的约定和非标准做法
记录用户偏好（语言、格式化风格等）
避免记录可从代码或 git 历史自动推导的信息
定期用 /recall 检查记忆的有效性

使用原则

能直接描述的任务就使用自然语言；需要配置固化、会话管理或多步骤编排时再使用命令。遇到命令不存在或行为与文中不同的情况，先用 /help 和 /status 确认当前版本与可用能力。

服务器环境配置指南

Fri, 12 Jun 2026 00:00:00 GMT

这套流程用于初始化没有 root 权限的 Linux 服务器。目标是在用户目录中完成 Shell、Python、项目目录和远程文件挂载配置，不依赖系统管理员安装软件。

主要内容包括：

Shell 环境初始化与 zsh 编译安装
oh-my-zsh 配置与 Powerlevel10k 主题
micromamba 部署与初始化
个人共享目录与项目工作区建立
使用 rclone 将本机 SFTP 目录挂载为 FUSE 目录
Python 环境创建
pip 国内镜像配置

以下步骤均无需 sudo 或 root 权限，仅在用户目录下操作。

1. Shell 环境升级：编译安装 zsh

大部分 Linux 服务器预装的是 bash，但如果你习惯 zsh 的补全和主题生态，建议自行编译一份用户态 zsh。

1.1 准备编译依赖

由于没有 root 权限，需要借助 micromamba 创建临时环境来提供编译工具链：

# 下载 micromamba 二进制（详见下一节）
curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj .local/micromamba
chmod +x .local/micromamba/micromamba

# 创建一个用于编译的环境
./.local/micromamba/micromamba create -n make make ncurses

1.2 下载并解压 zsh 源码

# 下载 zsh 源码包
wget https://sourceforge.net/projects/zsh/files/zsh/5.9.1/zsh-5.9.1.tar.xz/download -O zsh-5.9.1.tar.xz
tar -xJf zsh-5.9.1.tar.xz
cd zsh-5.9.1

1.3 配置与编译

设置编译环境变量，让编译器找到 micromamba 环境中安装的 ncurses 库：

ENV_PATH="$HOME/.local/micromamba/envs/make"

make distclean || rm -f config.cache

./configure --prefix="$HOME/.local/zsh" \
    CFLAGS="-I${ENV_PATH}/include -I${ENV_PATH}/include/ncurses" \
    CPPFLAGS="-I${ENV_PATH}/include -I${ENV_PATH}/include/ncurses" \
    LDFLAGS="-L${ENV_PATH}/lib -Wl,-rpath,${ENV_PATH}/lib" \
    --with-termlib=ncurses

make && make install

编译完成后，zsh 会被安装到 $HOME/.local/zsh 下。

1.4 切换默认 Shell

# 确认 zsh 路径
which zsh
# 输出: ~/.local/zsh/bin/zsh

# 查看当前系统已登记的 shell
cat /etc/shells

# 切换默认登录 shell
chsh -s "$HOME/.local/zsh/bin/zsh"

[!TIP] 如果 chsh 在服务器上可用（部分共享服务器允许用户自行切换），该命令会直接生效。重新登录后即为 zsh。

若 chsh 不可用，可在 ~/.bash_profile 末尾添加 exec $HOME/.local/zsh/bin/zsh，每次登录时自动进入 zsh。

1.5 安装 oh-my-zsh 与 Powerlevel10k 主题

oh-my-zsh 是 zsh 最流行的配置框架，提供丰富的主题和插件生态。Powerlevel10k（p10k）是一款高性能的 oh-my-zsh 主题，提供清晰的信息展示和便捷的配置向导。

1.5.1 安装 oh-my-zsh

通过 curl 一键安装：

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

安装脚本会自动备份已有的 ~/.zshrc 并生成一份新的默认配置。

1.5.2 安装 Powerlevel10k 主题

将 p10k 主题克隆到 oh-my-zsh 的自定义主题目录下：

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \
    "${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k"

1.5.3 启用主题

编辑 ~/.zshrc，将主题设置为 powerlevel10k/powerlevel10k：

# 修改前
ZSH_THEME="robbyrussell"

# 修改后
ZSH_THEME="powerlevel10k/powerlevel10k"

1.5.4 运行配置向导

重新加载 ~/.zshrc 或新开一个终端标签页，p10k 会自动启动交互式配置向导：

source ~/.zshrc

配置向导会依次询问：

字体：是否安装 Meslo Nerd Font（推荐安装，否则部分图标显示异常）
样式：经典、纯净、彩虹、瘦线等多种样式可选
提示符元素：选择要显示的信息（时间、电池、Python 虚拟环境、git 状态等）
间距与换行：单行或双行提示符

配置完成后，p10k 会自动生成 ~/.p10k.zsh 文件，后续可通过 p10k configure 随时重新运行向导。

[!TIP] 如果终端连接后图标显示为乱码或方框，说明缺少 Nerd Font。可以在本地终端（如 iTerm2、Windows Terminal）中下载安装 Meslo Nerd Font，并将终端字体设置为 MesloLGS NF。

[!TIP] p10k 配置向导提供了丰富的自定义选项，强烈建议首次使用时花几分钟过一遍向导，后续使用体验会好很多。

2. 安装 Micromamba

micromamba 是 conda 的 C++ 重实现，静态链接、启动速度快、无环境嵌套问题，非常适合在无 root 权限的环境下管理 Python 版本和包。

2.1 下载与安装

curl -Ls https://micro.mamba.pm/api/micromamba/linux-64/latest | tar -xvj .local/micromamba
chmod +x .local/micromamba/micromamba

2.2 初始化 Shell

./.local/micromamba/micromamba shell init -s bash
# 如果使用 zsh，替换为：
./.local/micromamba/micromamba shell init -s zsh

初始化完成后，重新加载 shell 配置文件或重新登录即可使用 micromamba 命令。

2.3 验证安装

micromamba env list

如果正确输出了环境列表（即使为空），说明安装成功。

3. 建立目录结构

3.1 服务器摸底

在新服务器上，先确认磁盘容量、配额和共享目录情况：

df -h                          # 查看磁盘挂载与容量
quota -v                       # 查看用户配额
groups                         # 查看所属组

3.2 创建个人工作目录

根据共享存储的布局，建议建立标准化的个人目录结构。

这样做的目的是将自己的文件（代码、数据、模型、产出）存放在干净的独立目录中，与 ~/.cache、shell 配置文件、micromamba 环境等系统/工具生成的文件彻底分离。这样无论是备份、迁移还是清理缓存，都不会误伤自己的数据。

/share/<group_name>/<username>/
├── Datasets/     # 数据集
├── Models/       # 预训练模型
├── Outputs/      # 输出与实验结果
└── Projects/     # 项目工作区

创建命令（按实际情况修改组名）：

GROUP_NAME="your-group"
USER_NAME="${USER:?当前 shell 未设置 USER}"
SHARE_BASE="/share/${GROUP_NAME}/${USER_NAME}"
mkdir -p "${SHARE_BASE}"/{Datasets,Models,Outputs,Projects}

3.3 创建项目工作区

mkdir -p ~/Projects/work1

建议将工作区与共享目录配合使用，项目产出可以软链接或直接存放到共享目录中，便于团队协作。

3.4 使用 rclone 挂载本机 SFTP 目录

有些程序不能正确跟随符号链接，或者要求目标必须表现为普通目录。此时可以让 rclone 通过本机的 SSH/SFTP 读取实际工作目录，再将它挂载到另一个位置。程序看到的是一个普通的 FUSE 目录，而不是符号链接。

这样做的主要目的是把当前希望通过网页查看的内容统一挂载到一个固定目录，再由 OpenList 等外部服务挂载并提供网页浏览，而不必移动或复制原始文件。

以下示例假设服务器的目录结构为：

/sdc/home/<username>/<username>/
├── ai-workspace/w1/  # 实际目录
└── Pan/w1/           # FUSE 挂载点

示例中的用户名从 $USER 获取，不需要在命令或文章中写入真实账号。

前置条件

此方案不需要 root 权限，但需要：

$HOME/bin/rclone 已安装且可执行；
系统提供 fusermount3；
本机 sshd 正在运行；
~/.ssh/id_ed25519 可以免密登录 localhost；
挂载点存在且为空。

可以先验证依赖和本机 SSH：

command -v "$HOME/bin/rclone"
command -v fusermount3
ssh -i "$HOME/.ssh/id_ed25519" localhost true

定义脱敏路径变量

USER_NAME="${USER:?当前 shell 未设置 USER}"
USER_ROOT="/sdc/home/${USER_NAME}/${USER_NAME}"
SOURCE_DIR="${USER_ROOT}/ai-workspace/w1"
MOUNT_DIR="${USER_ROOT}/Pan/w1"

先确认实际目录存在，再创建空挂载点：

test -d "$SOURCE_DIR"
mkdir -p "$MOUNT_DIR"

if [ -n "$(find "$MOUNT_DIR" -mindepth 1 -maxdepth 1 -print -quit)" ]; then
  echo "挂载点非空：$MOUNT_DIR" >&2
  exit 1
fi

执行挂载

rclone 的按需 SFTP remote 使用双斜杠表示远端绝对路径。下面先移除 SOURCE_DIR 开头的 /，再显式拼接 //：

REMOTE=":sftp,host=localhost,user=${USER_NAME},key_file=${HOME}/.ssh/id_ed25519,known_hosts_file=none://${SOURCE_DIR#/}"
LOG_FILE="$(dirname "$MOUNT_DIR")/.rclone-w1.log"

"$HOME/bin/rclone" mount "$REMOTE" "$MOUNT_DIR" \
  --daemon \
  --vfs-cache-mode writes \
  --log-file "$LOG_FILE" \
  --log-level INFO

这里的 known_hosts_file=none 会跳过 localhost 的主机密钥校验，仅适合明确连接本机回环 SSH 的场景。如果改为连接其他主机，应配置并校验 known_hosts，不要沿用这个选项。

检查挂载是否成功：

mountpoint "$MOUNT_DIR"
findmnt -T "$MOUNT_DIR"

成功后，访问 Pan/w1 实际会通过本机 SFTP 读写 ai-workspace/w1。

卸载

正常卸载：

fusermount3 -u "$MOUNT_DIR"

如果提示设备忙，先关闭终端、编辑器、训练任务等正在访问该目录的程序，再重新卸载。必要时可以延迟卸载：

fusermount3 -uz "$MOUNT_DIR"

[!WARNING] 挂载期间不要删除或移动 w1 挂载点。服务器重启后 FUSE 挂载会失效，需要重新执行挂载命令；若要长期使用，可以后续再封装为登录脚本或用户级服务。

4. 创建 Python 环境

4.1 基础 Python 环境

创建一个通用 Python 3.10 环境：

micromamba create -n py10 python=3.10

4.2 环境管理常用命令

micromamba env list                    # 列出所有环境
micromamba activate py10               # 激活环境
micromamba deactivate                  # 退出当前环境
micromamba remove -n py10 --all        # 删除环境
micromamba install -n py10 <package>   # 安装包

5. 配置 pip 国内镜像

在国内网络环境下，配置 pip 镜像源可以显著提升包下载速度。

5.1 写入配置文件

mkdir -p ~/.config/pip
cat > ~/.config/pip/pip.conf <<'EOF'
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn
EOF

5.2 验证配置

micromamba run -n py10 python -m pip config list

输出中应包含 index-url 指向清华源，即配置生效。

6. 启动配置文件整理

初始化过程中需要调整以下 shell 配置文件，确保每次登录环境正确：

文件	用途
`~/.bashrc`	bash 交互式 shell 的配置文件
`~/.bash_profile`	bash 登录时读取的配置文件
`~/.zshrc`	zsh 的配置文件

建议将 micromamba 的初始化代码、环境变量（如 PATH、LD_LIBRARY_PATH）统一写入对应 shell 的配置文件中。

7. 配置 Git 提交模板

在服务器上进行开发时，经常需要提交代码。配置一个标准化的提交信息模板可以让每次 git commit 时都有结构化的提示，避免遗漏关键信息。

7.1 创建模板文件

cat > ~/.git-commit-template.txt << 'EOF'

**note:**
-

---
**todo:**
- []
---
**fixed:**
- []

EOF

模板分为三个区域：

区域	用途
`note:`	备注说明、背景信息、相关上下文
`todo:`	待完成的待办项，使用 `- []` 标记
`fixed:`	本次提交修复的问题或完成的事项

7.2 配置 Git 使用模板

git config --global commit.template ~/.git-commit-template.txt

[!TIP] 如果希望只对特定项目生效，去掉 --global，在对应仓库目录下执行 git config commit.template ~/.git-commit-template.txt 即可。

7.3 效果

配置完成后，每次执行 git commit（不带 -m）时，编辑器会自动打开并预填充模板：


**note:**
-

---
**todo:**
- []
---
**fixed:**
- []

只需在对应位置填写内容即可。使用 -m 参数时模板不会生效，适用于简单的一次性提交。

初始化结果确认

逐项执行以下检查，确认初始化结果：

[x] 用户态 micromamba 已安装，可管理 Python 环境
[x] zsh 已编译安装并设为默认登录 shell
[x] 个人共享目录与标准子目录结构已建立
[x] 项目工作区已创建
[x] Python 3.10 环境（py10）已创建
[x] pip 已配置清华镜像源
[x] Git 提交模板已配置（note/todo/fixed 三段式）

这些项目全部通过后，环境即可用于数据集管理、模型下载和实验脚本开发。后续升级仍应保持工具安装在用户目录中，避免与系统包管理器混用。

Zsh 中的 Conda 自定义命令框架

Thu, 16 Apr 2026 00:00:00 GMT

长期使用 conda 或 micromamba 后，Shell 配置中通常会积累一些高频的自定义操作：

根据当前目录自动激活某个环境
快速停用当前环境
维护“项目目录 -> 环境名”的映射关系
给 conda 增加一些自己的子命令

最直接的做法，通常是在 ~/.zshrc 里写一个很长的 conda() 函数，用 case 分发不同子命令。这个方案能用，但随着逻辑增加，会很快出现几个问题：

~/.zshrc 越来越臃肿
子命令扩展不方便
help 信息难以维护
实现和注册耦合太紧，不利于长期演进

这里把自定义 conda 子命令拆成一个三层的小型框架：

JSON 指令定义
通用分发器
各自独立的实现函数

最终效果是：

~/.zshrc 中只保留一行 source
执行 conda 时，除了原有 micromamba help，还能显示你自己注册的子命令和说明
新增一个子命令时，只需要：
- 在 JSON 中注册
- 写一个实现函数
不需要再去修改一大段 case 分支

一、适用场景

这套方案适合下面这些人：

使用 zsh
底层环境管理器是 micromamba，但希望继续使用 conda 这个命令入口
想给 conda 增加自己的快捷子命令
希望自定义命令具备“可注册、可扩展、可维护”的结构

如果你平时会做下面这些操作，这套方案会特别顺手：

conda ac：按目录映射自动激活环境
conda de：快速停用环境
conda map curr：把当前目录和当前环境写入映射表
conda map：直接编辑映射配置

二、最终结构

建议把相关文件拆成下面这样：

~/.zshrc
~/.zsh/
  conda-wrapper.zsh
  conda-commands.json
~/.conda_map.ini

各文件职责如下：

~/.zshrc
- 只负责初始化 shell，并 source 你的自定义框架
~/.zsh/conda-wrapper.zsh
- 框架主逻辑
- 包含注册表加载、命令分发、help 输出、各实现函数
~/.zsh/conda-commands.json
- 子命令注册表
- 声明每个命令的类型、目标和说明
~/.conda_map.ini
- 保存“路径 -> 环境”的映射关系

三、整体设计思路

核心思想很简单：

1. `conda` 不再直接硬编码全部逻辑

不再写这种结构：

conda() {
  case "$1" in
    ac) ... ;;
    de) ... ;;
    map) ... ;;
    *) micromamba "$@" ;;
  esac
}

而是改成：

先看看 $1 是否在 JSON 注册表里
如果在：
- 按注册信息执行对应逻辑
如果不在：
- 回落到原始 micromamba "$@"

这样你自己的子命令和 micromamba 原生能力就自然共存了。

2. JSON 只管声明，不管实现

JSON 负责定义：

命令名
命令类型
目标动作
help 描述

比如：

ac 对应某个 zsh 函数
de 对应 micromamba deactivate
map 对应某个 zsh 函数

这就是“注册”和“实现”分离。

3. 实现函数彼此独立

每个子命令的业务逻辑用独立函数承载，比如：

_conda_cmd_ac
_conda_cmd_map

这样新增功能时不需要碰已有命令逻辑，只需要加新函数和注册项。

四、部署步骤

下面按完整部署流程介绍。

第一步：确保 `micromamba` 已初始化

你的 ~/.zshrc 中应先有 micromamba shell init 生成的初始化内容，典型形式如下：

# >>> mamba initialize >>>
export MAMBA_EXE="$HOME/micromamba/micromamba"
export MAMBA_ROOT_PREFIX="$HOME/micromamba"
__mamba_setup="$("$MAMBA_EXE" shell hook --shell zsh --root-prefix "$MAMBA_ROOT_PREFIX" 2> /dev/null)"
if [ $? -eq 0 ]; then
    eval "$__mamba_setup"
else
    alias micromamba="$MAMBA_EXE"
fi
unset __mamba_setup
# <<< mamba initialize <<<

这一段的作用是：

设置 MAMBA_EXE
设置 MAMBA_ROOT_PREFIX
把 micromamba 的 shell hook 注入当前 shell
让 activate/deactivate 等命令在 shell 环境里生效

注意：这一步非常关键。因为环境激活本质上不是一个普通子进程动作，而是要修改当前 shell 的环境变量。

第二步：在 `~/.zshrc` 里只保留简短加载语句

在 mamba initialize 之后添加：

source "$HOME/.zsh/conda-wrapper.zsh"

这样 ~/.zshrc 本身就不会塞满业务逻辑。

推荐结构：

# >>> mamba initialize >>>
# ... micromamba init generated block ...
# <<< mamba initialize <<<

source "$HOME/.zsh/conda-wrapper.zsh"

第三步：创建注册表文件 `~/.zsh/conda-commands.json`

这个文件是整个框架的命令声明中心。

示例：

{
  "commands": {
    "ac": {
      "type": "function",
      "target": "_conda_cmd_ac",
      "description": "根据当前目录匹配 ~/.conda_map.ini 并激活对应环境（可用于手动触发）。"
    },
    "de": {
      "type": "micromamba",
      "target": "deactivate",
      "description": "停用当前环境（等价于 micromamba deactivate）。"
    },
    "map": {
      "type": "function",
      "target": "_conda_cmd_map",
      "description": "维护路径->环境映射：map curr 写入当前目录；map 打开 ~/.conda_map.ini。"
    }
  }
}

字段说明：

commands
- 所有自定义子命令的集合
每个子命令 key，例如 ac
- 就是用户执行的 conda ac
type
- 命令类型
- 当前支持：
  - function
  - micromamba
target
- 目标执行体
- 若 type=function，则是 zsh 函数名
- 若 type=micromamba，则是转发给 micromamba 的子命令
description
- 用于 help 输出的说明文字

这一步完成后，你的子命令元信息就集中管理起来了。

第四步：创建框架主文件 `~/.zsh/conda-wrapper.zsh`

这是整个系统的核心。它一般需要包含下面几部分：

1. 注册表缓存结构

例如：

typeset -g _CONDA_CMD_REGISTRY_FILE="$HOME/.zsh/conda-commands.json"
typeset -g _CONDA_CMD_REGISTRY_LOADED=0
typeset -gA _CONDA_CMD_TYPE_MAP
typeset -gA _CONDA_CMD_TARGET_MAP
typeset -gA _CONDA_CMD_DESC_MAP

作用：

保存 JSON 文件位置
标记是否已经加载过注册表
用关联数组缓存命令类型、目标和说明

这样 shell 会在首次使用时读取 JSON，之后直接用内存数据，不需要每次反复解析文件。

2. 统一执行 `micromamba` 的函数

建议做一个包装器：

_conda_exec_mamba() {
    if command -v micromamba >/dev/null 2>&1; then
        micromamba "$@"
    elif [[ -n "$MAMBA_EXE" && -x "$MAMBA_EXE" ]]; then
        "$MAMBA_EXE" "$@"
    else
        echo "未找到 micromamba，请先完成 micromamba 初始化。" >&2
        return 127
    fi
}

这个函数解决两个问题：

micromamba 在某些子 shell 中可能不在 PATH
但 MAMBA_EXE 可能已经可用

统一封装后，你后续所有转发都走它，避免到处重复写兜底逻辑。

3. 注册表加载器

这是最关键的一部分。思路是：

用 python3 解析 JSON
输出 tab 分隔的数据
zsh 再把这些内容读进关联数组

典型实现思路如下：

_conda_load_command_registry() {
    (( _CONDA_CMD_REGISTRY_LOADED )) && return 0
    [[ -f "$_CONDA_CMD_REGISTRY_FILE" ]] || return 1

    local key type target desc
    while IFS=$'\t' read -r key type target desc; do
        [[ -z "$key" || -z "$type" || -z "$target" ]] && continue
        _CONDA_CMD_TYPE_MAP[$key]="$type"
        _CONDA_CMD_TARGET_MAP[$key]="$target"
        _CONDA_CMD_DESC_MAP[$key]="$desc"
    done < <(
        python3 - "$_CONDA_CMD_REGISTRY_FILE" <<'PY'
import json
import sys

path = sys.argv[1]
with open(path, "r", encoding="utf-8") as f:
    data = json.load(f)

for key, spec in data.get("commands", {}).items():
    cmd_type = str(spec.get("type", "")).strip()
    target = str(spec.get("target", "")).strip()
    desc = str(spec.get("description", "")).strip()
    desc = desc.replace("\t", " ").replace("\n", " ")
    if key and cmd_type and target:
        print(f"{key}\t{cmd_type}\t{target}\t{desc}")
PY
    )

    _CONDA_CMD_REGISTRY_LOADED=1
}

这里有几个细节很重要：

read -r key type target desc
- 必须读 4 列
- 如果只读 3 列，description 就不会进缓存
desc.replace("\t", " ").replace("\n", " ")
- 防止描述里出现换行或 tab，破坏 shell 侧解析
_CONDA_CMD_REGISTRY_LOADED
- 避免每次都反复解析 JSON，提高性能

4. 通用分发器

分发器根据注册表决定如何执行命令：

_conda_dispatch() {
    local subcommand="$1"
    shift

    _conda_load_command_registry || return 1

    local cmd_type="${_CONDA_CMD_TYPE_MAP[$subcommand]}"
    local target="${_CONDA_CMD_TARGET_MAP[$subcommand]}"
    [[ -z "$cmd_type" || -z "$target" ]] && return 1

    case "$cmd_type" in
        function)
            if typeset -f "$target" >/dev/null 2>&1; then
                "$target" "$@"
            else
                echo "conda 子命令 '$subcommand' 对应函数 '$target' 不存在。" >&2
                return 1
            fi
            ;;
        micromamba)
            _conda_exec_mamba "$target" "$@"
            ;;
        *)
            echo "conda 子命令 '$subcommand' 的类型 '$cmd_type' 不支持。" >&2
            return 1
            ;;
    esac
}

这段逻辑的价值在于：

conda 本身不再关心每个命令细节
它只负责查注册表，然后调用正确执行方式
后续如果你想支持更多类型，比如：
- alias
- script
- shell
- python 也可以继续扩展

5. 自定义 help 输出

当用户只输入 conda 时，希望除了原生 micromamba help，还能看到自定义命令及说明。

例如：

_conda_print_custom_help() {
    _conda_load_command_registry || return 0

    local cmd
    echo ""
    echo "Custom subcommands:"
    for cmd in ${(k)_CONDA_CMD_TYPE_MAP}; do
        local desc="${_CONDA_CMD_DESC_MAP[$cmd]}"
        if [[ -n "$desc" ]]; then
            echo "  ${cmd} - ${desc}"
        else
            echo "  ${cmd}"
        fi
    done
    echo ""
    echo "Use 'conda <subcommand> ...' to run a custom command."
}

输出效果类似：

Custom subcommands:
  de - 停用当前环境（等价于 micromamba deactivate）。
  ac - 根据当前目录匹配 ~/.conda_map.ini 并激活对应环境（可用于手动触发）。
  map - 维护路径->环境映射：map curr 写入当前目录；map 打开 ~/.conda_map.ini。

Use 'conda <subcommand> ...' to run a custom command.

这样用户执行 conda 时，既不会丢掉原生帮助，又能顺便看到你自己的扩展命令。

6. `conda()` 统一入口

最后把入口收束成一个非常干净的函数：

conda() {
    if [[ $# -eq 0 ]]; then
        _conda_exec_mamba
        _conda_print_custom_help
        return 0
    fi

    local subcommand="$1"
    if [[ -n "$subcommand" ]] && _conda_dispatch "$subcommand" "${@:2}"; then
        return $?
    fi
    _conda_exec_mamba "$@"
}

这里的行为很自然：

无参数：显示原生 help + 自定义 help
注册命令：走自定义逻辑
非注册命令：回落到原始 micromamba

这就是整个框架的主入口。

五、如何实现具体子命令

1. `ac`：根据目录映射激活环境

这个命令通常会依赖两个辅助函数：

_load_auto_map
_find_env_for_dir

然后由 _auto_activate_on_cd 决定是否切换环境，最后由 _conda_cmd_ac 调用它。

思路如下：

读取 ~/.conda_map.ini
找到与当前目录最匹配的前缀
如果找到目标环境且当前环境不同，则执行 conda activate
如果没找到目标环境且当前环境不是 base，则执行 conda deactivate

这样你只需要运行：

conda ac

就可以手动按目录切环境。

2. `de`：快速停用环境

这个命令最适合注册成 micromamba 类型：

"de": {
  "type": "micromamba",
  "target": "deactivate",
  "description": "停用当前环境（等价于 micromamba deactivate）。"
}

这样无需写实现函数，框架会自动转发到：

micromamba deactivate

优点是非常轻量。

3. `map`：维护目录和环境映射

map 适合写成函数型命令，因为它有分支逻辑：

conda map curr
- 把当前目录和当前激活环境写入 ~/.conda_map.ini
conda map
- 直接打开 ~/.conda_map.ini 编辑

这类“带业务状态、带文件读写”的命令，用函数承载更清晰。

六、目录环境映射文件怎么设计

映射文件 ~/.conda_map.ini 可以做成很简单的键值格式：

/home/<username>/project/a = py38
/home/<username>/project/b = ml
/home/<username>/workspace/demo = testenv

解析规则可以是：

一行一个映射
= 左边是目录
= 右边是环境名
支持注释行
支持去除首尾空白

匹配时使用“最长前缀优先”，例如：

当前目录：/home/<username>/project/a/subdir
已有映射：
- /home/<username>/project = base-env
- /home/<username>/project/a = py38

最终应选择 py38，因为它的路径前缀更长、更具体。

这是很实用的一个策略。

七、新增一个子命令要怎么做

这是这套框架最重要的价值所在。

假设你想新增一个 conda lsmap，用于打印当前所有映射。

方式一：函数型命令

先在 JSON 中注册：

"lsmap": {
  "type": "function",
  "target": "_conda_cmd_lsmap",
  "description": "列出当前所有目录到环境的映射。"
}

再在 conda-wrapper.zsh 中实现：

_conda_cmd_lsmap() {
    local file="$HOME/.conda_map.ini"
    if [[ ! -f "$file" ]]; then
        echo "映射文件不存在：$file"
        return 1
    fi
    sed '/^\s*[#;]/d; /^\s*$/d' "$file"
}

然后重新加载：

source ~/.zshrc

现在就能使用：

conda lsmap

并且 conda help 中也会自动出现对应说明。

方式二：直接转发到 `micromamba`

如果你只是想做某个简短别名，也可以直接注册成 micromamba 类型。

例如：

"rm": {
  "type": "micromamba",
  "target": "remove",
  "description": "删除当前环境中的包（等价于 micromamba remove）。"
}

这样就能用：

conda rm numpy

它会等价执行：

micromamba remove numpy

八、为什么这种设计比在 `~/.zshrc` 里硬写 `case` 更好

1. 结构更清晰

原先所有逻辑混在一个函数里，新增命令时越来越乱。现在分成：

注册
分发
实现

职责很明确。

2. 扩展成本更低

新增命令只需要：

改 JSON
加函数

不需要反复修改分发主逻辑。

3. help 自动生成

命令和说明写在同一个 JSON 中，不容易出现“实现变了、帮助文案没改”的情况。

4. `~/.zshrc` 更干净

把复杂逻辑移出 ~/.zshrc 后，shell 初始化文件更易读，也更方便迁移和备份。

5. 后续可继续演化

比如未来你可以进一步加上：

hidden: true
usage
examples
aliases
group
order

把这个小框架逐步做成真正可维护的 CLI 扩展层。

九、部署时的常见坑

1. `description` 没显示

这是最容易踩的坑之一。

如果你 JSON 里有：

"description": "xxx"

但 help 里没显示，通常原因是 shell 读取时没有把描述字段读出来。

比如如果你写成：

while IFS=$'\t' read -r key type target; do

那就只读了 3 列，第四列 desc 会丢失。

正确写法必须是：

while IFS=$'\t' read -r key type target desc; do

并且要写入：

_CONDA_CMD_DESC_MAP[$key]="$desc"

2. `micromamba` 在某些 shell 中不可用

有时你手动 source 某个文件时，micromamba 不一定在 PATH 里。建议统一通过 _conda_exec_mamba 执行，并回退到 $MAMBA_EXE。

否则会出现：

command not found: micromamba

3. JSON 描述里包含换行或 tab

如果你直接把 JSON 的 description 原样打印为 tab 分隔数据，shell 解析时可能错位。

建议在 Python 侧先做清理：

desc = desc.replace("\t", " ").replace("\n", " ")

4. `activate` / `deactivate` 需要在 shell 环境生效

环境切换不是普通可执行程序逻辑。如果 micromamba shell hook 没有正确初始化，activate/deactivate 就可能行为不符合预期。

所以一定要确保 mamba initialize 块有效。

十、可以继续增强的方向

这套框架已经够实用，但如果你想把它继续产品化，还可以加这些能力。

1. 命令顺序控制

现在 help 中的顺序通常取决于解析和关联数组的枚举方式，不一定稳定。你可以在 JSON 中增加：

"order": 10

然后在 Python 解析时按 order 排序输出。

2. 支持别名

例如：

"deactivate": {
  "type": "micromamba",
  "target": "deactivate",
  "description": "停用当前环境。",
  "aliases": ["de"]
}

这样 help 中可以同时显示别名，或者允许多个入口指向同一个实现。

3. 支持示例输出

增加：

"examples": [
  "conda map curr",
  "conda ac"
]

然后在 conda help <subcommand> 中展示更详细帮助。

4. 支持 `conda commands`

可以新增一个框架级命令，列出所有已注册命令及类型、说明，用于调试注册表。

5. 自动监听 `cd`

你当前的自动激活逻辑如果只是手动调用 conda ac，已经够稳。如果想进一步实现“每次 cd 自动切环境”，可以挂载 chpwd hook。

不过这个行为更激进，建议先确认你确实需要，否则有时会让 shell 行为变得过于“主动”。

十一、一套可落地的最小工作流程

如果你现在要从零部署，推荐按下面顺序：

保证 micromamba shell init 已在 ~/.zshrc 中生效
新建目录：
```
mkdir -p ~/.zsh
```
创建注册表：
- ~/.zsh/conda-commands.json
创建主逻辑文件：
- ~/.zsh/conda-wrapper.zsh
在 ~/.zshrc 中加入：
```
source "$HOME/.zsh/conda-wrapper.zsh"
```
重新加载：
```
source ~/.zshrc
```
验证：
```
conda
conda ac
conda de
conda map
```

十二、总结

这套方案本质上是把 shell 中零散的“命令快捷方式”升级成了一个简易命令框架。

它的核心价值不在于“能不能跑”，而在于：

是否容易维护
是否容易扩展
是否能把命令定义、说明和实现分开
是否能让 ~/.zshrc 保持干净

通过 JSON 注册 + 通用分发 + 独立实现 这三层结构，你就可以把原本容易失控的 conda() 包装函数，整理成一个长期可演进的小系统。

如果你的 shell 中已经存在越来越多的“我自己常用的小命令”，这类思路其实不只适用于 conda，同样也可以推广到：

git 增强命令
docker 快捷命令
项目脚手架命令
本地开发环境切换命令

适合迁移到这套结构的判断标准很直接：自定义命令已经需要独立说明、频繁增删，或者一个 case 分支开始牵动其他逻辑。只有少量固定别名时，继续保留简单函数反而更容易维护。

机器学习环境配置

Tue, 28 Oct 2025 00:00:00 GMT

为什么选择 micromamba

micromamba 是使用 conda-forge channel 的 Conda 兼容环境管理器。相比完整 Conda，它更适合无 root 权限的服务器和需要控制安装体积的场景：

使用静态链接的 C++ 可执行文件，安装后可以直接运行；
默认使用 conda-forge channel，软件包覆盖范围较广；
不需要 root 权限，安装和卸载都在用户目录中完成；
安装体积较小，适合服务器环境。

micromamba 也可以管理 JDK、Node.js 和 CUDA 等 Conda 包。是否使用这些包，仍应根据项目需求决定。

[!TIP] 现在可以使用conda进行jdk,node,甚至cuda的安装管理以及隔离

安装 micromamba

[!NOTE] 下面使用官方安装脚本，不依赖 Homebrew。

官方指导：link

mac, linux, windows git bash:

"${SHELL}" <(curl -L micro.mamba.pm/install.sh)

自动升级：

micromamba self-update

在远程 VS Code 中使用 micromamba

安装 Python 与 Python Environments 扩展后，可以让远程 VS Code 将 micromamba 作为 Conda 兼容的环境管理器使用。

远程主机设置

通过 Remote SSH 连接服务器后，打开命令面板，执行 Preferences: Open Remote Settings (JSON)。对应的远程配置文件通常位于：

~/.vscode-server/data/Machine/settings.json

加入以下配置：

{
  "python-envs.defaultEnvManager": "ms-python.python:conda",
  "python.condaPath": "~/micromamba/micromamba"
}

其中 python.condaPath 必须指向远程服务器上的 micromamba 可执行文件。如果安装位置不同，可以先执行以下命令确认：

command -v micromamba

[!IMPORTANT] 示例使用 ~ 表示当前用户的 home 目录，避免在共享配置、截图或文章中暴露真实用户名。请不要直接写入 /home/<username>/... 或其他包含个人账号的绝对路径。

项目设置

在项目根目录创建或编辑 .vscode/settings.json：

{
  "python-envs.pythonProjects": [
    {
      "path": ".",
      "envManager": "ms-python.python:conda",
      "packageManager": "ms-python.python:conda"
    }
  ]
}

这里将当前目录声明为 Python 项目，并指定使用 Conda 兼容的环境与包管理器；实际执行程序由远程主机设置中的 python.condaPath 指向 micromamba。

[!NOTE] python.condaPath 属于远程主机级设置，不要提交到项目的 .vscode/settings.json。这样既能避免泄露服务器目录结构，也能让不同开发者分别配置自己的安装路径。

保存后执行 Developer: Reload Window，再通过 Python: Select Interpreter 或侧边栏的 Python Environments 视图选择环境。若环境未出现，可执行 Python Environments: Refresh All Environment Managers 后重试。

按目录自动加载 Conda 环境

使用bashrc自动加载(仅在终端创建时自动)文件夹的 conda 环境

可使用man命令来加载最合适的环境(未指定则用父文件夹的)

<!-- ~/.zshrc -->
# --- 自动按路径激活 micromamba 环境（从 ~/.conda_map.ini 读取） ---
_load_auto_map() {
    local file="$HOME/.conda_map.ini"
    typeset -gA AUTO_ACTIVATE_MAP
    [[ -f "$file" ]] || return
    local line key val
    while IFS= read -r line || [[ -n "$line" ]]; do
        # 删除注释（# 或 ;）和首尾空白
        line="${line%%[#;]*}"
        line="${line#"${line%%[![:space:]]*}"}"
        line="${line%"${line##*[![:space:]]}"}"
        [[ -z "$line" ]] && continue
        if [[ "$line" == *=* ]]; then
            key="${line%%=*}"
            val="${line#*=}"
            key="${key#"${key%%[![:space:]]*}"}"; key="${key%"${key##*[![:space:]]}"}"
            val="${val#"${val%%[![:space:]]*}"}"; val="${val%"${val##*[![:space:]]}"}"
            AUTO_ACTIVATE_MAP[$key]="$val"
        fi
    done < "$file"
}

_find_env_for_dir() {
    local pwd="$PWD"
    local best_prefix=""
    local best_env=""
    local prefix
    for prefix in "${(@k)AUTO_ACTIVATE_MAP}"; do
        # 确保以目录前缀匹配（支持不带斜杠的写法）
        if [[ "${pwd%/}" == "${prefix%/}"* ]]; then
            if (( ${#prefix} > ${#best_prefix} )); then
                best_prefix="$prefix"
                best_env="${AUTO_ACTIVATE_MAP[$prefix]}"
            fi
        fi
    done
    printf '%s' "$best_env"
}

_auto_activate_on_cd() {
    _load_auto_map
    local target_env cur_env
    target_env="$(_find_env_for_dir)"

    cur_env="${CONDA_DEFAULT_ENV:-}"
    if [[ -z "$cur_env" && -n "$CONDA_PREFIX" ]]; then
        cur_env="$(basename "$CONDA_PREFIX")"
    fi

    if [[ -n "$target_env" ]]; then
        if [[ "$cur_env" != "$target_env" ]]; then
            conda activate "$target_env" >/dev/null 2>&1 || true
        fi
    else
        if [[ -n "$cur_env" && "$cur_env" != "base" ]]; then
            conda deactivate >/dev/null 2>&1 || true
        fi
    fi
}
_auto_activate_on_cd
alias ac=_auto_activate_on_cd
# ac 来手动激活对应环境（前缀匹配激活，子文件夹都可用）
# --- 结束 自动激活 ---

<!-- ~/.bashrc -->
# --- 自动按路径激活 micromamba 环境（从 ~/.conda_map.ini 读取） ---
_load_auto_map() {
    local file="$HOME/.conda_map.ini"
    # 使用全局关联数组
    declare -gA AUTO_ACTIVATE_MAP=()
    [[ -f "$file" ]] || return
    local line key val
    while IFS= read -r line || [[ -n "$line" ]]; do
        # 删除注释（# 或 ;）和首尾空白
        line="${line%%[#;]*}"
        line="${line#"${line%%[![:space:]]*}"}"
        line="${line%"${line##*[![:space:]]}"}"
        [[ -z "$line" ]] && continue
        if [[ "$line" =~ ^([^=]+)=(.+)$ ]]; then
            key="${BASH_REMATCH[1]}"
            val="${BASH_REMATCH[2]}"
            key="${key#"${key%%[![:space:]]*}"}"; key="${key%"${key##*[![:space:]]}"}"
            val="${val#"${val%%[![:space:]]*}"}"; val="${val%"${val##*[![:space:]]}"}"
            AUTO_ACTIVATE_MAP["$key"]="$val"
        fi
    done < "$file"
}

_find_env_for_dir() {
    local pwd="$PWD"
    local best_prefix=""
    local best_env=""
    local prefix
    for prefix in "${!AUTO_ACTIVATE_MAP[@]}"; do
        # 确保以目录前缀匹配（支持不带斜杠的写法）
        if [[ "${pwd%/}" == "${prefix%/}"* ]]; then
            if (( ${#prefix} > ${#best_prefix} )); then
                best_prefix="$prefix"
                best_env="${AUTO_ACTIVATE_MAP[$prefix]}"
            fi
        fi
    done
    printf '%s' "$best_env"
}

_auto_activate_on_cd() {
    _load_auto_map
    local target_env cur_env
    target_env="$(_find_env_for_dir)"

    cur_env="${CONDA_DEFAULT_ENV:-}"
    if [[ -z "$cur_env" && -n "$CONDA_PREFIX" ]]; then
        cur_env="$(basename "$CONDA_PREFIX")"
    fi

    if [[ -n "$target_env" ]]; then
        if [[ "$cur_env" != "$target_env" ]]; then
            conda activate "$target_env" >/dev/null 2>&1 || true
        fi
    else
        if [[ -n "$cur_env" && "$cur_env" != "base" ]]; then
            conda deactivate >/dev/null 2>&1 || true
        fi
    fi
}
_auto_activate_on_cd
alias ac=_auto_activate_on_cd
# ac 来手动激活对应环境（前缀匹配激活，子文件夹都可用）
# --- 结束 自动激活 ---

验收结果

无 root 权限或希望减少安装体积时，推荐使用 micromamba 管理 Conda 环境。
远程 VS Code 中，将 python.condaPath 指向 micromamba，并为项目设置 Conda 环境管理器，即可完成环境发现、选择和包管理。
主机相关路径应放在远程 Machine 设置中，项目配置只保留可共享内容，避免暴露用户名和服务器目录结构。

Mihomo 设置指南

Sun, 05 Oct 2025 00:00:00 GMT

Android

将新模块推送到 Mihomo 配置目录：

adb push "$HOME/Downloads/TT/Clash配置.yaml" /sdcard/Android/Clash

macOS

macOS 版 Clash Verge Rev 在这台设备上运行不稳定，改为直接运行 Mihomo 内核。

macOS sudo mv mihomo.plist /Library/LaunchDaemons
# 加载服务
sudo launchctl load /Library/LaunchDaemons/mihomo.plist
# 查看服务
sudo launchctl list | grep mihomo
# 卸载停止服务
sudo launchctl unload /Library/LaunchDaemons/mihomo.plist

# 启动服务
sudo launchctl start mihomo
# 停止服务
sudo launchctl stop mihomo

macOS TUN 与 DNS 排查

记录日期：2026-08-12。

macOS 使用 Mihomo TUN 时，抖音、百度等国内网站明显卡顿，Google 也无法访问。关闭 TUN 后恢复正常，设置系统 SOCKS 代理后 Google 可以访问。

排查确认问题不在代理节点或规则：即使切换为全局 DIRECT，流量仍然需要经过 TUN 入站协议栈，因此 TUN 路径异常依然会影响连接。将 TUN 从 gvisor 调整为 system，移除无效的 device: wlan9，关闭 strict-route 和 IPv6，并将 MTU 调整为 1380 后，仍未解决 Google 访问问题。

最终确认根因是 macOS 的局域网 DNS 没有被 Mihomo 劫持。系统 DNS 指向路由器（例如 192.168.x.1），同时配置又排除了整个局域网地址段：

tun:
  enable: true
  stack: system
  auto-route: true
  auto-detect-interface: false
  dns-hijack:
    - any:53
    - tcp://any:53
  strict-route: false
  mtu: 1380
  route-exclude-address:
    - 192.168.0.0/16
    - fc00::/7

interface-name: en0
ipv6: false

由于路由器地址位于被排除的 192.168.0.0/16 中，发往路由器的 53 端口请求不会进入 TUN，dns-hijack 无法生效。路由器当时为 www.google.com 返回了错误的公网地址，而 Mihomo DNS 返回的是正常的 Fake-IP 198.18.x.x。显式设置 SOCKS 代理时，域名直接交给 Mihomo，所以 Google 可以访问。

解决方法是把 macOS Wi-Fi 的普通 DNS 改为公网 DNS，使 53 端口查询进入 TUN 后由 Mihomo 劫持：

sudo networksetup -setdnsservers Wi-Fi 223.5.5.5 119.29.29.29
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder

修改后可通过以下命令验证：

dscacheutil -q host -a name www.google.com

开启 Fake-IP TUN 时，正常结果应为 198.18.x.x，而不是路由器返回的错误公网 IP。

修改普通 DNS 不会使 Bonjour/mDNS 失效。mDNS 使用 UDP 5353 和组播地址 224.0.0.251/FF02::FB，与普通 DNS 的 53 端口不同；.local 设备发现、AirPlay、AirDrop 和 Bonjour 打印机仍可正常工作。可能受影响的是由路由器普通 DNS 提供的 nas、router.lan 等内部域名，而不是 设备名.local。可使用 dns-sd -G v4v6 设备名.local 验证 mDNS。

VS Code macOS C++ 环境配置

Wed, 27 Aug 2025 00:00:00 GMT

这套配置用于在 macOS 的 VS Code 中编译、运行和调试单文件 C++ 程序。编译器使用系统 Clang，调试器使用 LLDB。

扩展

安装以下扩展：

C/C++ 语言支持；
CodeLLDB；
Code Runner（仅用于快速运行，不代替调试配置）。

配置文件

tasks.json 定义编译任务；
launch.json 定义 F5 调试入口；
settings.json 配置头文件关联和 Code Runner 参数。

<!-- launch.json -->
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug C++",
            "type": "lldb",
            "request": "launch",
            "program": "${fileDirname}/bin/${fileBasenameNoExtension}",
            "args": [],
            "cwd": "${workspaceFolder}",
            "preLaunchTask": "build",
            "console": "integratedTerminal"
        }
    ]
}

<!-- tasks.json -->
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "mkdir",
            "args": [
                "-p",
                "${fileDirname}/bin",
                "&&",
                "g++",
                "-std=c++17",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/bin/${fileBasenameNoExtension}"
            ],
            "group": "build",
            "problemMatcher": [
                "$gcc"
            ]
        }
    ]
}

<!--settings.json ->
{
    // C++扩展配置
    "C_Cpp.default.includePath": [
        "${workspaceFolder}/cpp_includes",
        "${workspaceFolder}/**"
    ],
    "C_Cpp.default.compilerPath": "/usr/bin/g++",
    "C_Cpp.default.cppStandard": "c++17",
    "C_Cpp.default.intelliSenseMode": "macos-gcc-arm64",

    // Code Runner配置 - 与C++扩展保持一致的头文件路径
    "code-runner.executorMap": {
        "cpp": "cd$workspaceRoot && mkdir -p bin && g++ -std=c++17 -O2 -g -I cpp_includes $fullFileName -o ./bin/$fileNameWithoutExt && ./bin/$fileNameWithoutExt"
    },
    "code-runner.runInTerminal": true,
    "code-runner.saveFileBeforeRun": true,
    "code-runner.clearPreviousOutput": false,
    "code-runner.preserveFocus": false,
    "code-runner.showExecutionMessage": true,

    // 文件关联
    "files.associations": {
        "*.h": "cpp",
        "*.hpp": "cpp",
        "*.cpp": "cpp",
        "*.cc": "cpp",
        "*.cxx": "cpp"
    }
}

LeetCode 刷题列表

Tue, 26 Aug 2025 00:00:00 GMT

这份列表按数据结构和算法主题整理 LeetCode 题目，用于记录刷题范围与后续复盘。编号沿用原始笔记顺序，不代表推荐完成顺序。

第一章：基础数据结构

数组双指针

⼆分搜索

在排序数组中查找元素的第⼀个和最后⼀个位置
⼆分查找
搜索插⼊位置
俄罗斯套娃信封问题
判断⼦序列
阶乘函数后 K 个零
爱吃⾹蕉的珂珂
在 D 天内送达包裹的能⼒

滑动窗⼝

⽆重复字符的最⻓⼦串
最⼩覆盖⼦串
找到字符串中所有字⺟异位词
字符串的排列
滑动窗⼝最⼤值

其他题⽬

三数之和
四数之和
⼩于 K 的两数之和
删除有序数组中的重复项
移除元素
移动零
最接近的三数之和
区间列表的交集
盛最多⽔的容器
接⾬⽔
优势洗牌
较⼩的三数之和

链表双指针

两数相加
删除链表的倒数第 N 个结点
合并两个有序链表
合并 K 个升序链表
环形链表
环形链表 II
相交链表
链表的中间结点
K 个⼀组翻转链表
删除排序链表中的重复元素
反转链表 II
回⽂链表

前缀和

区域和检索 - 数组不可变
⼆维区域和检索 - 矩阵不可变
和为 K 的⼦数组

差分数组

区间加法
拼⻋
航班预订统计

队列/栈算法

有效的括号
使括号有效的最少添加
平衡括号字符串的最少插⼊次数
最⻓有效括号
⽤队列实现栈
⽤栈实现队列
滑动窗⼝最⼤值

⼆叉堆

合并 K 个升序链表
数组中的第 K 个最⼤元素
数据流的中位数
数据流中的第 K ⼤元素

数据结构设计

LRU 缓存机制
扁平化嵌套列表迭代器
O(1) 时间插⼊、删除和获取随机元素
LFU 缓存
最⼤频率栈

第二章：进阶数据结构

⼆叉树

⼆叉树的中序遍历
相同的树
⼆叉树的层序遍历在线⽹站
⼆叉树的锯⻮形层序遍历
⼆叉树的最⼤深度
从前序与中序遍历序列构造⼆叉树
从中序与后序遍历序列构造⼆叉树
最⼤⼆叉树
⼆叉树的层序遍历 II
⼆叉树的最⼩深度
⼆叉树展开为链表
填充每个节点的下⼀个右侧节点指针
翻转⼆叉树
⼆叉树的前序遍历
⼆叉树的后序遍历
完全⼆叉树的节点个数
⼆叉树的最近公共祖先
⼆叉树的序列化与反序列化
扁平化嵌套列表迭代器
⼆叉搜索树中的众数
⼆叉树的直径
N 叉树的最⼤深度
N 叉树的前序遍历
N 叉树的后序遍历
寻找重复的⼦树
单值⼆叉树

⼆叉搜索树

不同的⼆叉搜索树 II
不同的⼆叉搜索树
验证⼆叉搜索树
删除⼆叉搜索树中的节点
⼆叉搜索树中的搜索
⼆叉搜索树中的插⼊操作
⼆叉搜索树中第 K ⼩的元素
把⼆叉搜索树转换为累加树
把⼆叉搜索树转换为累加树
⼆叉搜索树中的众数
⼆叉搜索树的最⼩绝对差
⼆叉搜索树节点最⼩距离
⼆叉搜索⼦树的最⼤键值和

图论算法

图的遍历

所有可能的路径

⼆分图

判断⼆分图
可能的⼆分法#### 环检测/拓扑排序
课程表
课程表 II

并查集算法

被围绕的区域
等式⽅程的可满⾜性
情侣牵⼿

最⼩⽣成树

以图判树
最低成本联通所有城市
连接所有点的最⼩费⽤

最短路径

⽹络延迟时间
概率最⼤的路径
最⼩体⼒消耗路径

第三章：暴力搜索

回溯算法

电话号码的字⺟组合
括号⽣成
解数独
组合总和
全排列
组合
⼦集
N 皇后
⼆叉树的最⼤深度
⽬标和
划分为 k 个相等的⼦集

DFS 算法

被围绕的区域
岛屿数量
不同的岛屿数量
岛屿的最⼤⾯积
⻜地的数量
统计封闭岛屿的数⽬
统计⼦岛屿

BFS 算法

⼆叉树的层序遍历
⼆叉树的锯⻮形层序遍历
⼆叉树的层序遍历 II
⼆叉树的最⼩深度
打开转盘锁
滑动谜题

第四章：动态规划

⼀维 DP

跳跃游戏 II
跳跃游戏
最⼤⼦序和
爬楼梯
打家劫舍
打家劫舍 II
打家劫舍 III
最⻓递增⼦序列
零钱兑换
俄罗斯套娃信封问题

⼆维 DP

正则表达式匹配
不同路径
最⼩路径和
编辑距离
买卖股票的最佳时机
买卖股票的最佳时机 II
买卖股票的最佳时机 III
买卖股票的最佳时机 IV
最佳买卖股票时机含冷冻期
买卖股票的最佳时机含⼿续费
地下城游戏
戳⽓球
分割等和⼦集
⽬标和
⾃由之路
零钱兑换 II
两个字符串的删除操作
两个字符串的最⼩ ASCII 删除和
最⻓公共⼦序列
K 站中转内最便宜的航班
鸡蛋掉落
下降路径最⼩和

背包问题

分割等和⼦集
⽬标和
零钱兑换 II

第五章：其他经典算法

数学算法

电话号码的字⺟组合
组合
⼦集
加油站
只出现⼀次的数字
位 1 的个数
2 的幂
阶乘后的零
阶乘函数后 K 个零
计数质数
丢失的数字
Nim 游戏
灯泡开关
⽯⼦游戏
数据流的中位数
超级次⽅
链表随机节点
随机数索引
完美矩形
斐波那契数
错误的集合
⿊名单中的随机数

区间问题

合并区间
区间列表的交集
删除被覆盖区间
⽆重叠区间
⽤最少数量的箭引爆⽓球
视频拼接
单线程 CPU

Cloudflare 加速实践

Wed, 20 Aug 2025 00:00:00 GMT

这次测试以 blog.pinellia.uk 为例，目标是改善 Cloudflare 服务在国内网络中的直连表现。参考方案来自 BestWorkers。

测试结果

ITDOG TCPing 正常

ITDOG 的 TCPing 测试全部通过，但电脑和平板直连时仍然经常无法访问：

curl: (35) LibreSSL SSL_connect: SSL_ERROR_SYSCALL in connection to blog.pinellia.uk
浏览器：ERR_CONNECTION_CLOSED

排除 DNS 解析差异

Clash 的 DNS 解析结果与 ITDOG 一致：

解析出的 IP 可以 Ping 通，走代理时也能正常连接，因此问题不像是单纯的 DNS 解析错误。测试期间没有找到稳定复现的具体原因；电脑和平板等待一段时间后恢复直连。

这次调整没有形成可以验证的加速结论。后续排查应分别记录 DNS 结果、TLS 握手、路由和不同运营商网络下的表现，不能只根据 TCPing 全绿判断站点已经可用。

夹带私货：简单文件隐写

Wed, 20 Aug 2025 00:00:00 GMT

这是一种利用文件格式解析差异实现的简单隐藏方式：把 ZIP 数据追加到图片末尾。图片查看器通常仍按图片格式显示文件，binwalk 等工具则能识别并提取后面的压缩包。

参考：文件隐写示例。

[!WARNING] 这不是加密。任何知道文件结构的人都可以扫描并提取追加内容，不适合保护敏感数据。

操作过程

隐写

先把待隐藏内容打包为 a.zip，再追加到 b.png：

cat a.zip >> b.png

图片外观不变，但文件大小会增加。 <p align="center"> <img src="https://ipfs.pinellia.uk/ipfs/QmTMVbJQhP77CQm4bT5BEudQBCEbExLsDT2ybNQFHTTzGZ" alt="" width="40%" /> <br/> <img src="https://ipfs.pinellia.uk/ipfs/QmXrvW7ob9uXPcmQcdCFBXXX7hbnH6KeXin3kXtyXdcJLZ" alt="" width="40%" /> </p>

拆解

这里借用 binwalk命令进行拆解，也可以使用其他的，建议参考上面的知乎。

使用 binwalk b.png 查看文件结构：输出中应同时识别出图片和 ZIP 数据。

使用 binwalk -e b.png 提取文件：提取目录会以 ZIP 数据的起始偏移命名，其中包含解压后的文件。

注意事项

建议先把待隐藏文件打包。Word 和 PDF 等格式本身可能包含多个数据结构，直接追加会增加 binwalk 判断和提取的难度。

如果自动提取失败，可以根据起止偏移使用 dd 手动截取。打包只会改善识别和组织方式，不会提供加密保护。

Python 环境配置

Fri, 08 Aug 2025 00:00:00 GMT

这篇短文保留一段 Python 环境配置视频，并补充工具选择结论。需要在无 root 服务器上部署时，可改用体积更小的 micromamba。

介绍视频

选择建议

需要完整 Conda 体验时使用 Miniconda，代价是安装和环境求解相对较重。
已经使用 conda-forge 时，可以用 mamba 加快依赖求解。
无 root 权限或希望减少安装体积时，优先考虑 micromamba。

PTA 天梯赛 L1 刷题总结（二）：10 分题型

Wed, 26 Feb 2025 00:00:00 GMT

这组 10 分题主要考查输入输出、基础分支、循环和 STL 的直接使用。题目通常按样例逐组处理，不必为了“最后统一输出”而额外保存全部输入。

需要反复检查的细节有三项：计数变量初始化、行尾空格和换行位置。

1. 数字与拼音映射

L1-007 念数字

输入一个整数，逐位输出对应拼音；负数先输出 fu。数字与拼音是一一映射关系，直接按字符串读取可以保留原始顺序，也能自然处理负号。

下面保留三种实现用于比较。第一种按整数取模，需要逆序保存各位数字：

#include <stdio.h>
#include <stdlib.h>

void num(int s)
{
switch (s)
{
case 1:
printf("yi");break;
case 2:
printf("er");break;
case 3:
printf("san");break;
case 4:
printf("si");break;
case 5:
printf("wu");break;
case 6:
printf("liu");break;
case 7:
printf("qi");break;
case 8:
printf("ba");break;
case 9:
printf("jiu");break;
case 0:
printf("ling");break;
}
}
int main()
{
int n,i,j;
int a[100]={0};
scanf("%d",&n);
if(n<0)
  {
       printf("fu ");
       n*=(-1);
  }
   i=0;
   while(n/10)
  {
       a[i++]=n%10;
       n/=10;
  }
   a[i]=n;
   for(j=i;j>=0;j--)
  {
       if(j==0) num(a[j]);
       else
      {
           num(a[j]);
           printf(" ");
      }
  }
return 0;
}

二维字符数组

strlen(s) 获取字符串长度，s[i] - '0' 将数字字符转换为对应整数。只有两种分支时，可以使用条件运算符简化标志位初始化：

#include <iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int main() {
   char a[10][10] = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};
   char s[1000];
   scanf("%s",s);
   int len=strlen(s);
   int flag = s[0] == '-' ? 1 : 0;
   if(flag == 1)
      printf("fu");
   for(int i = flag; i < len; i++)
  {
       if(i == 0)
      {
           printf("%s",a[s[i]-'0']);
           continue;
      }

       printf(" %s",a[s[i]-'0']);
  }
   return 0;
}

`string` 数组

使用 flag 记录起始下标。若首字符为 '-'，先输出 fu，再从下标 1 开始查表：

#include <iostream>
#include <string>

using namespace std;

int main()
{
   string s[10]={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
   string a;
   int h;
   int i,flag;
   flag=0;
   cin>>a;
   if(a[0]=='-')
  {
       flag=1;
       cout<<"fu ";
  }
   for(int i=flag;a[i]!='\0';i++)
  {
        h = a[i]-'0';
       if(i<a.length()-1)
           cout<<s[h]<<" ";
       else
            cout<<s[h];
  }

   return 0;
}

2. 排序

L1-010 比较大小

std::sort(first, last) 默认升序排列左闭右开区间。数组有三个元素时，范围写作 sort(a, a + 3)；需要其他顺序时再提供比较函数：

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
   int a[3];
   cin>>a[0]>>a[1]>>a[2];
   sort(a,a+3);
   for(int i=0;i<3;i++)
  {
       if(i<2)
           cout<<a[i]<<"->";
       else cout<<a[i];
  }
   return 0;
}

3. 格式化输出

L1-008 求整数段和

printf("%5d", value) 将整数按 5 个字符宽度右对齐。用计数器控制每 5 个数换行，同时避免在最后一个数后多输出空行：

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
   int m,n,flag,sum;
   cin>>m>>n;
   sum=flag=0;
   for(int i=m;i<=n;i++)
  {
       printf("%5d",i);
       flag++;
       if(flag%5==0&&i!=n)
           printf("\n");
       sum+=i;
  }
   cout<<endl;
   cout<<"Sum = "<<sum;
   return 0;
}

4. 分类计算

L1-031 到底是不是太胖了

整数绝对值可使用 abs，浮点数使用 fabs。公共输出逻辑不要误放进某个 else 分支：

#include <iostream>
#include <math.h>
using namespace std;

int main()
{
   int n,W,w,H;
   cin>>n;
   while(n--)
  {
       cin>>H>>W;
       w=(H-100)*1.8;
       if(fabs(W-w)<w*0.1)
           cout<<"You are wan mei!"<<endl;
       else if(W>w)
           cout<<"You are tai pang le!"<<endl;
       else
           cout<<"You are tai shou le!"<<endl;
  }
   return 0;
}

5. 素数判断

L1-028 判断素数

试除范围只需到 sqrt(n)。计数从 2 开始，并单独处理 1 不是素数的边界：

#include <iostream>
#include <math.h>
#include <cstdio>
using namespace std;

int main()
{
   int i,j,n,m;
   cin>>n;
   for(i=0;i<n;i++)
  {
        int flag=0;
        cin>>m;
       for(j=2;j<=sqrt(m);j++)
      {
           if(m%j==0)
          {
               flag=1;
               break;
          }
      }
           if(flag==1||m==1)
               cout<<"No"<<endl;
           else if(flag==0)
               cout<<"Yes"<<endl;
  }
   return 0;
}

6. 满足条件后退出

L1-041 寻找 250

输入数量未知时持续读取；第一次遇到 250 就输出位置并用 break 结束循环：

#include <iostream>
#include <string>
#define N 10010
using namespace std;

int main()
{
   int i;
   int m=0;
   do
  {
       cin>>i;
       if(i==250)
      {
           cout<<m+1;
           break;
      }
       m++;
  }while(1);

   return 0;
}

7. 按规则判断

L1-055 谁是赢家

分别记录观众票数和三名评委的投票，再直接翻译题目的获胜条件。重点是确认 0、1 分别代表哪位选手：

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
   int i,pa,pb,a,b,c,qa,qb;
   cin>>pa>>pb;
   qa=qb=0;
   for(i=0;i<3;i++)
  {
        cin>>a;
        a==0?qa++:qb++;
  }
   if((pa>pb&&qa>=1)||(pa<pb&&qa==3))
       cout<<"The winner is "<<"a"<<": "<<pa<<" + "<<qa;
   else
       cout<<"The winner is "<<"b"<<": "<<pb<<" + "<<qb;
   return 0;
}

PTA 天梯赛 L1 刷题总结（三）：15 分题型

Wed, 26 Feb 2025 00:00:00 GMT

这组 15 分题按核心数据结构与处理方式分为五类：哈希映射、结构体、按题意模拟、字符串和矩阵。先判断题目属于哪一类，再检查输入边界、状态记录和输出格式。

一、哈希映射问题

L1-003 个位数统计

此题中N是一个不超过 1000 位的正整数，遇到这样的问题一般采用字符串遍历的方式解决。（超出了整型的范围）。题目要求对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。

常见实现中，int 是 32 位有符号整数，范围约为 $-2^{31}$ 到 $2^{31}-1$；long long 通常是 64 位，范围约为 $-2^{63}$ 到 $2^{63}-1$。1000 位整数远超这两种类型的范围，应按字符串处理。

思路：

根据题目的要求，第一想到的是用哈希表来存储每位数字对应的次数，这个是一一映射的关系。每一位上就是0到9十个数字，用一个长度为10的整型数组就行。对于出现次数为0的，就不用输出了。这里加个判断就可以。

对于字符串问题，首先先读入每一个字符，遇到一个字符，则对应出现次数+1。最后输出时如果映射的值不为0，则按照格式输出即可。

本题有两个注意点：先用 memset(s, 0, sizeof(s)) 初始化计数数组，并包含 <cstring>；遍历字符串时，str[i] 是字符，需要用 str[i] - '0' 转换为对应数字。

#include <iostream>
#include <string>
#include <string.h>

using namespace std;

int main()
{
   string str;
   int s[10];
   int i;
   cin>>str;
   memset(s,0,sizeof(s)); //关键，对数组初始化都设置为0，否则会出错
   for(i=0;i<str.length();i++)
  {
       s[str[i]-'0']++;    //注意str[i]是一个字符，要str[i]-'0'来转化为int类型
  }
   for(i=0;i<10;i++)
  {
       if(s[i]!=0)
           cout<<i<<":"<<s[i]<<endl;
  }
   return 0;
}

下面给出第二种方法**，博主去刷力扣时的常用方法。我们可以利用map来解决这个哈希数组问题。

这种方法有几个学习点

1）定义map的时候记得加上头文件#include <map>

** 如map<string,int>就是代表从string类型到int类型的映射，且map默认是按key值从小到大排序。

2）访问map容器内元素方法，一个是通过访问下标，比如下方的mp[c-’0’]，还有一种就是通过迭代器（如map<int, int>::iterator it）。通过it->first访问键，it->second访问值。

下边的写法可以这么写

for(map<int,int>::iterator it = mp.begin();it!=mp.end();it++)

{
cout << it->first << ":" << it->second << endl;
}

3）for(char c:str)这是for循环的一个简便写法，遍历字符串str的每一个字符就是c，也就是方法一中的str[i]，比方法一的遍历要方便很多对吧。

#include <iostream>
#include <string>
#include <string.h>
#include <map>

using namespace std;

int main()
{
   string str;
   cin>>str;
   map<int,int> mp;
   for(char c:str)
  {
       mp[c-'0']++;
  }
   map<int, int>::iterator it = mp.begin();

while (it != mp.end()) {
cout << it->first << ":" << it->second << endl;
it++;
}

   return 0;
}

二、结构体问题

L1-005 考试座位号

针对本题，题目的要求是对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。

思路：

** 考虑到每个人是有准考证号、试机座位号、考场座位号的。这时候考虑用结构体代表每个学生。特别是在不同数据类型的变量或数组组合在一起的时候应用结构体能够便于存储。

比如struct studentInfo{int id; char gender; string name;}Bob,stu[10];

其中studentInfo是结构体名，Bob是结构体变量，stu[10]是结构体数组（包含了10个学生的信息）。访问结构体可以通过.或者->

实现：

准考证号是16位数字，可以考虑用string类型来存储。首先遍历给定的N个学生的信息。再依次读入试机号，遍历结构体中是否有相同的试机号，相同则输出其准考证号和考试座位号。

当遍历的次数和循环的内容没有关系时，可以用while(m--)作循环

#include <iostream>
#include <cstdio>
#define N 100000
using namespace std;

struct node
{
   string z;
   int s,k;
}stu[N];
int main()
{
   int i,m,n,l;
   cin>>n;
   for(i=0;i<n;i++)
  {
      cin>>stu[i].z>>stu[i].s>>stu[i].k;
  }
   cin>>m;
   while(m--)
  {
       cin>>l;
       for(i=0;i<n;i++)
      {
           if(stu[i].s==l)
               cout<<stu[i].z<<" "<<stu[i].k<<endl;
      }
  }
   return 0;
}

或者我们可以优化一下，建立试机号到结构体（准考证号，座位号）的映射。下面给出第二种方法**。

#include <iostream>
#include <cstdio>
#include <map>
#define N 100000
using namespace std;

struct node
{
   string z;//准考证号
   int k; //考场座位号
}stu;

int main()
{
   int i,m,n,l;
   map<int,node> mp;
   cin>>n;
   int s;
   for(i=0;i<n;i++)
  {
      cin>>stu.z>>s>>stu.k;
      mp[s] = stu;
  }
   cin>>m;
   while(m--)
  {
       cin>>l;
       cout<<mp[l].z<<" "<<mp[l].k<<endl;
  }
   return 0;
}

L1-030 一帮一

得到全班排名后，在尚未分组的学生中，将名次最靠前的学生与名次最靠后的异性学生配对。每行输出一组姓名，分组顺序按前者名次从高到低排列。

思路：

**因为这道题我们不仅要存这个学生排名、姓名、还要存性别。考虑用结构体来代表每一个学生。

输入已经按照名次大小排列了，那遍历的边界在哪里呢？是n/2。要不然再后面差一点的学生就排到前面去了。

因为要和异性组队，那么是不是有可能出现第一名和最后一名同学是同性，于是第一名和倒数第二名同学组队了，那第二名和最后一名是异性，他们组队。那这时候就得考虑有个标志位来记录这个同学是不是组过队了。**

实现：

结构体我们上面已经说了，可以定义一个大小为N的结构体数组，在头部宏定义#define N 10000

**在输入第i个学生的性别和姓名时，初始化是否组队的标记位为0。

**在输出时，按照名词顺序，用两重循环，外层循环先输出名次高的同学名字，再嵌套一个循环，从j=n-1开始，若不满足j>i则跳出。如果这个同学之前未匹配并且和名次高的同学性别不同，则匹配成功，输出这个同学姓名，并置标记位为1。否则break（只会跳出这一层循环！）

#include <iostream>
#define N 10000
using namespace std;
struct node
{
   int x,f;
   string m;
}s[N];
int main()
{
   int i,j,n;
   cin>>n;
   for(i=0;i<n;i++)
  {
       cin>>s[i].x>>s[i].m;
       s[i].f=0;
  }
   for(i=0;i<n/2;i++)
  {
       for(j=n-1;j>i;j--)
      {
           if(s[i].x!=s[j].x&&s[j].f!=1)
          {
               cout<<s[i].m<<" "<<s[j].m<<endl;
               s[j].f=1;
               break;
          }
      }
  }
   return 0;
}

三、按题意模拟

L1-015 跟奥巴马一起画方块

题目要求是输入在一行中给出正方形边长N，**输出由给定字符C画出的正方形，且输出的行数实际上是列数的50%（四舍五入取整）。

双重循环，外层代表多少行，内层代表多少列。要求行数是列数的50%。给定的边长其实就是列数，那行数是四舍五入求整。

**本题比较简单，**注意点:int类型除法是向下取整，如果要做到四舍五入的话应写为l=(n+1)/2;

L1-016 查验身份证

定义两个数组，一个存储权重，一个存储校验码，按题意对比取模后对应校验码的值是否与身份证最后一位相同即可。为了便于核对，可用字符串类型存储身份证。

L1-017 到底有多二

输入第一行给出整数 N。“犯二的程度”是数字 2 的数量与位数之比；负数将结果乘以 1.5，偶数再乘以 2。

思路：

首先依题意N不超过50位，考虑用字符串类型定义N。遍历字符串记录2的个数。

注意位数需要排除符号位，如果首位是负号，用一个flag位标记是否*1.5（增加0.5倍）那么长度为s.length(）-1（可以用l-flag表示位数）。

看末位是否能被2整除，如果是结果*2。

**注意点：**小数点后保留两位 printf("%.2f",b);。比值要转为double类型。

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
   string s;
   double b;
   int i,cnt=0;
   cin>>s;
   int flag=0;
   if(s[0]=='-') flag=1;
   int l = s.length();
   for(i=flag;i<s.length();i++)
  {
       if(s[i]-'0'==2)
           cnt++;
  }
   b = (double)cnt/(l-flag)*100;
   if(flag==1)
       b*=1.5;
   if((s[l-1]-'0')%2==0)
       b*=2;
   printf("%.2f",b);
   cout<<"%";
   return 0;
}

L1-019 谁先倒

思路：

这题关键点在于判断谁赢谁输。比如甲输的条件是什么？注意同输是进入下一轮的，不喝酒。因此if中有两个判断条件。谁输了谁喝的杯数+1。

在for循环中我们每次遍历都看看是不是有人已经到达他的酒量了。有人倒下就终止（喝的杯数>酒量），输出输家和赢家喝的杯数，用break跳出循环。

注意点：

输入的时候用到getchar(); 目的是清空回车符，从标准输入流读取一个字符，读回车符时退出

最好定义的变量名能够很好的体现含义，特别这题一行四个变量，要避免后面写乱了。

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
   int a,b,n,i,yf,jf,yh,jh,ma,mb;
   ma=mb=0;
   cin>>a>>b;
   getchar();  //不用也可以，目的是清空回车符，从标准输入流读取一个字符，读回车符时退出
   cin>>n;
   for(i=0;i<n;i++)
  {
       cin>>jh>>jf>>yh>>yf;
       if(jf==jh+yh&&yf!=jh+yh)
           ma++;
       if(yf==jh+yh&&jf!=jh+yh)
           mb++;
       if(ma>a||mb>b)
      {
         if(mb>b)
          {
               cout<<"B"<<endl;
               cout<<ma;
          }
          if(ma>a)
          {
              cout<<"A"<<endl;
              cout<<mb;
          }
          break;
      }

  }

   return 0;
}

L1-062 幸运彩票

用字符串保存字符串，再依题意判断输出即可。

L1-069 胎压监测

思路：

这题可以用数组存储各个轮胎的值。求数组中最大值可以用到max()。注意读题内容准确，遍历每个轮胎，看最大值与此轮胎气压差大于阈值或者这个轮胎气压值小于最低气压时，轮胎异常数+1，并且标记轮胎编号。对于异常轮胎个数用一个变量表示，最后根据轮胎异常数为0,1还是>1的情况分别输出结果。

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

int main()
{
   int a[4];
   int yu,ya;
   scanf("%d %d %d %d",&a[0],&a[1],&a[2],&a[3]);
   scanf("%d %d",&ya,&yu);

   int maxY = 0,cnt =0,index,i;
   for(i=0;i<4;i++)
  {
       maxY = max(maxY,a[i]);
  }
   for(i=0;i<4;i++)
  {
       if(maxY-a[i]>yu||a[i]<ya)
      {
           cnt++;
           index = i;
      }
  }
   if(cnt==0) cout<<"Normal";
   else if(cnt==1) printf("Warning: please check #%d!",index+1);
   else cout<<"Warning: please check all the tires!";
   return 0;
}

L1-077 大笨钟的心情

**这道题也是不知道有多少行输入的，在遇到非法数据（不在[0,23]区间）时停止。那就把while循环()里内容改为while(cin>>n&&n>=0&&n<=23)。注意格式正确。

四、字符串处理

字符串转换为整数

L1-025 正整数A+B

A和B都在区间[1,1000] A、B有时候可能是超出范围的数字、负数、带小数点的实数、甚至是一堆乱码。把输入中出现的第1个空格认为是A和B的分隔。

思路：

首先A、B不一定都是整数，可能是乱码，因此采用字符串来存储A、B。读入A之后一定要加getchar()读入缓冲区中的空格，getline(cin,str)读入整行字符串B。

对于不符合条件的数字用?代替，只要加法的任一加数为？，结果均为？

** 我们只对符合条件的两个加数进行计算。由于A、B都是[1,1000]的数，因此我们可以把他们转化为整型再相加获得结果，这里可以专门写一个函数来实现字符串到整型的转换。如果返回值为-1，表示这个数不符合条件，否则返回转化为整型的值。最后以规定的格式输出等式。

输出结果时有四种可能：一是两个都是整数，第二、三种是A或B满足条件，另一个不符合条件，第四种是A、B都不符合条件。可用if进行判断。

实现：

** 那么这个函数要怎么写呢？我们将字符串和字符串长度作为参数传入（只传一个字符串也没有关系）。遍历这个字符串，如果出现这个字符<’0’且>’9’就说明这个字符串不符合条件了，这时直接返回-1，别继续遍历了。否则，sum=sum10+a[i]-'0'; 想想是不是这样。最后返回这个sum，也就是转化的结果。

#include <iostream>
#include <cstdio>
#include <string>
using namespace std;

int pan(string a,int len)
{
   int i,sum=0;
   for(i=0;i<len;i++)
  {
       if(a[i]<'0'||a[i]>'9')
           return -1;
       else
           sum=sum*10+a[i]-'0';
  }

   return sum;
}
int main()
{
   string a,b;
   cin>>a;
   getchar();
   getline(cin,b);
   int lena = a.length();
   int lenb = b.length();
   int A = pan(a,lena);
   int B = pan(b,lenb);
   if((A>0&&A<=1000)&&(B>0&&B<=1000))
       cout<<A<<" + "<<B<<" = "<<A+B;
   if((A>0&&A<=1000)&&(B<1||B>1000))
       cout<<A<<" + ? = ?";
   if(B>0&&B<=1000&&(A<1||A>1000))
       cout<<"? + "<<B<<" = ?";
   if((A<1||A>1000)&&(B<1||B>1000))
       cout<<"? + ? = ?";
   return 0;
}

提取整数的每一位

L1-033 出生年

输入在一行中给出出生年份y和目标年份中不同数字的个数n，其中y在[1, 3000]之间。根据输入，输出x和能达到要求的年份。数字间以1个空格分隔，行首尾不得有多余空格。注意不足4位的年份要在前面补零

思路：

题目已经说了所谓“n个数字都不相同”是指不同的数字正好是n个。**

考虑到set不会存放相同的元素，可以把当前年份所含的数字insert()加入到集合中，如果集合中数字个数==n就break退出。返回年龄和当前年份（注意输出格式！）。起始值为出生年份，循环到能找到这个年份为止（年份一年一年往上加）。

实现：

** 这里就和上题不同的是，不需将年份转化为字符串，而是需要将整型的一位位取出来。怎么取呢？假设当前处理的年份是n，这里也不需要按顺序来存，所以每次把n%10添加到set中（取出当前数的末位数字），再n/10。循环多少次呢?因为y在[1, 3000]，保证是个4位数。设置j的起始值为4就可以了。

while(j--)

{ s.insert(n%10);
 n/=10;
}

注意这时候n的值已经发生改变，用一个变量来保存一下它。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <set>
using namespace std;

int main()
{
   int y,n,m;
   cin>>y>>n;
   m = y;

   while(1)
  {
      int h = m;
      set<int> s;   //注意定义的位置
      int j=4;
      while(j--)
      {
          s.insert(h%10);
          h/=10;
      }
       if(s.size()==n) break;
       m++;
  }
   printf("%d %04d",m-y,m);
   return 0;
}

遇到终止标记时停止输入

还有种情况就是给一行字符串，我们使用getline(cin,str)后用s.length()就知道字符串的长度**，便可以用for循环遍历整个字符串了。（如58题）

L1-035 情人节

输入按照点赞的先后顺序给出不知道多少个点赞的人名，每个人名占一行，为不超过10个英文字母的非空单词，以回车结束。一个英文句点.标志输入的结束。若存在第2个人A和第14个人B，则输出“A and B are inviting you to dinner...”；若只有A没有B，则输出“A is the only one for you...”；若连A都没有，则输出“Momo... No one is for you ...”。

思路：

输入时注意条件是不知道多少个点赞的人名（可用字符串表示），这时候就可以用while循环，特别是题目说了用英文句点.标志输入的结束。倘若读入的字符串是’.’，就可以跳出循环。

**因为要输出第2和第14个人名，因此需要存储人名。可以用字符串数组，也可以单纯存放第2个和第14个人名。

这题在输出的时候考虑如题所示的三种情况。如果人数>=14,输出…… 如果人数>=2且<14，需要输出……如果人数<2,输出…… 这时候还需要一个变量来标记点赞人数（有多少次循环）

**第一种方法是用字符串数组来存储人名，用while(1)循环，直到遇到‘.’break跳出循环。

#include <iostream>
#define N 10000
using namespace std;

int main()
{
   string s[N];
   int i=0;
   while(1)
  {
       cin>>s[i];
       if(s[i][0]=='.')
           break;
       i++;

  }
   if(i>1&&i<=13)
           cout<<s[1]<<" is the only one for you...";
   if(i<=1)
       cout<<"Momo... No one is for you ...";
   if(i>13)
           cout<<s[1]<<" and "<<s[13]<<" are inviting you to dinner...";
   return 0;
}

第二种方法是用字符串数组来存储人名，用while(cin>>s&&s!=".")（注意是双引号！）**来看是否进入循环。

#include <iostream>
#define N 10000
using namespace std;

int main()
{
   string s,A,B;
   int i=0;
   while(cin>>s&&s!=".")
  {
       i++;
       if(i==2) A = s;
       if(i==14) B = s;

  }
   if(i>1&&i<=13)
           cout<<A<<" is the only one for you...";
   else if(i<=1)
       cout<<"Momo... No one is for you ...";
   else
        cout<<A<<" and "<<B<<" are inviting you to dinner...";
   return 0;
}

L1-044 稳赢

根据对方的出招，给出对应的赢招。需要每隔K次就让一个平局。

思路：

这题石头剪刀布有个很巧的方法，我们不要专门设一个函数，比如传入参数为剪刀，返回石头；出石头，返回布……而是可以用一个字符串数组的方法，比如string s[3]={"ChuiZi","JianDao","Bu"};比如锤子，我们用布来对。布就用剪刀。（规律：差2 再对三取模）**s[(i+2)%3]就是本局要赢对应的划拳。

因此对于输入的字符串我们可以遍历下字符串数组，看当前的字符串在字符串数组的索引i（一个个比较是否相等）。

其次注意K是间隔次数，每隔K局就输出一个和输入的字符串相同的划拳。（比如k=2，前两局赢了，我第三局就要平局）这时就要用一个变量表示局数（初始化为1），如果局数%(k+1)==0就说明这句要平局。

输入到End就退出循环，这个方法和上一题一样，就不再赘述。

#include <iostream>

using namespace std;

int main()
{
   string s[3]={"ChuiZi","JianDao","Bu"};
   string str;
   int n,i;
   cin>>n;
   int c=1;
   while(1)
  {
       cin>>str;
       if(str=="End")
           break;
       for(i=0;i<3;i++)
      {
           if(str==s[i])
          {
               if(c%(n+1)!=0)
                   cout<<s[(i+2)%3]<<endl;
               else cout<<s[i]<<endl;
          }
      }
        c++;
  }

   return 0;
}

L1-058 6翻了

从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。

这道题的难点就在于如何看有多少个连续的6，以及把连续的6替换为对应数字。

实现：

首先用getline(cin,s)读入这行句子。

考虑用string类型中的replace()函数，

str.replace(pos,len,str2);表示用str2替换str中从pos位置开始长度为len的子串。

#include <iostream>

using namespace std;

int main()
{
    string s;
   int i,j,n;
   getline(cin,s);
   for(i=0;i<s.length();i++)
  {
       for(j=0;i+j<s.size()&&s[i+j]=='6';j++);//记得这里有个分号，只是这样求一串6的长度
if(j>9) s.replace(i,j,"27");//j就是一串6的长度
else if(j>3) s.replace(i,j,"9");
  }
   cout<<s;
   return 0;
}

判断字符串是否包含子串

L1-070 吃火锅

自动检查你朋友给你发来的信息里有没有 chi1 huo3 guo1。输入每行给出一句不超过 80 个字符的、以回车结尾的朋友信息。当读到某一行只有一个英文句点 . 时，输入结束，此行不算在朋友信息里。

首先在一行中输出朋友信息的总条数。然后对朋友的每一行信息，检查其中是否包含 chi1 huo3 guo1，并且统计这样厉害的信息有多少条。在第二行中首先输出第一次出现 chi1 huo3 guo1 的信息是第几条（从 1 开始计数），然后输出这类信息的总条数，其间以一个空格分隔。题目保证输出的所有数字不超过 100。

如果朋友从头到尾都没提 chi1 huo3 guo1 这个关键词，则在第二行输出一个表情 -_-#。

思路：

首先要看看朋友到底发了多少条信息。这里每行就是一条，看有多少行。

注意二者区别 cin>>str：遇到空格将停止输入 getline()：获得完整一行字符串

怎么体现遇到chi1 huo3 guo1呢？输入的这一行字符串包含这个字符串即可。这里插入一个知识点：

在string类型中有一个find()函数，str.find(str2)，如果str包含str2，就返回在str中第一次出现str2的位置，否则返回string::npos。

注意用一个变量来存储第一次出现“chi1 huo3 guo1”的行数以及出现”chi1 huo3 guo1”的条数。

注意是提到次数为0**时而不是行数为0时输出表情！这个在定义变量的时候做好区分。

#include <cstdio>
#include <iostream>
#include <string>

using namespace std;
int main()
{
   string s;
   string str = "chi1 huo3 guo1";
   int cnt = 0,ans = 0,first = 0,flag=0 ;
   while(getline(cin,s)&&s!=".")
  {
       cnt++;
       if(s.find(str)!=string::npos)
      {
           ans++;
           if(ans == 1)  first = cnt;
      }
  }
   cout<<cnt<<endl;
   if(ans ==0)  cout<<"-_-#";
else cout<<first<<" "<<ans;
return 0;
}

L1-078 吉老师的回归

逐行检查字符串。如果其中包含区分大小写的 qiandao 或 easy，就跳过这道题。

输入表示本次天梯赛有 N 道题目，吉老师现在做完了 M 道。在一行中输出吉老师当前正在做的题目对应的题面（即做完了 M 道题目后，吉老师正在做哪个题）。如果吉老师已经把所有他打算做的题目做完了，输出一行 Wo AK le。

思路（本题脑子清醒比较重要）：

如果吉老师没把想做的题目做完，就输出吉老师正在做哪题（第m+1个不包含qiandao 或者 easy的题面）。如果吉老师都做完了，就输出指定内容。

这里就需要遍历完每一行的题面，看看究竟有多少题吉老师要完成的（与M比对是否已做完）。这就需要一个变量来记录吉老师做的题数，不包含：题数+1。

**当题数==M+1时，输出第M+1个不包含qiandao 或者 easy的题面。(注意在判断时二者是&&关系)。字符串包含的问题上题已说明。

什么情况下吉老师做完所有题目呢？ t<=m 也就是已完成的题数>=需要做的题数的情况

**注意：**此题的输入要么cin>>n>>m;之后跟上一个getchar()接收一下回车再接着循环存储题面。要么就是scanf("%d %d\n",&n,&m);进行输入。否则会出错！

#include <iostream>
#include <cstdio>
#include <string>

using namespace std;

int main()
{
   int n,m,t=0;
   cin>>n>>m;
   //scanf("%d %d\n",&n,&m);
   getchar();
   string s;
   for(int i=0;i<n;i++)
  {
       getline(cin,s);
       //if(s.find("qiandao")==string::npos&&s.find("easy")==string::npos)
       if(s.find("qiandao")==-1&&s.find("easy")==-1)    //也可以用-1表示string::npos，虽然会显示等号两边类型不匹配的warning
      {
           t++;
      }
       if(t==m+1)
      {
          cout<<s;
          break;
      }
  }
   if(t<=m) cout<<"Wo AK le"<<endl;
   return 0;
}

按位推导规律

L1-050 倒数第N个字符串

给定一个完全由小写英文字母组成的字符串等差递增序列，该序列中的每个字符串的长度固定为 L，从 L 个 a 开始，以 1 为步长递增。对于任意给定的 L，本题要求你给出对应序列倒数第 N 个字符串。

思路：

倒数第N个字符串，转化为正数第M个字符串来解决。L个字母会产生26^L个字符串，用函数表示就是pow(26,l);

感觉过去像是个找规律的问题，比如说aaaa、aaab…aaaz、aaba、aabb、aabc……zzzz。就好比满26了向前进1。可以看出到第28个（第一个记为0）时，把28%26的值为当前最低位（‘a’+2），接着28/26为1，对26求余为1，也就是倒数第二位。然后不断把这个值/26再对26求模（循环l次），就可以从最后一位往前推当前位的字符，结果是aabc。最后逆序逐个输出每一位上的字符。(这题对我来说还挺难想的…）

#include <iostream>
#include <math.h>
#define N 10
using namespace std;

int main()
{
   int l,n,m,i,t;
   char r[N];
   cin>>l>>n;
   t = pow(26,l);
   m = t-n;
   for(i=l-1;i>=0;i--)
  {
       r[i] ='a'+m%26;
       m/=26;
  }
   for(i=0;i<l;i++)
       cout<<r[i];

   return 0;
}

五、矩阵处理

矩阵相乘

L1-048 矩阵A乘以B

思路：

输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C。只有Ca与Rb相等时，两个矩阵才能相乘。

若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵AB，否则输出Error: Ca != Rb

可以在草稿纸上模拟一下矩阵相乘有什么特点。首先结果是Ra×Cb大小的矩阵c。比如ci的结果为a的第i行分别与b的第j列元素相乘结果再相加。

实现：

首先输入两个矩阵，用二维数组a和b来存储（在输入矩阵a的行数和列数时就创建符合大小的二维数组）。存入数组元素也不难，双重循环读入每个位置元素就可以了。

其次对Ca和Rb进行比较，不相等直接输出Error，就不要进行矩阵相乘了。可以用个if-else判断

实现起来是不是ai*ck。这个k的范围就是a的列数，即b的行数。因此设置三层循环，最里层计算sum+=ai*bk; 第二层循环需要更新sum=0;

**注意！**行首尾没有多余的空格。可用一个变量来标记此时是这一行第几个元素（若初始化为0）

非每行末尾元素，我们输出结果时再加一个空格。如果当前计数==Cb-1 就输出结果并换行即可。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int main()
{
   int i,j,k,ra,ca,rb,cb,sum;
   cin>>ra>>ca;
   int a[ra][ca];
   for(i=0;i<ra;i++)
  {
       for(j=0;j<ca;j++)
           cin>>a[i][j];
  }
   cin>>rb>>cb;
   int b[rb][cb];
   for(i=0;i<rb;i++)
  {
       for(j=0;j<cb;j++)
           cin>>b[i][j];
  }
   if(ca!=rb) printf("Error: %d != %d",ca,rb);
   else
  {
       cout<<ra<<" "<<cb<<endl;
       for(i=0;i<ra;i++)
      {
           for(j=0;j<cb;j++)
          {
                int sum=0;
                for(k=0;k<rb;k++)
                   sum+=a[i][k]*b[k][j];
               if(j==cb-1) cout<<sum<<endl;
               else  cout<<sum<<" ";
          }
      }
  }
   return 0;
}

倒置矩阵

L1-054 福到了

读入字符和网格规模，输出倒置的网格，如样例所示。但是，如果这个字正过来倒过去是一样的，就先输出bu yong dao le，然后再用输入指定的字符将其输出。

思路：

**看到这题想法是应该用一个二维数组/字符串数组来存储这个网格。然后创建一个同样大小的网格把原始网格倒置存储。但是怎么判断这是一个不用倒了的网格呢？是判断每个有字符的地方都处于它对应的位置吗？**比如在原始NN网格中一个元素位置是ai，那么倒置之后它的位置在an-i-1，**注意用给定字符替代。

但是，或许我们根本不需要再额外花费空间来存储倒后的元素，可以直接输出呢？

实现：

**注意：**读入字符和规模N之后要getchar();（上文L1-078中已说过类似问题）再接着进行网格内容输入。可以用字符串数组来输入，一行就是getline(cin,s[i]);

因为如果不用倒了，就说明这个网格是对称的，那它倒过来的时候元素对应位置一定是有字符的。一旦发现倒置后位置没有字符，就用置标志位flag为1（初始化为0），然后break跳出循环。根据flag的值判断是否需要输出“不用倒了”。

在输出的时候，通过判断它（要输出的网格）倒置的位置（也就是原来的网格规模）是否有元素决定输出的地方是输出空格还是指定字符，注意到达每行尾部时换行。

#include <iostream>
#include <cstdio>
#define N 1000
using namespace std;

int main()
{
   char c;
   int n,i,j;
   int flag=0;
   cin>>c>>n;
   getchar();
   string s[N];
   char m[n][n];
   for(i=0;i<n;i++)
  {
       getline(cin,s[i]);
  }
   for(i=0;i<n;i++)
  {
       for(j=0;j<n;j++)
      {
           if(s[i][j]!=s[n-i-1][n-j-1])
              {
                 flag=1;
                 break;
              }
      }
  }
   if(!flag) cout<<"bu yong dao le"<<endl;
   for(i=0;i<n;i++)
  {
       for(j=0;j<n;j++)
          {
               if(s[n-1-i][n-1-j]!='@')
                   cout<<" ";
               else cout<<c;
          }
       cout<<endl;
  }
   return 0;
}

景深、虚化与动态模糊：光圈和快门对照片的影响

Fri, 31 Jan 2025 00:00:00 GMT

光圈和快门都会影响曝光，但它们也分别控制画面的空间与时间表现：光圈改变景深和虚化，快门改变运动模糊。拍摄时可以从目标反推参数，想突出主体就调整光圈，想凝固或表现运动就调整快门。

光圈、景深与虚化

景深

镜头前只有一段距离范围能够保持可接受的清晰度，这个范围就是景深。

大光圈→浅景深。即清晰的区域小，背景会模糊。⬇️

小光圈→深景深。即清晰的区域大，背景也清晰。⬇️（简单理解为近视眼更喜欢眯缝着看人吧）

②虚化

大光圈，背景虚化越强⬇️

小光圈，背景虚化越弱⬇️

③虚化强弱的理解

光斑的形状来源于光圈扇叶形成的圆洞 [ 假如用卡纸剪出心形置于镜头前，光斑也成心形⬇️

④虚化的不止背景，还可以有前景。

前景虚化 ，可增添照片的梦幻感⬇️

⑤光圈与对焦的关系

光圈越大，越难对焦

运动类照片，若用大光圈，则很难对焦。建议小光圈。

【对焦，就是让清晰的区域（景深）与拍摄主体有重合，因此，小光圈易于对焦运动中的主体。】

快门与动态模糊

①影响了画面亮度，决定了动态模糊

②动态模糊:

慢快门时，假如相机抖动，将导致光在CMOS上有运动轨迹，进而导致照片糊掉

自动挡时，使用大光圈，增大ISO，闪光灯或补光灯照亮主体，使用三脚架，可以尽可能避免相机使用慢快门，进而避免拍摄时，相机抖动导致照片糊掉。

③慢速快门

是一种拍摄技巧，可用于拍摄光绘，星轨，车流，火花，王家卫式电影，运动类题材。

eg:

车流（为防止糊片，需要三脚架固定）⬇️ 星轨⬇️

烟花⬇️

运动镜头⬇️

参数选择

光圈大→提高亮度、产生虚化

快门慢→提高亮度、动态模糊

出题:

大太阳下，如何既有虚化，又有动态模糊？（可以拍摄出一种运动感、速度感）

如图⬇️

答:___________________________

强光下即使 ISO 已降到 100，画面仍可能过曝。如果又不希望缩小光圈或提高快门速度，可以使用固定档或可变档 ND 滤镜减少进光量。

效果:使用前⬇️

使用后⬇️

4.人对事物理解的四个层次:（勉励自己运用）

5.作业:拍摄尝试

Pinellia Blog

GNU Screen 仅保留 Ctrl+A Ctrl+D，其余按键透传

环境

核心原理

1. 不能只解除默认按键绑定

2. 将 Screen 自身的命令前缀移走

3. 单独绑定 Ctrl+A Ctrl+D

最终配置

为什么单独按 Ctrl+A 会有短暂延迟

不影响现有 Screen 会话的方法

修改前备份

验证思路

日常使用

回滚

最终结果

使用 YubiKey 配置 OpenPGP：密钥生成、备份与日常使用

最终要得到什么

1. 准备 GnuPG 与卡片

macOS

Linux

检查 OpenPGP 应用

2. 先规划算法与有效期

3. 创建主密钥与子密钥

4. 在迁移前制作完整备份

实际验证备份

5. 修改卡片 PIN

6. 把三把私钥迁移到卡片

主密钥迁移到 Signature 槽

[E] 子密钥迁移到 Encryption 槽

[A] 子密钥迁移到 Authentication 槽

7. 验证卡片状态

8. 分别测试三个卡槽

签名与验证

加密与解密

导出 SSH 公钥

9. 配置 Git commit 签名

10. 把认证子密钥用于 SSH

11. 发布公钥与指纹

12. 可选的卡片安全设置

每次签名都重新验证 PIN

物理触摸确认 UIF

KDF

卡片元数据

13. 在新电脑上恢复使用

14. 卡片丢失、损坏或 PIN 锁定

用户 PIN 锁定

卡片损坏但身份仍需继续使用

卡片丢失或怀疑已被复制使用

15. 日常检查清单

验收结果

参考资料

从 giffgaff 转入 VOXI：eSIM 激活、APN 排障与保号说明

开始前需要准备什么

第一步：开通并写入 VOXI eSIM

eSIM 写入后一直无服务怎么办

方案 A：只修改 LTE APN

方案 B：填写 Talkmobile APN

第二步：从 giffgaff 获取 PAC

第三步：在 VOXI 提交携号转入

套餐取消、PAYG 与保号

长期漫游风险

常见问题速查

参考资料

不安装 Android Studio 也能开发 Android

准备环境

构建与测试

安装到真机

注意事项

远程服务器 Codex 使用本地 AiMaMi 中转服务指南

配置结构与切换边界

在本机单独运行 SSH 反向转发

方案 A：使用 Codex Profile

Profile 如何工作

调整主配置

创建官方模型 Profile

创建智能路由 Profile

添加便捷别名

Profile 的优缺点

方案 B：使用脚本切换全局配置

完整 Linux 脚本

3. 单独绑定 `Ctrl+A Ctrl+D`

为什么单独按 `Ctrl+A` 会有短暂延迟

`[E]` 子密钥迁移到 Encryption 槽

`[A]` 子密钥迁移到 Authentication 槽

先确认 `mount_ntfs` 来自哪里

提示 `Resource busy`

12.2 善用 `/prompt` 排查问题

12.3 `/compact` 的时机