Pinellia Blog

Claude Code 斜杠命令完全指南

Fri, 12 Jun 2026 00:00:00 GMT

前言

Claude Code 是 Anthropic 推出的终端原生 AI 编程助手。除了在交互中自然描述需求之外，它还提供了一套以 / 开头的斜杠命令（Slash Commands），用于执行配置、会话管理、代码审查、项目初始化等操作。

本文基于实际使用经验，对所有内置斜杠命令进行系统梳理。

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 检查记忆的有效性

小结

Claude Code 的斜杠命令体系涵盖了从会话管理、代码审查、配置调整到自动化编排的完整开发工作流。掌握这些命令可以大幅提升你在终端中的开发效率——将 AI 从「对话伙伴」升级为「可编排的编程环境」。

核心原则：能说的就直接说，需要精确控制时用命令。大部分日常操作通过自然语言即可完成，斜杠命令用于配置固化、会话管理、多步骤编排等需要明确控制的场景。

服务器环境配置指南

Fri, 12 Jun 2026 00:00:00 GMT

前言

本文记录在一台无 root 权限的 Linux 服务器上，完成基础开发环境初始化的完整流程。目标是从裸机状态搭建出一套可用、稳定的命令行交互与 Python 开发环境。

主要内容包括：

Shell 环境初始化与 zsh 编译安装
oh-my-zsh 配置与 Powerlevel10k 主题
micromamba 部署与初始化
个人共享目录与项目工作区建立
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/     # 项目工作区

创建命令：

SHARE_BASE="/share/liurui_group/niuhongkai"
mkdir -p "${SHARE_BASE}"/{Datasets,Models,Outputs,Projects}

3.3 创建项目工作区

mkdir -p ~/Projects/work1

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

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 时，很多人都会逐渐积累一些“高频但非官方”的操作，比如：

根据当前目录自动激活某个环境
快速停用当前环境
维护“项目目录 -> 环境名”的映射关系
给 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/niuhongkai/project/a = py38
/home/niuhongkai/project/b = ml
/home/niuhongkai/workspace/demo = testenv

解析规则可以是：

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

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

当前目录：/home/niuhongkai/project/a/subdir
已有映射：
- /home/niuhongkai/project = base-env
- /home/niuhongkai/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 快捷命令
项目脚手架命令
本地开发环境切换命令

一句话总结：

把 shell 自定义从“堆脚本”升级成“可注册的命令层”，你会明显感受到维护成本下降。

机器学习环境配置

Tue, 28 Oct 2025 00:00:00 GMT

conda->micromamba

micromamba 是一个使用 conda-forge channel 的 conda 替代品，优势如下：

为静态链接的 C++ 可执行文件，速度快
默认采用 conda-forge channel 更新更全
非root环境下易于安装卸载，同时占用空间极小
拥有更全面的提示以及进度条
没有conda的环境嵌套激活问题，用着放心

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

how 2 install

[!TIP] 鉴于 homebrew 下载较为臃肿，不建议使用 homebrew

官方指导：link

mac, linux, windows git bash:

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

自动升级：

micromamba self-update

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 来手动激活对应环境（前缀匹配激活，子文件夹都可用）
# --- 结束 自动激活 ---

总结

推荐使用 Miniconda，日常使用稳定，缺点是环境构建稍慢。
可尝试 conda-forge + mamba，但部分 forge channel 可能体验一般。

mihomo 设置指南

Sun, 05 Oct 2025 00:00:00 GMT

Android

机端新模块

adb push /Users/nhk/Downloads/TT/Clash配置.yaml /sdcard/Android/Clash

MAC

mac版本的 verge rev 天天死机，直接跑内核还快一点

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

vscode mac c++ 环境配置

Wed, 27 Aug 2025 00:00:00 GMT

使用的插件

C++系列，code runner

配置文件

tasks/launch 文件用来完善f5调试
settings 文件主要用来完善cpp代码万能头，以及 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

第⼀章、基础数据结构

数组双指针

⼆分搜索

在排序数组中查找元素的第⼀个和最后⼀个位置
⼆分查找
搜索插⼊位置
俄罗斯套娃信封问题
判断⼦序列
阶乘函数后 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

夹带私货--简单文件隐写

Wed, 20 Aug 2025 00:00:00 GMT

简单介绍

懒得写了： https://zhuanlan.zhihu.com/p/590378572

实现

隐写

使用 cat a.zip >> b.png命令实现将pdf追加到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查看文件结构：可以看到，被识别为了一个正常图像以及一个压缩包文件

使用 binwalk -e b.png将文件提取出来可以看到，提取出的文件夹如下，在以zip文件开始地址命名的文件夹下直接解出了压缩包内的文件

TIPS

建议将文件打压缩包后再进行隐写，因为例如word文档以及pdf本身就是一个文件集合，这样会导致binwalk无法正确的识别文件类型并提取。

当然，这样加密效果会更好，而且知道文件开始结束位置可以使用dd命令手动提取。

cf加速实践

Wed, 20 Aug 2025 00:00:00 GMT

参考

https://cmliussss.com/p/BestWorkers/

结果记录

尝试加速本博客 blog.pinellia.uk为例

itdog tcping全绿：

但本地的设备包括电脑手机，在走直连的情况下，访问极其受限，大部分情况下：

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

确认非dns问题

clash的dns结果与itdog吻合：

尝试指定找不到无法访问的原因，走代理的情况下能连接。可以ping通解析出来的ip

rec：平板和电脑等了很长时间莫名其妙就能连接了

Python 环境配置

Fri, 08 Aug 2025 00:00:00 GMT

介绍视频

总结

推荐使用 Miniconda，日常使用稳定，缺点是环境构建稍慢。
可尝试 conda-forge + mamba，但部分 forge channel 可能体验一般。

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

Wed, 26 Feb 2025 00:00:00 GMT

从这里开始，题目通常都是先给N，然后给出N行数据，虽然题目中看上去输出样例是一起输出，但是我们在编译器里可以是针对每一个样例给出结果（不用把示例都输入后再输出结果），意味着不需要用数组储存（或者使用结构体），可以节省代码量。

一般情况下，题目还会要求行尾不能有空格，那么我们可以在输出时分两种情况，如if(i==n)时输出xxx, else 输出xxx 以及空格。 测试时注意使用英文的标点符号 最好在变量需要时再进行初始化，这样也比较方便（但是好像Code Blocks不支持这样操作，需要一开始就定义变量）。 在计数时注意赋初始值( 一般为0)，否则该变量数值不确定

接下来说说10分题出现的题型（旁边是题号）

给一个整数，输出每一位上的数字 7

L1-007 念数字 (10分) 输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。

如果是过去的思维，通常会采用C语言的switch-case结构，先读入整数，再获取每一位上的数字，用switch-case结构来读出每一位的拼音
如果是用更聪明的想法，其实数字和拼音是****存在一个一一映射的关系(hash)，那么可以用读入字符串的方式读入输入示例。如果是char型数组的话，可以用二维数组charm定义，因为二维数组中的每个一维数组都存储着拼音，当然如果使用string数组就更方便了。或者使用STL容器的map来做也很快（后面大题再说）。

下面以三种做法为例进行对比 1）读入整型法 这里涉及到如何获取每一位的数字的做法。很容易理解，以106为例，106%10，余数为6，即个位，然后106/10后再取余，循环的终止条件在于/10之后为0。这样依次获取的数字是从右往左读的，所以在输出时需注意。在这里我的做法是把获取的每一位数存入数组，在倒序输出。

#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;
}

2）二维数组法 len = strlen(s);获取字符数组的长度 s[i]-'0'获得的就是该字符对应的整数 如'6'-'0'=6 另外在if-else如果只有两种情况（****非此即彼），那么就可用xxx?a:b xxx表示判断条件，如果满足则执行a,否则执行b。这样来简化写法

#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;
}

3）string数组法 在很多题目中，我们会采用标志位flag来标记，通常初始化为0，如果满足某条件标记为1，这样可以容易地判断是否满足某一条件。在这道题中，如果a[0]=='-'，就说明这个数是负数，输出"fu"，注意在读入string类型的a时，应该用的是英文的单引号''，而非双引号.

#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.排序 10

具体排序方法有很多，这里介绍STL容器中的sort,注意要加头文件 #include < algorithm >基本用法是定义了数组之后，sort(数组的起始位置，结束的****下一个位置,cmp)，第三个参数不加时默认时从小到大排序，否则需要自定义一个cmp函数，规定排序的顺序

L1-010 比较大小 (10分) 要求将输入的任意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.格式化输出不足补充靠右 8 18 37（分类讨论）

关于格式化输出，在上一节已作讨论，在这里来说以下靠右的做法，例如 左对齐-%10d 右对齐%10d。数字宽度为10，若不足10，在左边补足空格

以L1-008 求整数段和 (10分)为例 首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。

这道题需要特别注意的是换行，可以用一个变量cnt来递增，若cnt%5==0说明此时该换行，另外一个测试点在于如果最后一个数不是在最后一行最后一个位置，不需要换行

#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.简单计算阶乘计算（嵌套循环） 13 31 40

以L1-031 到底是不是太胖了 (10分)为例 说此题的原因在于 abs(x) 要加头文件 #include x必须为整数 浮点型用math.h下的fabs() 注意在if 的时候不要把公共部分放在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.简单题 22 47 53 61 不多说 6.判断素数 28 判断素数****需要用到sqrt()求平方根缩小循环的范围，否则可能会超时，注意加上头文件<math.h> L1-028 判断素数 (10分)

#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;
}

7.达到某条件即break 41 一般达到某条件则用break退出循环

L1-041 寻找250 (10分) 输入在一行中给出不知道多少个绝对值不超过1000的整数 在一行中输出第一次出现的"250"是对方扔过来的第几个数字（计数从1开始）

这样的情况就是不能够知道到底扔来多少数，这时候就可以用while(1)不断接收数字，一旦满足此数为250即退出循环

#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;
}

8.根据题意求解 55 63

以L1-055 谁是赢家 (10分)为例 每次安排两位艺人表演，他们的胜负由观众投票和 3名评委投票两部分共同决定。如果一位艺人的观众票数高，且得到至少 1名评委的认可，该艺人就胜出；或艺人的观众票数低，但得到全部评委的认可，也可以胜出。数字 0 代表投票给 a，数字 1 代表投票给 b，其间以一个空格分隔。 这题思路不难，用几个变量存储一下观众和评委得票数，根据题意进行描述即可

#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

首先对20道题进行一个分类吧~

一、哈希映射问题

二、结构体问题

三、简单题（按题意要求写就行，部分题给出代码）

四、字符串处理

五、矩阵处理

一、哈希映射问题

L1-003 个位数统计

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

**回顾一下int类型和long long类型有多少位 **

int类型 -231~231 -1 【int类型在C语言中占4个字节，即32个二进制位，最高位为符号位】

long long类型 −263,263−1【long long类型在C语言中占8个字节，即64个二进制位】

int只能表示到10^9，而long long 可以表示到10^18。****根据不同的情况需定义不同的数据类型。

思路：

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

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

本题有两个注意点

1） memset(s,0,sizeof(s)); 是关键，对数组初始化都设置为0，否则会出错。用到这个时需要加上头文件 #include <string.h>

2）注意遍历时str[i]是一个字符，要str[i]-'0'来转化为int类型

#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的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。

思路：

首先依题意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)。**注意格式正确。

四、字符串处理

1、字符串转化为整型

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;
}

2、提取整数的每一位数字

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;
}

3、遇到某个特定字符串停止输入（不知道循环多少次的情况）

还有种情况就是给一行字符串，我们使用****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;
}

4、字符串包含问题（是否包含某一子串）

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;
}

5、规律题

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;
}

五、矩阵处理

1、矩阵相乘

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;
}

2、倒置矩阵

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

1.光圈可影响亮度、景深、虚化；对焦的本质；对焦和光圈的关系

2.快门可影响亮度，决定动态模糊；慢门的运用

3.倒过来思考也是一样:想要动态模糊→改变快门；想要虚化→改变光圈

1、光圈的大小除了影响亮度，还影响景深、虚化。

①景深:从镜头发散出去，只有一部分区域的景象是清晰的，其他的会模糊。而清晰的区域，就叫做景深。（如图）

大光圈→浅景深。即清晰的区域小，背景会模糊。⬇️

小光圈→深景深。即清晰的区域大，背景也清晰。⬇️（简单理解为近视眼更喜欢眯缝着看人吧）

②虚化

大光圈，背景虚化越强⬇️

小光圈，背景虚化越弱⬇️

③虚化强弱的理解

光斑的形状来源于光圈扇叶形成的圆洞 [ 假如用卡纸剪出心形置于镜头前，光斑也成心形⬇️

④虚化的不止背景，还可以有前景。

前景虚化 ，可增添照片的梦幻感⬇️

⑤光圈与对焦的关系

光圈越大，越难对焦

运动类照片，若用大光圈，则很难对焦。建议小光圈。

【对焦，就是让清晰的区域（景深）与拍摄主体有重合，因此，小光圈易于对焦运动中的主体。】

2、快门

①影响了画面亮度，决定了动态模糊

②动态模糊:

慢快门时，假如相机抖动，将导致光在CMOS上有运动轨迹，进而导致照片糊掉

自动挡时，使用大光圈，增大ISO，闪光灯或补光灯照亮主体，使用三脚架，可以尽可能避免相机使用慢快门，进而避免拍摄时，相机抖动导致照片糊掉。

③慢速快门

是一种拍摄技巧，可用于拍摄光绘，星轨，车流，火花，王家卫式电影，运动类题材。

eg:

车流（为防止糊片，需要三脚架固定）⬇️ 星轨⬇️

烟花⬇️

运动镜头⬇️

3. up总结

光圈大→提高亮度、产生虚化

快门慢→提高亮度、动态模糊

出题:

大太阳下，如何既有虚化，又有动态模糊？（可以拍摄出一种运动感、速度感）

如图⬇️

答:___________________________

Ps:如果大太阳下，即使ISO降到100，画面依然过曝，不得不减小光圈/调快快门。

此时需要一个新道具——ND滤镜（有固定参数、可变参数两种）

效果:使用前⬇️

使用后⬇️

4.人对事物理解的四个层次:（勉励自己运用）

5.作业:拍摄尝试

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.1. Start with `http://` or `https://`: Use web image2. Start with `/`: For image in `public` dir``3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.
Dump everything in the pot and follow this algorithm:

find wooden spoon uncover pot stir cover pot balance wooden spoon precariously on pot handle wait 10 minutes goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$ I = \int \rho R^{2} dV $$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

[^1]: Footnote text goes here.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

m3u8

Pinellia Blog

Claude Code 斜杠命令完全指南

前言

1. 会话管理

2. 配置与偏好

3. 项目初始化与记忆

4. 代码审查与质量

5. 开发与调试

6. 任务与后台管理

7. 自动化与工作流

8. 扩展与集成

9. 技能类命令（Skills）

10. 信息与帮助

11. 账户管理

12. 实用技巧

12.1 命令组合

12.2 善用 /prompt 排查问题

12.3 /compact 的时机

12.4 项目级 vs 用户级配置

12.5 Memory 的最佳实践

小结

服务器环境配置指南

前言

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

1.1 准备编译依赖

1.2 下载并解压 zsh 源码

1.3 配置与编译

1.4 切换默认 Shell

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

1.5.1 安装 oh-my-zsh

1.5.2 安装 Powerlevel10k 主题

1.5.3 启用主题

1.5.4 运行配置向导

2. 安装 Micromamba

2.1 下载与安装

2.2 初始化 Shell

2.3 验证安装

3. 建立目录结构

3.1 服务器摸底

3.2 创建个人工作目录

3.3 创建项目工作区

4. 创建 Python 环境

4.1 基础 Python 环境

4.2 环境管理常用命令

5. 配置 pip 国内镜像

5.1 写入配置文件

5.2 验证配置

6. 启动配置文件整理

7. 配置 Git 提交模板

7.1 创建模板文件

7.2 配置 Git 使用模板

7.3 效果

初始化结果确认

Zsh 中的 Conda 自定义命令框架

一、适用场景

二、最终结构

三、整体设计思路

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

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

3. 实现函数彼此独立

四、部署步骤

第一步：确保 micromamba 已初始化

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

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

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

1. 注册表缓存结构

2. 统一执行 micromamba 的函数

3. 注册表加载器

4. 通用分发器

5. 自定义 help 输出

6. conda() 统一入口

五、如何实现具体子命令

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

2. de：快速停用环境

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

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

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

方式一：函数型命令

方式二：直接转发到 micromamba

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

12.2 善用 `/prompt` 排查问题

12.3 `/compact` 的时机

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

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

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

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

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

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

6. `conda()` 统一入口

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

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

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

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

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

4. `~/.zshrc` 更干净

1. `description` 没显示

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

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

4. 支持 `conda commands`

5. 自动监听 `cd`

机器学习环境配置