橘子75

AI Agent 初体验

Sat, 19 Sep 2026 00:00:00 GMT

目录#

背景
配置
探索
总结

背景#

加入学创部之后，接触到 AI Agent ，听说很好用，于是开始在电脑上研究如何部署。

配置#

电脑配置：Win 11

虽然我很想重装 win 10 ，但是一想到我还要把所有环境都重新配置，就放弃了。

配置 agent 分为两个过程：载体和 api

因为我用的不是成套的、现成的 dsh 之类的，我采用 opencode 搭载 dsh 的 api ，这样感觉用着比较舒适，因为 opencode 给人感觉是嵌在终端里的，比较方便。

opencode#

opencode 是一个开源的 api 托管工具，可以通过访问官方链接查看。

我是使用 pnpm 装 opencode 。

Deepseek Harness#

我登录 dsh ，然后充了一点资金，接着创建了一个 api key。

然后，只需要把 api key 导入 opencode ，就可以直接在 opencode 使用。

opencode 可以直接在“运行”打开，也可以在“终端”打开。

opencode

探索#

修复 Windows Defender#

Windows Defender 崩了

这个虽然我让他跑了挺久，但是最后也没有解决。

排查磁盘大小占用问题#

这个算是清了点内存，约 30G 。

编写计划软件#

这个在我的另一篇文章有详细过程，这个项目非常成功，在此不赘述。

总结#

AI Agent 太好用了！#

橘务通-计划规划软件

Sat, 19 Sep 2026 00:00:00 GMT

目录#

事发背景
提示词编写
调整
产品效果
总结

事发背景#

最近感觉，有些日常任务需要反复的立起和倒下，比如丢垃圾；

然后，关于四象限任务分配法，我觉得“紧急但不重要”这一个维度是不太需要的，因为不重要的事情就未必会去做，所以用紧急来形容也不太妥当，因为不存在所谓的“不太重要”，只有“必须得做”或者“可以不做”。

而很多规划软件可能并没有我所想的这些东西。

因此，我就突然想要写一个自己的计划软件，装到手机上，实现个性化需求定制。

其实我很早就想写一个背单词的手机软件了，拿来滚一直记不住的词或者汉语意思，还有滚词形变化。估计这会是下一个项目。

但是，碍于不了解 Android 系统的相关 app 架构，就一直没开工。

但是现在不一样了，前段时间刚给电脑装了个 Agent ，正愁没地方用。

于是乎，开始在 Agent 的引领下试图制作一个用于日程规划的安卓 app 。

提示词编写#

众所周知，使用 Agent 干活，最重要的事情是给出清晰的、可执行的路径，尽量不要模棱两可，这样可以节省 Token 。

我根据我所构想的初步需求，构建了一下需要存在的页面，比如首页是什么、日常任务页面、任务如何排序和显示、如何删除和归档、如何批量导入导出、添加任务和修改任务界面、不同类型的任务怎么放、任务标签、任务的手动与自动立起、页面的颜色风格、暗色模式适配……

然后有了如下长达 180018001800 多字的提示词。

1
请你帮我完成如下任务，项目目录位于 ``D:\OrangePlan`` 。
2

3
# 总纲
4

5
我现在想要编写一个安卓app，计划是想要通过写成静态网页，然后封装成apk装到自己手机上，但是，如果你可以更方便的生成可安装的apk文件，也可以改变方案。
6

7
我希望日程等数据可以存储到手机上，并且可以导入和导出，导入导出采取可读的可批量处理的形式，不用加密，需要兼容中文字符。需要注意存储方式与电脑的不同，希望能存数据到手机上然后读取。要求如下，未提及情况请自行构建。
8

9
# 页面要求
10

11
打开的主页面是日常任务页面，下方是导航栏，分别是日常任务、单次任务、日程、我的。
12

13
所有颜色安排要符合夜间模式的要求，可以在设置中调整或者设置跟随系统。
14

15
色调：采用蓝色为主色调。
16

17
风格：优美，简洁，鲜明，但是注意颜色不要太亮太刺眼。
18

19
“我的”栏目内包含归档按钮和设置按钮，在设置里可以导入导出，还有一些其他设置，归档按钮可以进入归档页面。
20

21
# 细则
22

23
## 任务/日程显示界面
24

25
基础任务/日程显示：每个任务是一个小卡片，一行一个任务，显示任务名称，向左滑可以显示归档按钮和删除按钮，直接点击任务卡片可以进入修改界面，与创建页面相同，可修改任务信息。
26

27
## 日常任务
28

29
- 性质：时不时需要立起来的任务
30
- 添加任务页面：需要填写的内容包括名称、手动或自动特定时间（允许手动或自动每日/每周/每月/每学期） (任务按首字母排序)，末尾是保存按钮，右上角有个叉可以取消编辑，手机返回也可以取消编辑
31
- 显示界面额外显示：对于手动任务，任务卡片左边存在按钮，可以切换立起任务/完成任务，其他的任务左边统一空出相同距离。对于立起的任务，采用不同颜色标识。
32
- 示例任务（可选一两个加入）：记账 不背词形变化 丢垃圾 吃水果 完成某科作业 写小说 志愿者 理头发 剪指甲
33

34
## 一次性任务
35

36
- 性质：做完后直接归档 (按重要度从大到小排序)
37
- 添加任务页面：需要填写的内容包括名称、DDL（允许填暂无或特定日期）、重要指数 (任务按重要指数排序，重要程度相同按DDL从早到晚排序，暂无排在最后，其次按任务首字母排序)，末尾是保存按钮，右上角有个叉可以取消编辑，手机返回也可以取消编辑
38
- 事态分类（或重要度）：
39
    1. 落灰任务：可能长期屯在这里
40
    2. 休闲任务：可以不做，时间宽松
41
    3. 紧急任务：不得不做，时间紧急
42
    4. 重要任务：不得不做，时间宽松
43
- 内容标签：（希望可以自行添加标签、删除标签和按标签筛选）
44
- 以下是示例标签：
45
    1. 吃
46
    2. 玩
47
    3. 活
48
- 显示界面额外显示：每个卡片名称下方带有字体较小的标签和DDL，页面上面可以按标签筛选任务，不同事态的任务可用颜色区别（灰 蓝 黄 红）
49
- 示例任务（可选一两个加入）：更新某文章 研究某东西 学创活动安排 看某电影 安装某应用 毕业论文
50

51
## 日程
52

53
- 性质：可分类的日期标识 (按时间排序)
54
- 添加日程页面：需要填写的内容包括名称、时间（写特定日期，可以精确到时间点或者选择全天） (任务按时间排序，全天日程排在当天其他时间点日程的前面，其次按首字母排序)，末尾是保存按钮，右上角有个叉可以取消编辑，手机返回也可以取消编辑
55
- 显示界面额外显示：每个卡片名称下方带有时间（精确或全天）
56
- 示例任务（可选一两个加入）：社活 某某活动 选科抢课 四级报名
57

58
## 归档界面
59

60
对于每个已归档的任务或日程，首先按照三个类别分类，每个类别按照归档时间分类，每个类别可以折叠收起，页面最上方可以按名称搜索已归档的任务/日程。
61

62
每个归档卡片显示名称，下方显示归档日期，左划只有删除按钮，无法点击卡片修改信息。
63

64
# 补充
65

66
如果有不确定的信息，可以询问我，然后再继续工程。
67

68
如果有无法实现的步骤，请告知并给与可替代方案。
69

70
如果可以实现，请给出完成工程的步骤日志，需要构建和检查可用性，确定没问题后告诉我，我将投入试用。

展开收起

调整#

因为我一开始并不了解如何编写安卓软件，所以我一开始想让他通过封装静态网站的方法实现。后来他补充了，还需要写安卓框架和通过 Android build-tools 进行。

环境情况#

1
dsh ：当前这台 Windows 机器上有 Node.js 和包管理器（winget/choco），但没有安装 Java 和 Android SDK，而打包 APK 需要这两样。我先确认几个关键选择再动工。

我选择了 下载并安装 JDK 17 + Android build-tools + platform (无 Gradle 方案)

静态网页#

他直接一口气把 index.html 、 style.css 、 app.js 等全部搞定了，一口气写了 46+217+339+1031+29+5+11+180+88=194646+217+339+1031+29+5+11+180+88=194646+217+339+1031+29+5+11+180+88=1946 行代码。

构建 build#

安装完需要的工具后，他进行了自检并且尝试构建。

后来在字符编码上出了问题，也就是中文字符的问题。然后他进行了一下我看不懂的 16 进制操作后，实现了 “no warning” 的 build 。

随后他再次确认了各项功能运行正常，修改了一点 app.js 中的内容，且有签名。

1
成果
2
安装包：D:\OrangePlan\OrangePlan.apk（约 33 KB，已签名）
3
步骤日志
4
1. 环境：本机无 Java/Android SDK。我用 winget/直连下载的方式，在临时目录装了 Microsoft JDK 17、Android build-tools 34、platform-35（共约 300 MB，全自动）。首次后台脚本因 PowerShell 把中文路径按 GBK 读取而失败，改用纯 ASCII 脚本 + $env:TEMP 后成功；Adoptium 源连不上，改用微软 JDK；platform-34 已下架，改用 platform-35。
5
2. 网页 App（D:\OrangePlan\app\assets\ 下 index.html / style.css / app.js）：实现全部需求，深色蓝色主题，可跟随系统/深色/浅色。
6
3. WebView 外壳（MainActivity.java）：全屏加载网页，本地存储（localStorage），原生桥接导入/导出文件（走系统文件选择器，无需任何权限），重写返回键配合「手机返回取消编辑」。
7
4. 无 Gradle 打包（build.ps1）：aapt2 编资源 → javac → d8 → aapt2 链接 → 注入 dex → zipalign → keytool/apksigner 签名。期间把 android.jar 复制到纯英文路径消除了 aapt2 的中文路径告警。
8
5. 验证：node --check 语法通过；Chrome 无头渲染确认 JS 正常初始化（主题、视图、标签筛选均已生效）；aapt2 dump badging 确认包名 com.orangeplan.app、minSdk 21 / target 28、图标与中文标签「橙计划」字节正确；apksigner verify 通过。期间修复了「标签筛选未真正过滤列表」的 bug。
9
已实现功能要点
10
- 四个页签：日常任务 / 单次任务 / 日程 / 我的；卡片左滑出「归档/删除」、点击进编辑。
11
- 日常：手动(左侧切换立起/完成，立起高亮)/自动(每日·每周·每月·每学期) + 首字母(拼音)排序。
12
- 单次：重要度(落灰·休闲·紧急·重要，灰/蓝/黄/红)排序 + DDL + 自定义标签(增删/筛选)；示例标签 吃/玩/活。
13
- 日程：全天/具体时间，按时间排序。
14
- 归档：按三类别 + 归档时间分组可折叠，顶部搜索，卡片仅可删除。
15
- 设置：主题、导出 JSON/CSV、导入、载入示例任务、清空数据。
16
导入导出说明
17
- 导出/导入均不加密、UTF-8、兼容中文。JSON 保完整数据；CSV 表头为 类型,名称,方式,重要度,标签,日期,时间,全天,状态，可用 Excel 批量编辑后导入（归档内容仅随 JSON 导出）。
18
- 手机上导出会弹系统保存框（建议存到「下载」），导入可「选择文件」或直接粘贴文本。
19
试用方式
20
把 OrangePlan.apk 传到手机（微信/数据线/网盘均可），点击安装，允许「安装未知来源应用」即可。数据保存在本机 App 私有目录，卸载会丢失（建议定期在设置里导出备份）。
21
两个说明
22
- 未提及的「自动立起」我按「自动任务常驻列表、以周期标签标识、无手动开关」处理；「完成」仅手动任务可切换，自动任务靠左滑归档来移出。
23
- 我用临时目录里的 JDK/SDK 打包，orangeplan.keystore 已留在 D:\OrangePlan\android\（重打包需保留此密钥才能覆盖安装）。如果你希望我把工具链固定到项目里或改用其他方案，告诉我即可。

展开收起

修改小问题#

对于日常任务，手动任务的设计不太合理，应该是点击按钮之后设为完成，按钮不点击的时候视为未完成（他设计反了）；对于自动任务，自动的应该是立起来的时间，之前我说的有误，他也跟手动一样前面有个按钮可以完成或取消完成，也就是说，与手动的相比，他多了一个自动立起任务的功能（补充内容）
应用名称叫“橘务通”，而不是橙计划（这个我怀疑是他直接翻译英文而没有看到我写的提示词）
（询问问题）应用签名具体是什么？

修正#

他直接把所有 OrangePlan 都改成了 juwutong ，这我就很无奈了，只是想意译一下而已。我深知如果继续跟他纠结这个他肯定搞不明白，所以就这样罢。

然后修改了一下功能。

他自动给自动立起的任务设置了黄色边框高亮，这个感觉还可以，就没有管他。

问题的答复：

1
签名署名说明
2

3
Android 每个 App 都必须用数字签名才能安装。这个签名是一个「自签名证书」（自己生成的），里面的名字（CN）无需你的真实姓名、也没有法律署名要求——侧载自用场景下爱填什么都行。我填的是 CN=JuWuTong。
4
真正重要的只有两点：
5
1. 保管好 D:\OrangePlan\android\juwutong.keystore 和密码。密码我固定为 ******（库密码与密钥密码相同）。以后出新版必须用这个同一个 keystore 签名，否则手机会要求先卸载旧版才能安装（数据会丢）。
6
2. 将来若要上架应用市场，才需要用这个签名的指纹做开发者实名认证，那是上架阶段的事，与现在无关。
7
结论：现在不需要你署名，东西都已替你生成并留在项目里。若想改密码或改 CN，告诉我即可重新生成。

得出结论：

keystore 是用来更新软件的，防止卸载旧版数据丢失
上架应用市场的时候才会扯到那些签名实名问题，不用管

接下来使用时又出现一个问题：自动立起的任务在未完成的时候会一直显示归档和删除按钮遮挡任务卡片。

让他改了改，重新打包，发现问题：立起状态的卡片之前用半透明背景色，下面按钮就显示出来了。

修复：背景改成不透明色，保留琥珀色边框和「立起」标签。

至此，没什么大问题了。

产品效果#

日常任务

新建日常

单次任务

新建单次

日程

我的

设置

归档

总结#

这次 Agent 应用实践，让我大致了解了 Android 架构长什么样，初步熟悉如何写提示词，同时也深刻认识到了：

Agent 太好用了！#

零碎思考

Sat, 19 Sep 2026 00:00:00 GMT

安慰好像不需要什么高深的技术，大部分时候你不需要安慰到点子上，你只需要让对方知道你在努力安慰他，就够了，因为这件事本身也是一种安慰。
爱情，是完美的友情。
友情极致是爱情，爱情终点是亲情。
人无远虑必有近忧的意思可能是：不想长远可能是最近事多。

大事记

Fri, 18 Sep 2026 00:00:00 GMT

2026.9.1 加入2026级开甲书院学创部，成为副部长#
2026.9.3 学创部相聚KFC，并一起面试剩下部员#
2026.9.7 写入党申请书#
2026.9.18 学创部全员聚餐#
2026.9.23 开甲团学联破冰大会#

选科概率计算

Tue, 15 Sep 2026 00:00:00 GMT

序言#

这是一个很简单的项目，甚至算不上项目，只是用程序解决问题。

起因#

选课初选是抽签的，如下：

选课界面

因为每刷新一次人数都会变动，如果带数据算每次都要按很多数字，因此写了程序来算。

输入格式#

按照以下格式将报名数据写入 in.txt ：

1
n
2

3
m1
4
a11 b11
5
a12 b12
6
a13 b13
7
...
8

9
m2
10
...

其中 nnn 表示有几个类型的课， mim_imi 表示每类课选了几个，然后 ai,ja_{i,j}ai,j 和 bi,jb_{i,j}bi,j 分别表示这门课程报名人数和招收人数。

理论过程#

于是我们假设不考虑复杂的机制（意愿顺序的影响、多门课程最多中一门），单纯用人数相除计算抽中的概率，来粗略表征抽中的几率。

有兴趣的读者可以展开讨论更复杂的情况。

通俗的说，一类课抽到的概率就是 111 减去全都不中的概率。

严谨的说，假设一类课选到的概率为 ppp ，选了 mmm 门课，每门课的报名人数和招收人数分别为 aia_iai 和 bib_ibi ，则：

p=1−∏i=1mbiaip=1-\prod_{i=1}^m\frac{b_i}{a_i}p=1−∏i=1maibi

当然，只是粗略计算，仅供参考。

计算完单门课之后，我们将数据存到 to.txt ，然后接着计算这几类课中抽中几个各自的概率，也就是不同类之间的排列组合。此处不展开，详见程序。

然后我们把结果输出到 out.txt ，稍微排版一下，得到结果。

程序实现#

计算某类课：

1
#include<bits/stdc++.h>
2
using namespace std;
3
int m,n,a[7][2];
4
double p;
5
int read(){//fast read,not necessary
6
    int x=0,f=0;
7
    char c=getchar();
8
    while(c<'0'||c>'9'){
9
        if(c=='-') f=1;
10
        c=getchar();
11
    }
12
    while(c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
13
    return f?-x:x;
14
}
15
int main(){
16
    freopen("in.txt","r",stdin);
17
    freopen("to.txt","w",stdout);
18
    m=read();
19
    cout<<m<<endl;
20
    while(m--){
21
        n=read();
22
        for(int i=1;i<=n;++i) a[i][0]=read(),a[i][1]=read();
23
        p=1;
24
        for(int i=1;i<=n;++i) p*=(double)(a[i][0]-a[i][1])/a[i][0];
25
        cout<<1-p<<" ";
26
    }
27
    return 0;
28
}

展开收起

计算综合概率：

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,op[7];
4
double ans[7],a[7];
5
void dfs(int p,int cnt){
6
    if(p>=n){
7
        double tt=1;
8
        for(int i=1;i<=n;++i) tt*=(op[i]?a[i]:(1-a[i]));
9
        ans[cnt]+=tt;
10
        return ;
11
    }
12
    op[p+1]=0;
13
    dfs(p+1,cnt);
14
    op[p+1]=1;
15
    dfs(p+1,cnt+1);
16
}
17
int main(){
18
    freopen("to.txt","r",stdin);
19
    freopen("out.txt","w",stdout);
20
    cin>>n;
21
    cout<<"通识\t\t科光\t\t美育\t\t体育\n";
22
    for(int i=1;i<=n;++i) cin>>a[i];
23
    for(int i=1;i<=n;++i) cout<<a[i]<<"\t";
24
    cout<<"\n\n";
25
    dfs(0,0);
26
    for(int i=0;i<=n;++i) cout<<"= "<<i<<" : "<<ans[i]<<"\n";
27
    cout<<"\n";
28
    for(int i=n-1;i>=0;--i) ans[i]+=ans[i+1];
29
    for(int i=0;i<=n;++i) cout<<">= "<<i<<" : "<<ans[i]<<"\n";
30
    cout<<"\n";
31
    cout<<"科光和美育至少一个 : "<<1-(1-a[2])*(1-a[3])<<"\n";
32
    cout<<"\n";
33
    cout<<"科光和美育都中 : "<<a[2]*a[3]<<"\n";
34
    cout<<"\n";
35
    cout<<"通识和科光和美育至少一个 : "<<1-(1-a[1])*(1-a[2])*(1-a[3])<<"\n";
36
    return 0;
37
}

展开收起

输出结果#

初选结束时，我的数据是这样的：

展开收起

1
out.txt
2

3
通识        科光        美育        体育
4
0.397145    0.545727    0.46386    0.811387
5

6
= 0 : 0.0276936
7
= 1 : 0.194607
8
= 2 : 0.391158
9
= 3 : 0.30497
10
= 4 : 0.0815717
11

12
>= 0 : 1
13
>= 1 : 0.972306
14
>= 2 : 0.7777
15
>= 3 : 0.386541
16
>= 4 : 0.0815717
17

18
科光和美育至少一个 : 0.756446
19

20
科光和美育都中 : 0.253141
21

22
通识和科光和美育至少一个 : 0.853172

展开收起

后记#

后来选课结果出了，这四类课中，我只有美育没有抽中，后面需要补选。

感觉还是比较符合计算出的概率的。

补充#

后来我使用脚本，在补退选阶段，成功抢到了美育课。

喜提疯狂星期四。

最终课表如下：

最终课表

取火柴问题变种

Sun, 13 Sep 2026 00:00:00 GMT

目录#

起因
问题构建 & 前置知识
手推过程
DSDSDS 过程
验证结论
补充

起因#

高中毕业，整理材料的时候，发现自己之前在草稿纸上探究到一半的变种取火柴问题。于是就展开来探究了一下。

问题构建 & 前置知识#

正常的取火柴问题是：一堆火柴一共有 nnn 根，有两个足够聪明的人轮流取火柴，每次可以取 1∼a1\sim a1∼a 根，取到最后一根火柴的人胜利，问先手必胜还是后手必胜。

例如，每次可以取 1∼31\sim 31∼3 根。很容易知道，当 4∣n4 \mid n4∣n 时，后手必胜，否则先手必胜。也就是说，对于取 1∼a1\sim a1∼a 的情况，当且仅当 nnn 是 (a+1)(a+1)(a+1) 的倍数时，后手必胜。这里不展开赘述。

现在我们要讨论的是，如果在 1∼a1\sim a1∼a 中跳过一个数不能取，周期会发生什么变化？如果跳过不止一个数，周期又会发生什么变化？

在后续的问题探讨中，可以采用线性递推的方式，例如，你已经知道总火柴数为 1∼n1\sim n1∼n 时分别的必胜情况，那么对于总数 (n+1)(n+1)(n+1) 的情况，只要能够一次取若干根跳到一个后手必胜的局面，那么该情况一定是先手必胜；若找不到，则后手必胜。

手推过程#

跳过一个数#

问题变为：每次可以取 1∼a1\sim a1∼a 或 (a+2)(a+2)(a+2)

这个问题依然比较经典，经过几个例子的尝试后可以发现，后手必胜情况的周期为断点位置，即后手必胜当且仅当 n=k(a+1),kn=k(a+1),kn=k(a+1),k 为正整数。

后面不止一个数#

问题变为：每次可以取 1∼a1\sim a1∼a 或 (a+2)∼b(a+2)\sim b(a+2)∼b

我们尝试举例。

尝试 111 222 444 ：后手必胜周期 333

尝试 111 333 444 ：后手必胜周期 2/52/52/5 交替，大周期 777

注意到，我们似乎需要比较前后两段数字的长短，也就是 aaa 和 (b−a−1)(b-a-1)(b−a−1) 的大小关系。

似乎，前半段较短时，会出现交替后手必胜周期；后半段较短时则不会？

尝试 1∼61\sim 61∼6 8∼138\sim 138∼13 ：后手必胜周期 777

尝试 1∼61\sim 61∼6 8∼148\sim 148∼14 ：后手必胜周期 7/157/157/15 交替，大周期 222222

推论：

当 2a+1≥b2a+1\geq b2a+1≥b ：后手必胜周期 (a+1)(a+1)(a+1)
当 2a+1<b2a+1 < b2a+1<b ：后手必胜周期 (a+1)/(b+1)(a+1)/(b+1)(a+1)/(b+1) 交替，大周期 (a+b+2)(a+b+2)(a+b+2)

经过多轮验证，应该成立。

开头一般化#

问题变为：每次可以取 a∼ba\sim ba∼b 或 (b+2)∼c(b+2)\sim c(b+2)∼c

这种情况不符合题目情况，总数为特定数时会出现最后几根怎么也取不走的情况，游戏无法进行。

故我们不讨论这种情况。

跳过若干数#

问题变为：每次可以取 1∼a1\sim a1∼a 或 (a+3)∼b(a+3)\sim b(a+3)∼b

我们毫无头绪，于是举例：

尝试 111 222 555 ：后手必胜周期 333

尝试 111 222 666 ：后手必胜周期 3/43/43/4 交替，大周期 777

尝试 111 222 777 ：后手必胜周期 333

尝试 111 222 888 ：后手必胜周期 333

尝试 111 222 999 ：后手必胜周期 3/3/43/3/43/3/4 交替，大周期 101010

尝试 111 222 101010 ：后手必胜周期 333

尝试 111 222 111111 ：后手必胜周期 333

尝试 111 222 121212 ：后手必胜周期 3/3/3/43/3/3/43/3/3/4 交替，大周期 131313

尝试 111 333 444 ：后手必胜周期 2/52/52/5 交替，大周期 777

尝试 111 444 555 ：后手必胜周期 2/62/62/6 交替，大周期 888

尝试 111 555 666 ：后手必胜周期 2/2/72/2/72/2/7 交替，大周期 111111

尝试 111 666 777 ：后手必胜周期 2/2/82/2/82/2/8 交替，大周期 121212

尝试 111 777 888 ：后手必胜周期 2/2/2/92/2/2/92/2/2/9 交替，大周期 151515

尝试 111 888 999 ：后手必胜周期 2/2/2/102/2/2/102/2/2/10 交替，大周期 161616

尝试 111 222 555 666 ：后手必胜周期 3/43/43/4，大周期 777

尝试 111 222 666 777 ：后手必胜周期 3/53/53/5，大周期 888

尝试 111 222 777 888 ：后手必胜周期 333

尝试 111 222 888 999 ：后手必胜周期 3/3/43/3/43/3/4，大周期 101010

感觉似乎是有规律的，但是我搞不明白，于是，我转向了 DeepseekDeepseekDeepseek 。

DSDSDS 过程#

经过 DSDSDS，我们发现，当取 1∼a1 \sim a1∼a c∼bc \sim bc∼b (c≥a+2)(c \ge a+2)(c≥a+2) 的时候：

如果不考虑 c∼bc \sim bc∼b 的部分，大于 aaa 的部分如果不是 (a+1)(a+1)(a+1) 的倍数，一定先手胜，所有 (a+1)(a+1)(a+1) 的倍数都是后手胜。

加入考虑， c∼bc \sim bc∼b 中可能影响后手胜位置的，便是其中是 (a+1)(a+1)(a+1) 倍数的数。例如含有 (2a+2)(2a+2)(2a+2) ，那么此时比 (2a+2)(2a+2)(2a+2) 略大的数，跳到的 (2a+2)(2a+2)(2a+2) 就会变成先手胜。

这个时候我们需要讨论，通过 1∼31\sim 31∼3 10∼1310\sim 1310∼13 和 1∼31\sim 31∼3 10∼1210\sim 1210∼12 两个例子，我们发现前者是 4/4/144/4/144/4/14 ， 141414 接在后边构成 222222 大周期，后者是 131313 把 4/44/44/4 包在里面形成 131313 大周期。

于是我又 DSDSDS 了一下，对于 1∼a1 \sim a1∼a c∼bc \sim bc∼b ，记 L=a+1L=a+1L=a+1 ，他给出的结论是:

1
if 后半段连续区间包含m*L（m为能取所有值的最小值）:
2
    if m>=2 and 后半段区间长>=L:
3
        T=(m-1)L+(b+1) 接尾型
4
    else:
5
        T=b+1 包裹型
6
else:
7
    T=a+1 断点型

对于分支一，通俗的解释是： 1∼a1\sim a1∼a 覆盖所有可到达的非倍数余数，如果无 LLL 的倍数，那么所有后手胜的位置都不会受到影响，等于是先手胜的位置自己之间加了一些连接。

对于分支二，通俗的解释是： bbb 是能减去的最大数， (b+1)(b+1)(b+1) 之前的数都按照 LLL 的倍数规则，其中 c∼bc\sim bc∼b 全部标为先手胜，那么如果 (b+1)(b+1)(b+1) 跳不到任何后手胜点，他自己就是后手胜，否则会被推迟到 (m−1)L+(b+1)(m-1)L+(b+1)(m−1)L+(b+1) 。

验证结论#

验证方案#

验证规则成立：对拍

对拍，具体来说就是，对比“暴力递推”和“规律求解”两种方法得出的周期是不是都相同。

输入#

输入所有可以取的数，然后输出 nnn 为 1∼10001\sim 10001∼1000 分别是谁必胜，记先手必胜为 000 ，后手必胜为 111 。

规律求解法#

于是我先写了一个按照规则输出周期的代码 answer.cpp 。

暴力递推法#

在写这个代码的时候，我发现，我需要根据获得的 0/10/10/1 ansansans 数组来求它的最小周期，这个时候我们可以使用 KMPKMPKMP 匹配算法，此处不展开讲述，代码写入 duipai.cpp 。

随机数据生成#

这里我们使用 C++ 中的均匀整数生成工具，代码如 random.cpp 。

比对数据#

我写了一个程序，让他们自动生成 100010001000 次数据，比对 100010001000 次，看结果是否有差异。代码如 check.cpp 。

参考代码#

所有代码如下：

answer.cpp展开收起

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,A[105],m,L,a,c,b,T;
4
bool flag;
5
int read(){
6
    int x=0,f=0;
7
    char c=getchar();
8
    while(c<'0'||c>'9'){
9
        if(c=='-') f=1;
10
        c=getchar();
11
    }
12
    while(c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
13
    return f?-x:x;
14
}
15
int main(){
16
    n=read();
17
    for(int i=1;i<=n;++i) A[i]=read();
18
    //1.successive?
19
    flag=1;
20
    for(int i=2;i<=n;++i) if(A[i]!=A[i-1]+1){
21
        flag=0;
22
        a=A[i-1],c=A[i],b=A[n];
23
        break;
24
    }
25
    if(flag) T=A[n]+1;
26
    else{
27
        L=a+1;
28
        //2.mL?
29
        flag=0;
30
        for(int i=c;i<=b;++i) if(i%L==0){
31
            flag=1;
32
            m=i/L;
33
            break;
34
        }
35
        if(flag){
36
            if(m>=2&&b-c+1>=L) T=(m-1)*L+b+1;
37
            else T=b+1;
38
        }else T=L;
39
    }
40
    cout<<T;
41
    return 0;
42
}

展开收起

duipai.cpp展开收起

1
#include<bits/stdc++.h>
2
using namespace std;
3
int n,a[105],pi[1005];
4
bool flag,ans[1005];
5
int read(){
6
    int x=0,f=0;
7
    char c=getchar();
8
    while(c<'0'||c>'9'){
9
        if(c=='-') f=1;
10
        c=getchar();
11
    }
12
    while(c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
13
    return f?-x:x;
14
}
15
int main(){
16
    n=read();
17
    for(int i=1;i<=n;++i) a[i]=read();
18
    for(int i=0;i<1000;++i){
19
        flag=1,ans[i]=0;
20
        for(int j=1;j<=n;++j) if(i-a[j]==0||(i-a[j]>0&&ans[i-a[j]])) flag=0;
21
        if(flag) ans[i]=1;
22
    }
23
    //find circle
24
    for(int i=1;i<1000;++i){
25
        int j=pi[i-1];
26
        while(j>0&&ans[i]!=ans[j]) j=pi[j-1];
27
        if(ans[i]==ans[j]) ++j;
28
        pi[i]=j;
29
    }
30
    cout<<1000-pi[999];
31
    return 0;
32
}

展开收起

random.cpp展开收起

1
#include<bits/stdc++.h>
2
#include<random>
3
using namespace std;
4
int a,c,b,n,A[55];
5
int main(){
6
    default_random_engine e;
7
    uniform_int_distribution<int> u(1,20);
8
    e.seed(time(0));
9
    a=u(e);
10
    c=u(e)+a;
11
    b=u(e)+c;
12
    for(int i=1;i<=b;++i) if(i<=a||(c<=i&&i<=b)) A[++n]=i;
13
    cout<<n<<"\n";
14
    for(int i=1;i<=n;++i) cout<<A[i]<<" ";
15
    return 0;
16
}

展开收起

check.cpp展开收起

1
#include<bits/stdc++.h>
2
#include<windows.h>
3
using namespace std;
4
int main(){
5
    int T=1000;
6
    while(T--){
7
        printf("#%d\n",1000-T);
8
        system("random.exe > random.txt");
9
        system("duipai.exe < random.txt > duipai.txt");
10
        double st=clock();
11
        system("answer.exe < random.txt > answer.txt");
12
        double ed=clock();
13
        if(system("fc duipai.txt answer.txt")) return(printf("Wrong Answer  %.0lfms",ed-st))&&0;
14
        else if(ed-st>1000) return(printf("Time Limit Exceeded  %.0lfms",ed-st))&&0;
15
        else printf("Accepted  %.0lfms\n",ed-st);
16
        puts("");
17
    }
18
    return 0;
19
}

展开收起

结果#

一开始，第 747474 个比对出现差异，原因是当时 answer.cpp 第 333333 行的 break 忘记加了。

更正后， 100010001000 次答案均无差异。

因此，推断结论成立。

若后半段不是连续区间呢？

似乎没有确切规律，或者说规律太过复杂，有兴趣的读者可以自行探究。

补充#

最后问了一下 DSDSDS 这在博弈论里是什么问题，他是这么说的，仅供参考：

是的，这个问题属于组合博弈论（Combinatorial Game Theory）的范畴，具体是无偏博弈（impartial game）中的减法游戏（subtraction game），也可以看成是单堆 Nim 的变种。

食物旅行

Sun, 06 Sep 2026 00:00:00 GMT

食物图

名称：霸碗盖码饭
地点：南京鼓楼区南京大学附近
上榜原因：在南京吃到了青椒炒肉，味道不错

食物图

名称：喜赞 · 轻食
地点：南京鼓楼区南京大学附近
上榜原因：虽然是轻食，但是量挺足，价格也比较实惠，味道也不错

家庭食谱

Mon, 17 Aug 2026 00:00:00 GMT

丝瓜汤#

食材#

瘦肉、丝瓜
蒜
油、盐、酱油

步骤#

瘦肉切小片，加适当盐，用地瓜粉或葛粉加适量水拌均匀，静置到水吸干，然后再加一点水，保持湿润；丝瓜沿纵切面对半切，然后分别切片；蒜头切片
热锅，倒油，油热放蒜片
倒丝瓜，加盐，炒一炒，加酱油
倒水，水烧开再加肉，肉加入后用锅铲将肉切分成小块，避免大块难熟
搅一搅，煮到肉看着熟了，再煮一会儿，可出锅

其他#

肉切的时候最好垂直于纹理切，这样比较嫩
from mother

西红柿炒蛋#

西红柿炒蛋（原图直出）

食材#

鸡蛋、西红柿
油、盐、酱油

步骤#

西红柿对半切开、去蒂、切成扇形，若要小块还可以将扇形对半切开；鸡蛋打入碗中，搅匀成蛋液
起锅倒油，颠锅让油铺满锅底，油热后均匀倒入蛋液
等底部差不多成型之后，将整个蛋面翻过来
倒入西红柿，翻炒，加少量盐，加一点点酱油
至蛋呈现金黄色、西红柿出汁，再炒一会儿即可出锅

其他#

切西红柿的时候，捏着两边比较好切
蛋液整块翻会比较均匀好看
盐也可以在加西红柿之前放
from mother

紧张该怎么办

Mon, 17 Aug 2026 00:00:00 GMT

目录#

发端
风暴
总结

发端#

高考好紧张，语文紧张，数学紧张，还好后面没那么紧张，最后只考砸了一科。

风暴#

追本溯源#

后面之所以不紧张，靠的是“考砸就算了，懒得管，随他便”的自暴自弃心态，还有“我知道我还有分要追”的理智。

紧张是为什么呢？我之所以紧张，是因为在意，注意这不等于重要。

对于高考，我在想如果失败了怎么办，或者，系统的说，因为只有一次机会、变数很大且起决定性作用。

“大家普遍觉得重要”不是直接原因，而是导致我认为高考“起决定性作用”的原因。

生物心态最好了。万事开头难啊。

对症下药#

对于“决定性作用”，重要是世人贴的标签，真的一定重要吗？我们从小到大，每个阶段都说是“关键”“重要节点”。重要个锤子。

对于“变数很大”，没变数的事情还需要担心吗？

对于“只有一次机会”，每个人的人生都是独一无二的一条路，你不是非得在跟别人一模一样的路上追上甚至超过别人。所以尽量不要在意岔路的结果，尽管这很难。如果真的做不到，那就至少在重大事情来临前，充分思考明白，不要逃避！

整体的过程是，首先你要发现自己处于紧张状态，接着用一些东西让自己冷静，然后进入重大事件的专注。

以下是可以试试的办法：

（临场）#

悲观一点的-天命既定，水来土掩

乐观一点的-天命在我，超常必胜

理性回归的-紧张不能解决问题啊，理性理性（此法对我没用，好像会更紧张）

（早期）#

预设可接受的be结局-也就是提前预设好最坏的结果，充分思考，提前难过

提前想想，要是真失败了，那大不了就***，管他的

失去这次机会会造成什么负面影响？……好像也就那样吧

总结#

紧张八字诀：天命既定水来土掩

英语七选五风波

Tue, 11 Aug 2026 00:00:00 GMT

项目概述#

起因
问题背景
数学方法计算
程序模拟计算
补充
总结
拓展

起因#

事情是这样的。

高一的时候，英语还没有积累太多，经常在阅读限时训练中做不到最后一篇七选五。

其中有一次，我破罐子破摔，直接蒙了五个上去。

结果如图所示：

英语答题卡惨状

我悲从中来，不禁思考，我，竟然如此倒霉吗？一个都没有蒙对。

于是，我展开了对此的计算。

问题背景#

为了得到一个通性的计算方式，我们将问题一般化为：对于一道 mmm 选 nnn 的英语阅读题，随机选择互不相同的选项填上去，答案对 kkk 个的概率是多少？ (0≤k≤n,1<n≤m)(0 \le k \le n, 1 < n \le m)(0≤k≤n,1<n≤m)

例如，对于一道七选五，你的答案可以填： EDCBAEDCBAEDCBA 、 CFDEACFDEACFDEA 、 BGDFCBGDFCBGDFC ……

为了方便说明，我们不妨假设正确答案为 ABCDEABCDEABCDE 。

数学方法计算#

首先，对于对 kkk 个的情况，不难想到分步乘法，先在 nnn 个空里选出 kkk 个是填对的，也就是 CnkC_n^kCnk ，然后剩余 (n−k)(n-k)(n−k) 个都是错的。

对于剩余填错的那些空，正面计算显然不太容易，于是正难则反。

假设对于这 (n−k)(n-k)(n−k) 个空和剩下的 (m−k)(m-k)(m−k) 个选项，猜对 XXX 个空对应的方案数为 cnt(X)cnt(X)cnt(X) ；选择 XXX 个空填对、剩下乱填对应的方案数为 pre(X)pre(X)pre(X) ，则：

我们需要得到 cnt(0)cnt(0)cnt(0) 。

根据容斥原理，乱填 (n−k)(n-k)(n−k) 个的情况数，需要扣掉选一个空填对、剩下 (n−k−1)(n-k-1)(n−k−1) 个乱填的情况数，但是在 Cn−k1×Am−k−1n−k−1C_{n-k}^{1} \times A_{m-k-1}^{n-k-1}Cn−k1×Am−k−1n−k−1 的计算过程中，对于每一次“选一个填对”的操作，不同的这些操作之间包含的情况数可能重叠，因为后面的是随便填的。

而重叠的部分，正是那些选两个空填对、剩下 (n−k−2)(n-k-2)(n−k−2) 个乱填的情况。

但是，这样又会造成一些情况被多扣掉，也就是那些选三个空填对、剩下 (n−k−3)(n-k-3)(n−k−3) 个乱填的情况，需要加回来。

以此类推，也就是： cnt(0)=pre(0)−pre(1)+pre(2)−cnt(0)=pre(0)-pre(1)+pre(2)-cnt(0)=pre(0)−pre(1)+pre(2)− ……

最后，我们可以得到：

对于一道 mmm 选 nnn ，答案对 kkk 个的情况数是： (0≤k≤n,1<n≤m)(0 \le k \le n, 1 < n \le m)(0≤k≤n,1<n≤m)

Cnk×∑i=0n−k[(−1)iAm−k−in−k−iCn−ki]C_n^k \times \sum_{i=0}^{n-k}[(-1)^i A_{m-k-i}^{n-k-i} C_{n-k}^i]Cnk×∑i=0n−k[(−1)iAm−k−in−k−iCn−ki]

用公式计算了七选五的情况及其概率，草稿如下：

草稿

这个计算结果可以方便我们对下面的频率估计概率提供参照。

程序模拟计算#

我们知道，当样本足够大的时候，用频率估计概率，可以大致估计出这个问题的答案。

我们又知道，计算机的很多随机数其实是不太均匀的，比如一些以时间刻度为标准的随机数，在密集调取时就会出很大问题。

虽然计算机可能没有完全的随机数，但是我们可以找一个更精确一点的。

我们引入 C++ 的 random 库，使用 uniform_int_distribution 随机整数生成函数。

模拟从 mmm 个选项选 nnn 个填入空，然后判断对了几个，同时计数。

程序代码如下：

1
#include<bits/stdc++.h>
2
#include<windows.h>
3
#include<conio.h>
4
#include<random>
5
using namespace std;
6
int n,m,a[102],t;
7
long long T,per,sum,cnt[102];
8
bool v[102];
9
inline int read(){
10
    int x=0,f=0;
11
    char ch=getchar();
12
    while(ch<'0'||ch>'9'){
13
        if(ch=='-') f=1;
14
        ch=getchar();
15
    }
16
    while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
17
    return f?-x:x;
18
}
19
int main(){
20
    //input
21
    SetConsoleTitle("\"from m choose n\" simulate");
22
    system("color F0");
23
    printf("from m choose n:");m=read(),n=read();
24
    printf("sample size:");T=read();
25
    printf("per step:");per=read();
26
    //random seed
27
    default_random_engine e;
28
    uniform_int_distribution<int> u(1,m);
29
    e.seed(time(0));
30
    //process
31
    while(T-->0){
32
        //init
33
        for(int i=1;i<=m;++i) v[i]=0;
34
        //make data
35
        for(int i=1;i<=n;++i){
36
            t=u(e);
37
            if(v[t]) --i;
38
            else v[t]=1,a[i]=t;
39
        }
40
        //count
41
        t=0;
42
        for(int i=1;i<=n;++i) if(a[i]==i) ++t;
43
        ++cnt[t],++sum;
44
        //print
45
        if(sum%per==0){
46
            system("cls");
47
            printf("from %d choose %d\n",m,n);
48
            printf("total %lld\n",sum);
49
            for(int i=0;i<=n;++i) printf("%d correct %lld %.4lf%%\n",i,cnt[i],(double)cnt[i]*100/sum);
50
//            printf("(press any key to continue)");
51
//            getch();
52
        }
53
    }
54
    //result
55
    system("cls");
56
    printf("#result\n\n");
57
    printf("from %d choose %d\n",m,n);
58
    printf("total %lld\n",sum);
59
    for(int i=0;i<=n;++i) printf("%d correct %lld %.4lf%%\n",i,cnt[i],(double)cnt[i]*100/sum);
60
    printf("\npress any key to end");
61
    getch();
62
    return 0;
63
}

展开收起

需要输入的数据：

mmm -几个选项
nnn -几个空
TTT -样本大小
perperper -每一跳大小

我们取 m=7,n=5,T=108,per=105m=7,n=5,T=10^8,per=10^5m=7,n=5,T=108,per=105 ，得到如下模拟结果：

模拟结果

对于生成的概率，我们保留百分数两位小数，可以发现数值一样。

由此我们得出，对于 10810^8108 的样本大小，这个随机种子产生的结果与真实概率的误差 δ<0.01%\delta < 0.01\%δ<0.01% ，可接受。

同时我们也双重验证了上述数学计算过程应该没问题。

补充#

在七选五问题中，我们只考虑了填五个不一样的选项。

那如果填五个一样的选项呢？不难发现，全错的概率是 27\frac{2}{7}72 ，对一个的概率是 57\frac{5}{7}75 。

我们计算一下两种填法的期望，发现期望得分是相同的。

具体原因在此不详细阐释，可自行证明。

总结#

如果你和我有类似的经历，不要灰心，是全部蒙错的概率本来就高达 48.17%48.17\%48.17% ，甚至全错和对一个的概率加起来，就已经达到 84.09%84.09\%84.09% ，这并不能证明你运气不好，只能说蒙对还是太难了。

如果你追求稳妥，可以填五个一样的选项，这样至少得分的概率是 57\frac{5}{7}75 ，不至于较大概率没分。

当然，你想搏一搏，也未尝不可，毕竟还有 0.0397%0.0397\%0.0397% 的全对概率等着你~

拓展#

有兴趣的话，可以探索一下，填几个相同的选项，得分会比较舒服。

包括但可能不限于：（用同一个数字表示同一个选项）

12345（已探究）
11111（已探究）
12222
11222
11223
11234

如果有其他成果，欢迎发邮件到 juzi75@qq.com 。

拟合与回归-神经网络初体验

Sat, 01 Aug 2026 00:00:00 GMT

项目概述#

前置准备
部分原理
问题实例
Python实现步骤
结果
总结

前置准备#

个人采用的是PyTorch，可以在PyTorch官网选择对应配置，然后在你电脑的cmd运行给出的指令即可。

PyTorch是一个开源深度学习框架，主要用于 计算机视觉、自然语言处理 等人工智能领域。它以 动态计算图和自动微分 为核心特性，兼具灵活性与部署能力。

对于想用Python实现的人，PyTorch无疑是最佳选择。

值得一提的是，较大项目可能比较吃内存（建议16-32G）（小的也能跑就是了），同时最好支持GPU加速。

对于此项目，个人觉得基本没怎么消耗算力。

部分原理#

关于原理，肯定无法详细完全展开，这里仅谈谈个人觉得比较有意思的。

随机梯度下降（SGD）#

SGD，一种形象的理解是，对于二变量，通过计算估测值和真实值的差距，得到一个函数，这个函数可以看成一片丘陵，而你要接近最低点，也就是误差最小的地方。

借的图

对于当前所站的位置，计算一下坡面是向哪个方向倾斜的，然后朝这个方向走一定的步子，如果误差变小了，就走过去。

当然，只是这么做可能会陷入局部最优解，就像一个不那么低的盆地。

因此需要提及下面的内容。

SGD的优化#

值得一提的是，一开始本来只是想学习并了解 SGD ，但是最后并没有直接用 SGD ，而是用了优化版的 Adam——可以理解为动量+步子优化。

动量优化就是保留原有行走方向的一个惯性，防止路线七拐八绕。

步子优化就是根据坡度调整迈大步还是迈小步。

全连接前馈神经网络（MLP）#

MLP是最基础的 全连接神经网络 ，只包含信号映射和激活函数两个部分。

形象地说，先有一个输入层，包括若干变量的输入，然后会经历一些隐藏层，然后再到输出层输出结果。

对于每个神经元，它会对传来的数据进行特定运算，然后套上激活函数，传信号给下一个神经元。

特定运算中的函数有待定的系数，根据输出的误差情况进行调整，以接近最优解。

激活函数类似于神经元的阈值机制，只有刺激强度超过一定阈值的信号才能被传下去。（修改意见：uuk）

激活函数是一类让其实现“对非线性数据的拟合”的一种映射函数。

最常见的是模拟人类神经元的阈值传导模式，也就是接下来要说的ReLU。

当然，还有各种对它的优化和其他激活方式，这里我未展开更多探究，因此暂时略过。

ReLU函数#

这是常用的激活函数，表达式如下：

ReLU(x)={x,x>00,x≤0\text{ReLU}(x) = \begin{cases} x, & x > 0 \\ 0, & x \leq 0 \end{cases}ReLU(x)={x,0,x>0x≤0

图像如图所示：

ReLU函数图像

它的神奇之处在于，可以通过套这个东西来拟合非线性的关系，感性地理解，是因为较弱的信号被削掉了。

数据标准化#

注意到，ReLU以 000 为拐点，而数据千奇百怪。

想要套用这个函数，比起调整这个函数，调整每一组数据显得更为合理。

每组数据会统一化成均值为 000 、方差为 111 的一组数据。

记原始数据为 aia_iai ，标准化后数据为 bib_ibi ，原数据均值为 xxx ，标准差为 sss ，那么：

bi=(ai−x)/sb_i=(a_i-x)/sbi=(ai−x)/s

问题实例#

为了更好地实操，这里模拟一种情境。

某座城市里，设房面积为 x1x_1x1 平米，建成后过了 x2x_2x2 年，距离市中心 x3x_3x3 千米，房子总价为 yyy 万元。（60≤x1≤560,1≤x2≤30,1≤x3≤5060 \leq x_1 \leq 560,1 \leq x_2 \leq 30,1 \leq x_3 \leq 5060≤x1≤560,1≤x2≤30,1≤x3≤50）

我们假设这些变量一定满足如下关系：

y=x1tanh(x3)−x2y=\frac{x_1}{tanh(x_3)} - \sqrt {x_2}y=tanh(x3)x1−x2

其中 tanh(x)tanh(x)tanh(x) 函数是双曲正切函数。

当然，可能不太符合生活实际，甚至可能出现负数。

不过，我们现在就可以生成一些数据，对一个确定性关系进行拟合回归。

Python实现步骤#

0. 涉及的Python库#

numpy（处理数据）
torch（构建模型）
matplotlib（生成直观图）

1. 生成随机训练数据#

使用C++的mt_19937随机数。代码如下：

1
#include<bits/stdc++.h>
2
#include<random>
3
using namespace std;
4
int x[6],a[1005][6],n;
5
double calc(int t[6]){return t[1]/tanh(t[3])-sqrt(t[2]);}
6
bool valid(){
7
    for(int i=1;i<=n;++i) if(x==a[i]) return false;
8
    return true;
9
}
10
int main(){
11
    freopen("data.txt","w",stdout);
12
    random_device rd;
13
    mt19937 gen(rd());
14
    uniform_int_distribution<int> d1(60,560),d2(1,30),d3(1,50);
15
    while(n<1000){
16
        do{x[1]=d1(gen),x[2]=d2(gen),x[3]=d3(gen);}while(!valid());
17
        ++n;
18
        for(int i=1;i<=3;++i) a[n][i]=x[i];
19
    }
20
    for(int i=1;i<=n;++i) cout<<a[i][1]<<" "<<a[i][2]<<" "<<a[i][3]<<" "<<calc(a[i])<<"\n";
21
    return 0;
22
}

展开收起

然后我们得到data.txt。

2. 读取数据#

3. 划分训练集和测试集#

4. 转为张量并标准化#

5. 创建神经网络模型#

6. 训练+保存#

7. 评估+可视化#

上述过程代码如下：

1
import numpy as np
2
import torch
3
import torch.nn as nn
4
import torch.optim as optim
5
from torch.utils.data import DataLoader, TensorDataset
6
import matplotlib.pyplot as plt
7

8
# -------------------- 1. 从 data.txt 读取数据 --------------------
9
# 读取：每行 x1 x2 x3 y，数据之间用空格或制表符分隔
10
data = np.loadtxt('data.txt')  # shape: (1000, 4)
11

12
X = data[:, :3]   # 前3列是特征 (1000, 3)
13
y = data[:, 3:4]  # 第4列是目标值 (1000, 1)
14

15
print(f"加载数据完成，总样本数: {X.shape[0]}")
16

17
# -------------------- 2. 划分训练集和测试集 (8:2) --------------------
18
n_total = X.shape[0]
19
n_train = int(0.8 * n_total)  # 800
20
n_test = n_total - n_train
21

22
X_train_np = X[:n_train]
23
y_train_np = y[:n_train]
24
X_test_np = X[n_train:]
25
y_test_np = y[n_train:]
26

27
# 转为 PyTorch Tensor
28
X_train = torch.tensor(X_train_np, dtype=torch.float32)
29
y_train = torch.tensor(y_train_np, dtype=torch.float32)
30
X_test = torch.tensor(X_test_np, dtype=torch.float32)
31
y_test = torch.tensor(y_test_np, dtype=torch.float32)
32

33
# -------------------- 3. 标准化（使用训练集的均值和标准差） --------------------
34
# dim-dimension保留维度，计算结果仍是二维张量，便于后续归一化
35
mean = X_train.mean(dim=0, keepdim=True)
36
std = X_train.std(dim=0, keepdim=True)
37
X_train = (X_train - mean) / std
38
X_test = (X_test - mean) / std
39

40
# -------------------- 4. 创建 DataLoader --------------------
41
train_loader = DataLoader(TensorDataset(X_train, y_train), batch_size=32, shuffle=True)
42
test_loader = DataLoader(TensorDataset(X_test, y_test), batch_size=32, shuffle=False)
43

44
# -------------------- 5. 定义神经网络模型 --------------------
45
class Net(nn.Module):
46
    def __init__(self):
47
        super().__init__()
48
        self.fc1 = nn.Linear(3, 128)
49
        self.fc2 = nn.Linear(128, 64)
50
        self.fc3 = nn.Linear(64, 1)
51
        self.relu = nn.ReLU()
52

53
    def forward(self, x):
54
        x = self.relu(self.fc1(x))
55
        x = self.relu(self.fc2(x))
56
        x = self.fc3(x)
57
        return x
58

59
model = Net()
60
criterion = nn.MSELoss()
61
optimizer = optim.Adam(model.parameters(), lr=0.001)
62

63
# -------------------- 6. 训练循环 --------------------
64
epochs = 200
65
train_losses = []
66
test_losses = []
67

68
for epoch in range(epochs):
69

70
    # 训练模式
71
    model.train()
72
    total_loss = 0
73
    for Xb, yb in train_loader:
74
        optimizer.zero_grad()
75
        pred = model(Xb)
76
        loss = criterion(pred, yb)
77
        loss.backward()
78
        optimizer.step()
79
        total_loss += loss.item() * Xb.size(0)
80
    train_loss = total_loss / len(train_loader.dataset)
81
    train_losses.append(train_loss)
82

83
    # 测试集评估
84
    model.eval()
85
    test_loss = 0
86
    with torch.no_grad():
87
        for Xb, yb in test_loader:
88
            pred = model(Xb)
89
            loss = criterion(pred, yb)
90
            test_loss += loss.item() * Xb.size(0)
91
    test_loss = test_loss / len(test_loader.dataset)
92
    test_losses.append(test_loss)
93

94
    if (epoch + 1) % 20 == 0:
95
        print(f"Epoch {epoch+1:3d} | Train Loss: {train_loss:.6f} | Test Loss: {test_loss:.6f}")
96

97
# -------------------- 7. 保存模型 --------------------
98
torch.save(model.state_dict(), 'house_price_model.pth')
99
print("模型已保存为 house_price_model.pth")
100

101
# 同时保存标准化参数，以便后续预测新数据时使用
102
np.save('mean.npy', mean.numpy())
103
np.save('std.npy', std.numpy())
104
print("标准化参数已保存为 mean.npy 和 std.npy")
105

106
# -------------------- 8. 评估和可视化 --------------------
107
model.eval()
108
with torch.no_grad():
109
    y_pred = model(X_test).numpy()
110
    y_true = y_test.numpy()
111

112
# 计算 R^2
113
ss_res = ((y_true - y_pred) ** 2).sum()
114
ss_tot = ((y_true - y_true.mean()) ** 2).sum()
115
r2 = 1 - ss_res / ss_tot
116
print(f"测试集 R^2 分数: {r2:.6f}")
117

118
# 绘制预测 vs 真实图
119
plt.figure(figsize=(8, 6))
120
plt.scatter(y_true, y_pred, alpha=0.6, edgecolors='k', linewidth=0.5)
121
plt.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()], 'r--', linewidth=2)
122
plt.xlabel('True y (万元)')
123
plt.ylabel('Predicted y (万元)')
124
plt.title(f'Prediction vs True (R² = {r2:.4f})')
125
plt.grid(True, linestyle='--', alpha=0.5)
126
plt.show()
127

128
# 可选：绘制训练和测试损失曲线
129
plt.figure(figsize=(8, 4))
130
plt.plot(range(1, epochs+1), train_losses, label='Train Loss')
131
plt.plot(range(1, epochs+1), test_losses, label='Test Loss')
132
plt.xlabel('Epoch')
133
plt.ylabel('MSE Loss')
134
plt.legend()
135
plt.title('Loss during training')
136
plt.grid(True, linestyle='--', alpha=0.5)
137
plt.show()

展开收起

值得一提的是， R2R^2R2 是样本决定系数，介于 000 ~ 111 之间，越大拟合效果越好。

一开始，我没想起来，后来，死去的记忆开始攻击我。

样本决定系数

结果#

训练过程

拟合图

误差变化

预测比对

总结#

通过这次实操，我对人工智能领域有了初步了解
神经网络是个神奇的东西，简单的结构却能模拟复杂的数据，要感谢大脑生物学的馈赠
神经网络模型已经发展出很多种类，不妨也去了解一下其他模型

赋分原理的探索与程序实现

Mon, 06 Jul 2026 00:00:00 GMT

项目概述#

起因
赋分规则
逆推赋分比率
程序实现
总结
拓展

起因#

学校所买的智学网不包含赋分，看不见赋分，而且排名没分文理
自行排总分的时候缺少赋分过程，导致与学校发布排名的差别很大
问遍周围人发现没有人干过赋分这件事，无法白嫖
想要熟悉一下赋分过程
便于开盒

赋分规则#

步骤#

不论是什么级别（省/市/校）的赋分，都遵循相同的步骤。

我们记：

一个学生的原始分为 OOO ，赋分为 FFF
所在等级区间的最高原始分为 OupperO_{upper}Oupper ，对应赋分上界 FupperF_{upper}Fupper
所在等级区间的最低原始分为 OlowerO_{lower}Olower ，对应赋分上界 FlowerF_{lower}Flower

赋分的本质是映射，大致步骤：

根据 OOO 划定等级( AAA ~ EEE )
根据所在等级的 OupperO_{upper}Oupper 、 OlowerO_{lower}Olower 、 FupperF_{upper}Fupper 、 FlowerF_{lower}Flower ，代入公式进行计算
计算结果四舍五入得到 FFF

注：

每个等级的划分一般按照排名的百分比进行划分，例如 AAA 划为前 0%0\%0% ~ 15%15\%15%
每个等级对应的赋分上下界由相关人员决定，该等级的学生分数的赋分结果将填充该赋分区间

分级比例#

省份一般会对赋分比例进行公示，例如：

等级	比例	赋分区间
A	约 15%	100-86
B	约 35%	85-71
C	约 35%	70-56
D	约 13%	55-41
E	约 2%	40-30

约算#

值得一提的是，其中出现很多需要约算的地方，而约算的方式我们无从知晓，故需要一些默认处理。

计算等级划分排名线：总人数 ×15%\times 15\%×15% 可能并非整数，这里我们处理成四舍五入
计算等级划分分数线：当这个排名有多人同分时，我们不妨从该排名学生向上下寻找最近的另一分数分界线作为 等级划分分数线

例如下图， 15%15\%15% 等级分界线离原始分 595959 ~ 606060 划分线最近，所以我们向下取 OlowerO_{lower}Olower = 606060 ，对应 FlowerF_{lower}Flower = 868686

切线

代公式后得到的结果不是整数，我们四舍五入取整数作为赋分分数 FFF

公式#

Oupper−OO−Olower=Fupper−FF−Flower\frac{O_{upper}-O}{O-O_{lower}}=\frac{F_{upper}-F}{F-F_{lower}}O−OlowerOupper−O=F−FlowerFupper−F

例如：化学年段最高分 919191 ， AAA 线最低分 606060 。一个同学考了 737373 ，代入公式：

91−7373−60=100−FF−86\frac{91-73}{73-60}=\frac{100-F}{F-86}73−6091−73=F−86100−F

按计算器得：F=91.87≈92F=91.87≈92F=91.87≈92

误区#

赋分是按照 分数比例 给分，而不是排名比例给分

逆推赋分比率#

必要性#

显然，省市的比率没有什么用，因为我也无法获取到省市级考试大家的成绩。而智学网上只显示了原始分，非常影响手排总分段排（出分前）。年段由于一些原因，会调整赋分比例，只能问得 AAA 线约 50%50\%50% ，因此试图逆推年段比率

思路#

既然：

OOO →\to→ 分级 →\to→ 公式 →\to→ FFF

那么：

已知 FFF →\to→ 所在等级
已知 OOO + FFF + FupperF_{upper}Fupper + FlowerF_{lower}Flower →\to→ OupperO_{upper}Oupper + OlowerO_{lower}Olower
AAA 等级的 OupperO_{upper}Oupper 已知，为最高分
可依次推得原始分分数线
段排/总人数即为大概的比例

我们可以：

获取样本（ OOO 和对应的 FFF ）
判断所在等级区间，得出 FupperF_{upper}Fupper 和 FlowerF_{lower}Flower
OupperO_{upper}Oupper 已知的情况下，公式计算出 OlowerO_{lower}Olower
用“ OlowerO_{lower}Olower 所处段排”比上“该科考试总人数”得到百分比

举例#

例如：化学年段最高分 919191 ，一个同学考了 737373 ，赋出来 92>8592>8592>85 ，显然 AAA 。代入公式：

91−7373−Olower=100−9292−86\frac{91-73}{73-O_{lower}}=\frac{100-92}{92-86}73−Olower91−73=92−86100−92

按计算器得： Olower=59.5≈60O_{lower}=59.5≈60Olower=59.5≈60

查看：“ 595959 分对应的段排 −1-1−1 ”（≥ 606060 分的人数）为 383383383

化学考试总人数（去掉 000 分）为 772772772

所以 383/772=49.61%≈50%383/772=49.61\%≈50\%383/772=49.61%≈50%

可见，计算存在误差，特别是该科人数少的时候。但是 50%50\%50% 是个极好的数字，大概率是正确的。与获得的 AAA 线信息比照也说明算法正确。

程序实现赋分#

实现流程#

文件读入
对于每个赋分科目：排序，计算有效人数，计算排名切线与分数切线，并分别代公式
善后：物理类/历史类分流，文件输出

代码实现#

1
#include<bits/stdc++.h>
2
#include<conio.h>
3
using namespace std;
4
struct Stu{
5
    int id;
6
    string name;
7
    //0 [1,9]
8
    double origin[12],last[12];
9
}a[1145],li[1145],wen[1145];
10
int n,nli,nwen,nt,t,cut[8],p,fs[]={0,100,85,70,55,40},fx[]={0,86,71,56,41,30};
11
double rate[8]={0,0.50,0.87,0.92,0.97,1.00},fup,fdown,oup,odown,ori;
12
// rate  50% 37% 10% 3%  0%
13
//score  86  71  56  41  30
14
int main(){
15
    //get data
16
    freopen("firstget.txt","r",stdin);
17
    while(1){
18
        ++n;
19
        cin>>a[n].id;
20
//        if(a[n].id!=a[n-1].id) cout<<a[n].id<<" *\n";//
21
        if(a[n].id==0) break;
22
        cin>>a[n].name;
23
        for(int i=0;i<=9;++i) cin>>a[n].origin[i],a[n].last[i]=a[n].origin[i];
24
    }
25
    --n;
26
    cout<<"n="<<n<<"\n";
27
    //for each subject
28
    for(t=5;t<=9;++t){
29
        if(t==7) continue;
30
        //sort by score
31
        sort(a+1,a+n+1,[](Stu a,Stu b){return a.origin[t]>b.origin[t];});
32
        //count valid students
33
        nt=1;
34
        for(int i=1;i<=n;++i,++nt) if(a[i].origin[t]<=0) break;
35
        --nt;
36
        //find O_down
37
        for(int i=1;i<=5;++i){
38
            cut[i]=round((double)nt*rate[i]);
39
//            if(t==5) cout<<cut[i]<<" "<<a[cut[i]].origin[t]<<" *\n";//
40
            p=1;
41
            while(a[cut[i]].origin[t]==a[cut[i]+p].origin[t]&&
42
                a[cut[i]].origin[t]==a[cut[i]-p].origin[t]) ++p;//same score forward/backward
43
            //question:at the middle
44
//            if(t==5) cout<<cut[i]+p<<" "<<a[cut[i]+p].origin[3]<<" "<<cut[i]-p<<" "<<a[cut[i]-p].origin[3]<<"\n";//
45
            if(a[cut[i]].origin[t]!=a[cut[i]+p].origin[t]) cut[i]+=p-1;
46
            else cut[i]-=p-1;
47
        }
48
        //formula
49
        for(int i=1;i<=5;++i){
50
            fup=fs[i],fdown=fx[i],oup=a[cut[i-1]+1].origin[t],odown=a[cut[i]].origin[t];
51
            for(int j=cut[i-1]+1;j<=cut[i];++j){
52
                ori=a[j].origin[t];
53
                a[j].last[t]=round((fup*(ori-odown)+fdown*(oup-ori))/(oup-odown));
54
            }
55
        }
56
    }
57
    //calulate final total score
58
    for(int i=1;i<=n;++i){
59
        a[i].last[0]=0;
60
        for(int j=1;j<=9;++j){
61
            if(j!=5&&j!=6&&j!=8&&j!=9) a[i].last[j]=a[i].origin[j];
62
            if(a[i].last[j]>=0) a[i].last[0]+=a[i].last[j];//plus no -1
63
        }
64
    }
65
    //wen/li divide
66
    sort(a+1,a+n+1,[](Stu a,Stu b){return a.origin[4]>b.origin[4];});
67
    for(int i=1;i<=n;++i){
68
        if(a[i].origin[4]<=0) break;
69
        nli=i;
70
        li[i]=a[i];
71
    }
72
    sort(a+1,a+n+1,[](Stu a,Stu b){return a.origin[7]>b.origin[7];});
73
    for(int i=1;i<=n;++i){
74
        if(a[i].origin[7]<=0) break;
75
        nwen=i;
76
        wen[i]=a[i];
77
    }
78
    //print result
79
    freopen("result_li.txt","w",stdout);
80
    sort(li+1,li+nli+1,[](Stu a,Stu b){return a.last[0]>b.last[0];});
81
    cout<<"班级\t姓名\t总分\t语文\t数学\t英语\t物理\t化学原始分\t化学赋分\t生物原始分\t生物赋分\t地理原始分\t地理赋分\t政治原始分\t政治赋分\t\n";
82
    for(int i=1;i<=nli;++i){
83
        cout<<li[i].id<<"\t"<<li[i].name<<"\t";
84
        for(int j=0;j<=3;++j) cout<<li[i].last[j]<<"\t";
85
        cout<<li[i].last[4]<<"\t";
86
        for(int j=5;j<=9;++j) if(j!=7) cout<<li[i].origin[j]<<"\t"<<li[i].last[j]<<"\t";
87
        cout<<"\n";
88
    }
89
    freopen("result_wen.txt","w",stdout);
90
    sort(wen+1,wen+nwen+1,[](Stu a,Stu b){return a.last[0]>b.last[0];});
91
    cout<<"班级\t姓名\t总分\t语文\t数学\t英语\t历史\t化学原始分\t化学赋分\t生物原始分\t生物赋分\t地理原始分\t地理赋分\t政治原始分\t政治赋分\t\n";
92
    for(int i=1;i<=nwen;++i){
93
        cout<<wen[i].id<<"\t"<<wen[i].name<<"\t";
94
        for(int j=0;j<=3;++j) cout<<wen[i].last[j]<<"\t";
95
        cout<<wen[i].last[7]<<"\t";
96
        for(int j=5;j<=9;++j) if(j!=7) cout<<wen[i].origin[j]<<"\t"<<wen[i].last[j]<<"\t";
97
        cout<<"\n";
98
    }
99
    freopen("CON","w",stdout);
100
    cout<<"finished\nenter to exit";
101
    getch();
102
    return 0;
103
}

展开收起

效果展示#

效果

总结#

收获#

再也不用担心看不到赋分了
可以自行总分排序，排名误差精度达到基本±3，鲜有±5（年段未修正分数时）提前开别人的盒
使我对赋分过程非常熟悉
开创了赋分程序之先河，供后人借鉴

不足#

与学校的赋分仍无法完全匹配，有误差
程序可能存在一些奇奇怪怪的BUG（尽管绝大多数时候它是对的）
想要这么做，需要先学会如何获取所有人的原始分，这个过程这里我们无法展开（尽管成绩可以通过询问他人实现，但这样就失去了“提前开盒”的乐趣意义）

拓展#

尽管实现了自己动手（赋分）丰衣足食，半年后，我再次想简化得到赋分后总排名的途径，想把抓取成绩程序和赋分程序结合，然而它们语言不通：Python / C++

于是我再次研究怎么把C++赋分程序打包成一个Python库让我可以直接在Python里调用

于是去问了Deepseek

询问

经历不少问题

曲折

最后终于解决

成果

打包成了一个.pyd文件，可以直接被其他程序调用。

至此，赋分的探索落下帷幕。

补充#

不久后，我再次使用，发现这个.pyd文件出了点问题，没法直接调用了。于是我就回归了使用C++和Python的原始版本。

Logistic-基于混沌映射的图片加密解密

Thu, 02 Jul 2026 00:00:00 GMT

项目概述#

起因
什么是Logistic混沌映射
Python图片处理的相关内容
实现过程
遇到的问题
总结

起因#

强基数学课程听得云里雾里，“误入歧途”和“走了歪路”双管齐下，老师的 “故国神游式” 讲法让我对上课内容一脸懵逼。一天晚上，我心血来潮，想找找上课所讲的逻辑斯蒂映射的动态图，结果没有找到，但是找到了这个：

搜索截图

于是乎，我心血来潮地打开Python尝试实现这东西。

搞这个比上强基好多了

Logistic混沌映射#

Logistic混沌

重要特点：

随机性

对初值的敏感性

Python图片处理#

涉及的Python库： PIL （图片处理）

函数	功能
Image.open()	打开一个图片
Image.size()	获取图片大小
Image.mode()	获取图片色彩模式(RGB/RGBA/灰度/etc.)
Image.getpixel((x,y))	获取某个像素点的颜色信息
Image.putpixel((x,y),color)	把某个点改为某颜色
Image.save()	保存图片

实现过程#

前置知识#

以RGB模式为例，像素点颜色的存储常为(R,G,B)，代码中体现为为color[ 000 ~ 222 ]，范围均为 000 - 255255255 。

为了满足 可还原性 （这里指A op B op B=A）和 封闭性 （这里指能将产生的数固定在某个范围）的要求，我们引入 “亦或” 操作。

异或 (Xor/⊕)：把两个数字化成二进制，对于每一位的两个数码，相同得0，不同得1，最后得到的数化回十进制数。整个过程 相当于不进位的加法 。例子如下：

1
1001(9)
2
1010(10)   ⊕
3
---------------
4
0011(3)
5

6

7
0011(3)
8
1010(10)   ⊕
9
----------------
10
1001(9)

至此我们完成了具体实现方式的构建。

实现流程#

加密和解密的桥梁，就是用同一组X0和μ进行Logistic推演产生的Xn数列。

graph TD A["输入X0,μ"] --> B["Logistic推演产生Xn(n=1,2,...)"] B --> C[取Xn数列里一个数对256取模为t] C --> D[把t和该像素点数字分别进行Xor加密] D --> E[用相同的t异或解密] E --> F[对比前后图片]

代码实现#

1
from PIL import Image
2
import math
3
import msvcrt
4

5
def Logistic(r,x,n):
6
    for i in range(n):
7
        x=r*x*(1-x)
8
    return x
9

10
if __name__=="__main__":
11
    #open
12
    image=Image.open(input('input file name:'))
13
    name=input('output file name:')
14
    width,height=image.size
15
    mode=image.mode
16
    print(f'Width:{width},Height:{height},Mode:{mode}')
17
    if mode!='RGB' and mode!='RGBA':
18
        print("can't do it")
19
    else:
20
        print('example r=3.75 x=0.50')
21
        r=float(input('r(3.57<=r<=4.00):'))
22
        x=float(input('x(0<x<1):'))
23
        #r,x=3.75,0.50
24
        temp=int(1145*r*r*r)
25
        x=Logistic(r,x,temp)
26
        key=0
27
        for xx in range(width):
28
            for yy in range(height):
29
                pixel=image.getpixel((xx,yy))
30
                x=Logistic(r,x,int(r*r))
31
                key=int(math.sqrt(x)*temp)%256
32
                aa=pixel[0]^key
33
                x=Logistic(r,x,int(math.sqrt(r)))
34
                key=int(math.sqrt(x)*temp)%256
35
                bb=pixel[1]^key
36
                x=Logistic(r,x,int(r))
37
                key=int(math.sqrt(x)*temp)%256
38
                cc=pixel[2]^key
39
                pixel=(aa,bb,cc)
40
                image.putpixel((xx,yy),pixel)
41
        image.save(name)
42
        print('finished.')
43
    print("Press any key to exit...")
44
    msvcrt.getch()

展开收起

遇到的问题#

图片格式会影响加密解密效果

png格式兼容性好，效果好；而jpg格式由于压缩的不可知问题会导致如下情景：

加密前

解密后

图片的存储大小变化

经过解密再加密的图片和原图相比，存储小了很多。

存储大小变化

暂时原因未知，猜测可能是：

非图片内容的其他信息数据被修改或破坏
图片在还原过程中有肉眼不可见的瑕疵，未能完美还原

暂时没有发现对图片质量产生明显影响的情况。至少还能打的开

总结#

Logistic映射的 随机性 很好的实现了图片像素点随机加密
初值敏感性 使得对图片的X0,μ的 暴力破解十分困难
从同一初始X0,μ开始时产生序列的 不变性 ，使得图片的加密和解密 过程可逆
诸如 存储大小变化 等未知问题仍待解决，目前暂时不敢将其应用于机密信息的加密

橘子75

AI Agent 初体验

目录#

背景#

配置#

opencode#

Deepseek Harness#

探索#

修复 Windows Defender#

排查磁盘大小占用问题#

编写计划软件#

总结#

AI Agent 太好用了！#

AI Agent 太好用了！#

AI Agent 太好用了！#

橘务通-计划规划软件

目录#

事发背景#

提示词编写#

调整#

环境情况#

静态网页#

构建 build#

修改小问题#

修正#

产品效果#

总结#

Agent 太好用了！#

Agent 太好用了！#

Agent 太好用了！#

零碎思考

大事记

2026.9.1 加入2026级开甲书院学创部，成为副部长#

2026.9.3 学创部相聚KFC，并一起面试剩下部员#

2026.9.7 写入党申请书#

2026.9.18 学创部全员聚餐#

2026.9.23 开甲团学联破冰大会#

选科概率计算

序言#

起因#

输入格式#

理论过程#

程序实现#

输出结果#

后记#

补充#

取火柴问题变种

目录#

起因#

问题构建 & 前置知识#

手推过程#

跳过一个数#

后面不止一个数#

开头一般化#

跳过若干数#

DSDSDS 过程#

验证结论#

验证方案#

输入#

规律求解法#

暴力递推法#

随机数据生成#

比对数据#

参考代码#

结果#

补充#

食物旅行

家庭食谱

丝瓜汤#

食材#

步骤#

其他#

西红柿炒蛋#

食材#

步骤#

其他#

紧张该怎么办

目录#

发端#

风暴#