真-大沙子的博客

从.NET Aspire看MySQL在云原生时代的退位

Tue, 30 Jun 2026 00:00:00 GMT

介绍#

image-JWXs.png

图源：https://db-engines.com/en/ranking_trend

作为常年稳居 DB-Engines 榜单前三的 MySQL 自然不必过多介绍可以说是它推动了关系型数据库的普及

.NET Aspire （在 2025 年 11 月发布的 Aspire 13 版本中，微软正式将其名称从.NET Aspire更改为Aspire）是新兴的开源应用平台，旨在简化云原生及分布式应用的开发、部署与运维。

这两者的”强强联手”想必能碰撞出明亮的技术火花，是云原生领域的又一力作。然而事实真的如此吗？

记录#

准备将.NET Aspire 示例项目通过 EF Core连接到本地MySQL 数据库时在Aspire官网的Integrations中只找到了 Aspire.Pomelo.EntityFrameworkCore.MySql 这一个支持包

连官方社区的 Community.Toolkit 都谈不上仅仅是一个第三方组织 Pomelo 的包而且一看仓库最新commit都是8个月前了 nuget上也还是.NET8的包抱着试一试的心态还是装上了并尝试与本地.NET10环境强行兼容

果然还是寄了

1
warning NU1608: 检测到的包版本在依赖项约束之外: Pomelo.EntityFrameworkCore.MySql 9.0.0 需要 Microsoft.EntityFrameworkCore.Relational (>= 9.0.0 && <= 9.0.999)，但版本 Microsoft.EntityFrameworkCore.Relational 10.0.5 已解决。

但这个Warning其实不是直接原因实际上的Error是Method not found: 'System.String Microsoft.EntityFrameworkCore.Diagnostics.AbstractionsStrings.ArgumentIsEmpty(System.Object)'

到API Reference里查了一下发现一个神奇的breaking change

Entity Framework Core 9.0

1
public static string ArgumentIsEmpty(object? argumentName);

Entity Framework Core 10.0

1
public static string ArgumentIsEmpty { get; }

可以看出ArgumentIsEmpty 的签名不声不响地从方法变成了属性并且文档中并没有相关说明

而相关包因故没有跟上这个变化从而导致使用命令行工具dotnet-ef 初始化数据库时出错

核心包Pomelo.EntityFrameworkCore.MySql 的issue列表中最新一条即为吐槽更新不及时导致无法连接到新版MySQL实例

总结#

社区生态活跃度是衡量一个项目或框架的重要指标像这样的”无人管理”反映了MySQL在Aspire中的边缘化以至于在整个关系型数据库和云原生领域的淡化

MySQL 本来就是仓促赶出来的半成品，至今如此
它甚至不能保证你数据不会丢

MySQL 一个事务都有致命深坑的垃圾数据库还是尽早抛弃的好

群友的态度也说明了问题

是时候转到PostgreSQL了

建立EntityFrameworkCore项目的模板

Tue, 30 Jun 2026 00:00:00 GMT

建立通用 AppHost项目

先在 Program.cs中配置好数据库连接

1
builder.AddNpgsqlDbContext<TasksContext>("Default-PostgreSQL", configureDbContextOptions: option =>
2
{
3
});

然后在 appsettings.json中添加数据库连接字符串

1
{
2
  // ...
3
  "ConnectionStrings": {
4
    "Default-PostgreSQL": "..."
5
  }
6
}

编写 DbContext 如下

1
using Microsoft.EntityFrameworkCore;
2

3
public class ExampleContext(DbContextOptions options) : DbContext(options)
4
{
5
    public DbSet<ExampleRecordType> Records { get; set; }
6
}

使用 dotnet-tools初始化数据库（建立初始化迁移）

Terminal window

1
dotnet ef migrations add InitialCreate
2
dotnet database update

成功的家庭网络配置&软路由记录

Tue, 30 Jun 2026 00:00:00 GMT

光猫桥接#

之前在出租屋搞过理论上握很熟悉这个流程了但不知道是被封锁了还是什么家里的光猫没法强制重置只能到咸鱼花了￥25查到了超级密码

用超级密码登录光猫后台记录INTERNET连接VLAN ID 删掉连接再新建一个Bridge类型的INTERNET连接填回VLAN ID就改好桥接了（注意关掉强推等会被运营商覆盖设置的功能）

另一个问题是我不知道宽带密码在出租屋咋搞的也不记得了根据经验猜了无数个密码组合都不行

根据网上的教程先用一个工具开光猫telnet 进去把加密的光猫配置文件导出来再用另一个工具解密就可以看到明文的配置文件了

中兴光猫telnet工具：https://github.com/douniwan5788/zte_modem_tools
备份：zte_modem_tools-main.zip
使用方法：python3 zte_factroymode.py --user CMCCAdmin --pass --ip 192.168.1.1 --port 80 telnet open
解密工具：https://pan.baidu.com/s/1kDfNa7nJ2madFadPlPgnjQ?pwd=y6my
备份：光猫破解工具.rar
使用方法： ./ztecfg.exe db_user_cfg.xml

之后就可以快乐地用路由器拨号上网了

铺设隐形光纤#

由于我家在装修时没有预埋网线导致只能走明线思考之后决定走隐形光纤沿着墙缝走线基本看不出来两头加上光纤收发器就可以当成正常网线来用了（有钱的可以直接用光口交换机/路由器或者千兆以上的光纤收发器来提升体验）

NUC软路由#

参见上一篇文章放弃了折腾好几天都没搞成功的ImmortalWrt系统

被同学点醒可以直接让DeepSeek via Claude Code帮我配环境加了 ssh-manager 的MCP就可以让Claude Code直接操作NUC了

NUC系统装的Debian 13 无线网卡的驱动也是自带的在AI的指导下也是经历了好几个阶段

阶段 1：WiFi 上联 + 网线直连（✅ 可行）#

flowchart LR subgraph internet[" "] INET([Internet]) end subgraph living["🏠 客厅 — 主路由 192.168.0.0/24"] MR[主路由 192.168.0.1] end subgraph room["💻 房间 — NUC"] NUC_W[wlp2s0 192.168.0.114/24] NUC_E[enp3s0 192.168.10.1/24 dnsmasq DHCP+DNS] end subgraph sec["🔒 副路由 NAT 域 — 192.168.2.0/24"] SR_WAN[WAN 口 DHCP 192.168.10.128] SR_LAN[LAN 口 192.168.2.1] CLI([客户端设备]) end INET --> MR MR -. WiFi .-> NUC_W NUC_W --> NUC_E NUC_E == 网线直连 ==> SR_WAN SR_WAN --> SR_LAN --> CLI

特征： WiFi 上联、双子网物理隔离、dnsmasq DHCP+DNS、nftables NAT masquerade。

阶段 2：纯有线单子网（❌ 不可行）#

致命缺陷： 副路由 DNS → 192.168.0.1:53 走交换机 L2 直达，clash 拿不到域名。

阶段 3：交换机 + 双子网（⚠️ DHCP 竞态）#

风险： NUC 和主路由两个 DHCP 同时可达副路由，WAN 口可能拿到 192.168.0.x。

阶段 4：LAN 口回环（❌ DHCP 风暴）#

致命缺陷： 回环线把 WAN 拖入广播域，主副路由 DHCP 双向泄露，网络卡死。

阶段 5：NUC 挂副路由下面（⚠️ 双层 NAT）#

缺点： NUC 对主网不可见（需 DMZ）、副路由故障连带 NUC 断网。

阶段 6：交换机 + 双子网 + 静态 IP（★ 最终方案）#

失败的软路由记录

Tue, 30 Jun 2026 00:00:00 GMT

今天上午面试结束也就是综评搞完了终于是完全解放了

中午回来想着把NUC再整整搞个心心念念的软路由玩玩

先装了个PVE试试上来就给我卡住了因为没法联网而我又不能熟练地在原始Linux环境下配网于是打算根据经验先装个NetworkManager（这里很神奇地能够联网因为我捣鼓着整出了把电脑连的WiFi通过以太网接口共享给NUC的操作）结果就踩坑了因为PVE自带的vmbr0桥接网络接口似乎和NetworkManager不兼容然后也不知道怎么办就直接给NetworkManager卸了之后又跟着各种教程用ip/ifup/ifdown试了半天（也包括问DeepSeek 但这家伙信息实在太不准了）

之后大概是重置了一下什么东西就能连上了（这时候还是网线直连电脑和NUC的情况）

总算登上PVE了 Web界面看着很舒服就是初始内存就占了不少 CPU也有不少占用又玩了会决定上个LXC装Tailscale（虽然我也不知道有啥用）于是又开始踩各种坑

首先是鬼脑发力想到用Tailscale共享网段得要桥接模式啊然后询问ai发现似乎WiFi连接没法这么搞（网口被我连电脑用了家里也不太方便想出租屋那样直接连到路由器上）现在搞清楚了是因为WiFi协议默认只有3个MAC地址在桥接情况下无法标识完整的包信息开启四地址模式可以解决但得看设备是否支持

之后为这个玩意又试了半天突然想起来我好像只是想搞个软路由来着于是决定直接在NUC上装软路由系统不要什么PVE了

选定了ImmortalWrt系统安装也费大劲了官网提供的img镜像需要在PE下直接写到NUC的硬盘上用的微PE正好又没有写盘工具幸亏NUC的USB接口丰富我直接拿U盘拷进去了一个写盘工具就成了（这里还有个小坑那个写盘工具必须要先把分区全部清空否则会报错并且没有任何信息）

终于进系统了这时候发现这个ImmortalWrt系统也是非常精简啊啥工具也没有装初始包只能通过网页上传这时候又被那个网线直连电脑的问题困住了

最终时间实在不早了下定决心把旧路由器拿过来当交换机用明天再试试

（这个旧路由器不支持IPv6和WiFi6 纯fw一个孱弱的上游连接能力导致我都没法放我房间当个AP用不过就网口来说有1WAN 4LAN的千兆口内网交换还是能用的）

（当AP失败还有个原因是家里没预留网线导致不能有线组网这个旧路由器又不能连WiFi6的无线暂时只能连2.4G的）

把旧路由器桥接到主网络（虽然只能是2.4G的）然后就能直接从电脑上访问ImmortalWrt的管理页面了

不得不说软路由系统占用确实小内存占用90MB 磁盘占用40MB

第二天：

得益于之前配好了路由器桥接和NUC的IP NUC连上路由器就能从其他局域网设备访问了但发现NUC还不能连通互联网于是先联网

在默认的br-lan接口中添加网关为主路由IP 添加DNS就可以了

之后从包管理器页面 apk update 一下就可以直接安装 luci-app-openclash 了

（这里依旧踩坑因为忘了重启导致试了很多办法都无法在页面中看到OpenClash的目录项）

之后手动下载clash meta内核并放到 /etc/openclash/core 目录下重命名为 clash_meta 再 chmod 755 clash_meta 就可以启动了

按照相关教程配置OpenClash的模式

最后还是不知道怎么回事把其他设备网关指向NUC之后仍然无法联网

依旧时间不早了决定直接摆烂明天装回Windows直接用图形界面的Clash Meta/Verge得了

第三天：

装Windows本来是这几天最简单的一次尝试但我灵机一动准备整个精简版系统

由于网上找不到合适的我直接用NTLite自己裁了个精简版（虽然并没有精简多少）顺便把买来的时候备份的一些驱动装上了

之后下载Clash并打开TUN模式可惜还是不行

又试了下Windows的网络共享和桥接（网桥）可能还是没搞明白总之就是要么连不上网要么连上了但Clash不起作用

可能是NUC5的8265网卡的兼容性问题

（中间包括用第三方小工具进行转发也是不行）

总之就是少碰跟硬件相关的东西我还是适合在功能完好的电脑上搞一些软件开发（我是不是以前也得出过这个结论）

一些经验#

联网#

参考刷入并配置immortalwrt进行上网

概要：在默认的br-lan接口中添加网关为主路由IP 添加DNS

换源#

Terminal window

1
sed -e 's,https://downloads.immortalwrt.org,https://mirrors.cernet.edu.cn/immortalwrt,g'  -e 's,https://mirrors.vsean.net/openwrt,https://mirrors.cernet.edu.cn/immortalwrt,g' -i.bak /etc/apk/repositories.d/distfeeds.list

安装OpenClash#

注意：装好了一定要重启！！！否则可能在面板里看不到OpenClash目录项

一些概率统计的公式推导

Sat, 13 Sep 2025 00:00:00 GMT

其实是在高二刚学的时候推的拖到现在才搞成电子稿（

二项分布#

设有二项分布

X∼B(n,p)X\sim \mathrm{B}(n,p)X∼B(n,p)

则有期望

μ=∑k=0nP(X=k)k=∑k=0nCnkpk(1−p)n−kk=∑k=1nCn−1k−1pk−1(1−p)(n−1)−(k−1)np=[p+(1−p)]n−1np=np\begin{aligned} \mu&=\sum_{k=0}^{n}{\mathrm{P}(X=k)k}\\ &=\sum_{k=0}^{n}{\mathrm{C}_n^k p^k (1-p)^{n-k} k}\\ &=\sum_{k=1}^{n}{\mathrm{C}_{n-1}^{k-1} p^{k-1} (1-p)^{(n-1)-(k-1)} np}\\ &=[p+(1-p)]^{n-1} np\\ &=np \end{aligned}μ=k=0∑nP(X=k)k=k=0∑nCnkpk(1−p)n−kk=k=1∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)np=[p+(1−p)]n−1np=np

方差

σ2=∑k=0nP(X=k)(k−μ)2=∑k=0nP(X=k)k2−2μ∑k=0nP(X=k)k+μ2=∑k=0nP(X=k)k2−2μ2+μ2=∑k=0nCnkpk(1−p)n−kk2−μ2=np∑k=1nCn−1k−1pk−1(1−p)(n−1)−(k−1)k−μ2=np∑k=1nCn−1k−1pk−1(1−p)(n−1)−(k−1)[(k−1)+1]−μ2=np∑k=2nCn−1k−1pk−1(1−p)(n−1)−(k−1)(k−1)+∑k=1nCn−1k−1pk−1(1−p)(n−1)−(k−1)−μ2=n(n−1)p2∑k=2nCn−2k−2pk−2(1−p)(n−2)−(k−2)+∑k=1nCn−1k−1pk−1(1−p)(n−1)−(k−1)−μ2=n(n−1)p2[p+(1−p)]n−2+[p+(1−p)]n−1−μ2=n(n−1)p2+1−n2p2=np(1−p)\begin{aligned} \sigma^2&=\sum_{k=0}^{n}{\mathrm{P}(X=k)(k-\mu)^2}\\ &=\sum_{k=0}^{n}{\mathrm{P}(X=k)k^2} - 2\mu\sum_{k=0}^{n}{\mathrm{P}(X=k)k} + \mu^2\\ &=\sum_{k=0}^{n}{\mathrm{P}(X=k)k^2} - 2\mu^2 + \mu^2\\ &=\sum_{k=0}^{n}{\mathrm{C}_n^k} p^k (1-p)^{n-k} k^2 - \mu^2\\ &=np\sum_{k=1}^{n}{\mathrm{C}_{n-1}^{k-1} p^{k-1} (1-p)^{(n-1)-(k-1)}k} - \mu^2\\ &=np\sum_{k=1}^{n}{\mathrm{C}_{n-1}^{k-1} p^{k-1} (1-p)^{(n-1)-(k-1)}[(k-1)+1]} - \mu^2\\ &=np\sum_{k=2}^{n}{\mathrm{C}_{n-1}^{k-1} p^{k-1} (1-p)^{(n-1)-(k-1)}(k-1)} + \sum_{k=1}^{n}{\mathrm{C}_{n-1}^{k-1}} p^{k-1} (1-p)^{(n-1)-(k-1)} - \mu^2\\ &=n(n-1)p^2\sum_{k=2}^{n}{\mathrm{C}_{n-2}^{k-2} p^{k-2} (1-p)^{(n-2)-(k-2)}} + \sum_{k=1}^{n}{\mathrm{C}_{n-1}^{k-1} p^{k-1} (1-p)^{(n-1)-(k-1)}} - \mu^2\\ &=n(n-1)p^2 [p+(1-p)]^{n-2} + [p+(1-p)]^{n-1} - \mu^2\\ &=n(n-1)p^2 + 1 - n^2 p^2\\ &=np(1-p) \end{aligned}σ2=k=0∑nP(X=k)(k−μ)2=k=0∑nP(X=k)k2−2μk=0∑nP(X=k)k+μ2=k=0∑nP(X=k)k2−2μ2+μ2=k=0∑nCnkpk(1−p)n−kk2−μ2=npk=1∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)k−μ2=npk=1∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)[(k−1)+1]−μ2=npk=2∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)(k−1)+k=1∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)−μ2=n(n−1)p2k=2∑nCn−2k−2pk−2(1−p)(n−2)−(k−2)+k=1∑nCn−1k−1pk−1(1−p)(n−1)−(k−1)−μ2=n(n−1)p2[p+(1−p)]n−2+[p+(1−p)]n−1−μ2=n(n−1)p2+1−n2p2=np(1−p)

分层抽样#

样本数量 nnn，均值 μ\muμ，方差 σ2\sigma^2σ2
共 kkk 层，第 iii 层样本数量为 nin_ini，均值为 μi\mu_iμi，方差为 σi2\sigma_i^2σi2
第 iii 层第 jjj 个样本为 xijx_{ij}xij
则有方差

σ2=1n∑i=1k∑j=1ni(xij−μ)2=1n∑i=1k∑j=1ni[(xij−μi)+(μi−μ)]2=1n∑i=1k[∑j=1ni(xij−μi)2+2(μi−μ)∑j=1ni(xij−μi)+∑j=1ni(μi−μ)2]=1n∑i=1k[niσi2+2(μi−μ)(∑j=1nixij−niμi)+ni(μi−μ)2]=1n∑i=1k[niσi2+ni(μi−μ)2]=1n∑i=1kni[σi2+(μi−μ)2]\begin{aligned} \sigma^2&=\frac{1}{n}\sum_{i=1}^{k}{\sum_{j=1}^{n_i}{(x_{ij}-\mu)^2}}\\ &=\frac{1}{n}\sum_{i=1}^{k}{\sum_{j=1}^{n_i}{[(x_{ij}-\mu_i)+(\mu_i-\mu)]^2}}\\ &=\frac{1}{n}\sum_{i=1}^{k}{\left[\sum_{j=1}^{n_i}{(x_{ij}-\mu_i)^2} + 2(\mu_i-\mu)\sum_{j=1}^{n_i}{(x_{ij}-\mu_i)} + \sum_{j=1}^{n_i}{(\mu_i-\mu)^2}\right]}\\ &=\frac{1}{n}\sum_{i=1}^{k}{\left[n_i\sigma_i^2 + 2(\mu_i-\mu)\left(\sum_{j=1}^{n_i}{x_{ij}-n_i\mu_i}\right) + n_i(\mu_i-\mu)^2\right]}\\ &=\frac{1}{n}\sum_{i=1}^{k}{\left[n_i\sigma_i^2 + n_i(\mu_i-\mu)^2\right]}\\ &=\frac{1}{n}\sum_{i=1}^{k}{n_i\left[\sigma_i^2 + (\mu_i-\mu)^2\right]} \end{aligned}σ2=n1i=1∑kj=1∑ni(xij−μ)2=n1i=1∑kj=1∑ni[(xij−μi)+(μi−μ)]2=n1i=1∑k[j=1∑ni(xij−μi)2+2(μi−μ)j=1∑ni(xij−μi)+j=1∑ni(μi−μ)2]=n1i=1∑k[niσi2+2(μi−μ)(j=1∑nixij−niμi)+ni(μi−μ)2]=n1i=1∑k[niσi2+ni(μi−μ)2]=n1i=1∑kni[σi2+(μi−μ)2]

【解决方案】FRP代理HTTPS时无法获取IP地址

Mon, 21 Jul 2025 00:00:00 GMT

背景#

通过FRP内网穿透本地的SpeedTest-X服务 HTTP访问时能获取正确的IP 但HTTPS访问时IP为127.0.0.1

解决方案#

使用Proxy Protocal

frpc.toml

1
[[proxies]]
2
name = "web-https"
3
type = "https"
4
localIP = "127.0.0.1"
5
localPort = 443
6
customDomains = ...
7
transport.proxyProtocolVersion = "v2" # 增加

web.conf

1
server
2
{
3
    listen 443 ssl proxy_protocol;
4
    listen [::]:443 ssl proxy_protocol;
5

6
    set_real_ip_from 127.0.0.1/32; # 此处根据实际情况填写错误的IP段
7
    real_ip_header proxy_protocol;
8
}

一些记录

Fri, 18 Jul 2025 00:00:00 GMT

上次写东西还是在上次这学期初不知道是学业压力还是周末摆烂导致一直没写东西终于熬到暑假有时间写点了
之前也有些技术话题想写的但是已经忘了（写点大杂烩记录吧也算是弥补了年度总结了（
这学期的根据相册回忆来写

二月#

合格考查成绩包过的（这过不了也是神人了不过就寄了
200块买了个便携屏 2K的LCD屏幕有点瑕疵但不影响在咸鱼一个个人商家买的其实跟淘宝直接买那种组装出货的应该是一个货源三手货了属于是（
可以TypeC一线通然后发现电脑外接显示器是直连独显的但是内置不行

三月#

和好基友去鸡鸣寺
城北万象汇两栋楼中间有个很长的空中走廊
换了耳机效果就那样毕竟便宜但是续航比原来那个水月雨的好多了
搞研究性学习项目在树莓派上跑通下位机程序跟同学调试跟踪效果
给D90换了18-140的镜头史诗级加强（原来是18-55的

四月#

搞研究性学习项目熬大夜终于炼成了识别气球的YOLO模型炮塔控制电路搭好了（后来发现用不了树莓派拉不动那个继电器）但是结题和期中考重叠导致好急
从中山码头坐轮渡到江北玩顺便去绣球公园
到江心洲玩
换了新键盘原来那个鼠标有点问题而且手感不太好
学校合唱节用D90爽拍

五月#

跟同学到水游城看孤独摇滚总集篇
看到新建的金陵中环大啊很大啊
去南京博物馆好像跟以前也没什么区别
玩新GTA5 但是存档没了啊啊啊
买了个移速的TF卡 128G只要30多块很便宜啊速度这块能读写就行（
坐缆车上紫金山用D90爽拍可惜能见度一般
鸽屋
骑车去燕子矶公园
骑车去江心洲
换新相机 A7M4+24-105F4 （虽然才给D90换过镜头直接鸟枪换炮了主要是准备暑假旅游的时候拍

六月#

学农纯当尼哥去了还有高考倒计时一年
去某个公园玩
鸽屋
坐缆车上紫金山用A7M4爽拍
研究性学习答辩也算是告一段落了还有个梦想基金的答辩不知道要拖到啥时候发现学校机房换了新电脑 i5-14500 16G DDR5 512G SN5000S 也是富了可惜我们用不到了
四校联考
学校科技文化节把两个相机装一个包里承重王（
自从被班主任ban了一周晚自习之后就一直在翘晚自习上不了一点（）感觉上学也上不了一点有点烦躁
之前搞的华为的服务器寄了一直重启导致QQ机器人的数据和之前搭的一堆服务都用不了了赶紧把QQ机器人迁移到NUC上但是原来的消息数据都在服务器上不知道怎么办了

七月#

开始补课强制晚自习更是上不了一点上五休一这一块 80分钟大课这一块
休息日忙里偷闲去石臼湖天空之境豪地方 12km的桥也是神奇下次来坐地铁
尝试申Github Education 失败
放假

一道小题

Sat, 08 Mar 2025 00:00:00 GMT

本来是想用markdown写了再复制到PPT里的但是这byd PowerPoint不支持也不能白写就放着吧

题目#

f(x)=a(x−1)−ln⁡x+1f(x)=a(x-1)-\ln x+1f(x)=a(x−1)−lnx+1，a≤2a\le 2a≤2 且 x>1x>1x>1，求证 f(x)<ex−1f(x)<e^{x-1}f(x)<ex−1 恒成立
即证 g(x)=ex−1−a(x−1)+ln⁡x−1>0g(x)=e^{x-1}-a(x-1)+\ln x-1>0g(x)=ex−1−a(x−1)+lnx−1>0 恒成立
将 g(x)g(x)g(x) 看作 G(a)=(1−x)a+(ex−1+ln⁡x−1)G(a)=(1-x)a+(e^{x-1}+\ln x-1)G(a)=(1−x)a+(ex−1+lnx−1)
∵1−x<0\because 1-x<0∵1−x<0
∴G(a)\therefore G(a)∴G(a) 单调递减，g(x)≥G(2)=ex−1−2x+ln⁡x+1g(x)\ge G(2)=e^{x-1}-2x+\ln x+1g(x)≥G(2)=ex−1−2x+lnx+1
令 h(x)=ex−1−2x+ln⁡x+1h(x)=e^{x-1}-2x+\ln x+1h(x)=ex−1−2x+lnx+1
即证 h(x)>0h(x)>0h(x)>0 恒成立

方法一：直接求导#

h′(x)=ex−1−2+1xh'(x)=e^{x-1}-2+\frac{1}{x}h′(x)=ex−1−2+x1
h′′(x)=ex−1−1x2h''(x)=e^{x-1}-\frac{1}{x^2}h′′(x)=ex−1−x21 单调递增
∴h′′(x)>h′′(1)=0\therefore h''(x)>h''(1)=0∴h′′(x)>h′′(1)=0
∴h′(x)\therefore h'(x)∴h′(x) 单调递增
∴h′(x)>h′(1)=0\therefore h'(x)>h'(1)=0∴h′(x)>h′(1)=0
∴h(x)\therefore h(x)∴h(x) 单调递增
∴h(x)>h(1)=0\therefore h(x)>h(1)=0∴h(x)>h(1)=0 得证

方法二：同构#

即证 ex−1−(x−1)+ln⁡x−x>0e^{x-1}-(x-1)+\ln x-x>0ex−1−(x−1)+lnx−x>0
即证 ex−1−(x−1)>x−ln⁡xe^{x-1}-(x-1)>x-\ln xex−1−(x−1)>x−lnx
即证 ex−1−(x−1)>eln⁡x−ln⁡xe^{x-1}-(x-1)>e^{\ln x}-\ln xex−1−(x−1)>elnx−lnx
令 p(x)=ex−xp(x)=e^x-xp(x)=ex−x
即证 p(x−1)>p(ln⁡x)p(x-1)>p(\ln x)p(x−1)>p(lnx)
又∵p′(x)=ex−1>0\because p'(x)=e^x-1>0∵p′(x)=ex−1>0，p(x)p(x)p(x) 单调递增
即证 x−1>ln⁡xx-1>\ln xx−1>lnx
q(x)=x−ln⁡x−1q(x)=x-\ln x-1q(x)=x−lnx−1，q′(x)=1−1x>0q'(x)=1-\frac{1}{x}>0q′(x)=1−x1>0，q(x)>q(1)=0q(x)>q(1)=0q(x)>q(1)=0，x−1>ln⁡xx-1>\ln xx−1>lnx
上式显然成立

一些简谐运动的运动学方程推导

Sat, 22 Feb 2025 00:00:00 GMT

从能量角度出发#

理想情况下无能量损失得到方程

12mv2+12kx2=E0\frac{1}{2}mv^2+\frac{1}{2}kx^2=E_021mv2+21kx2=E0

微分形式

m(dxdt)2+kx2=2E0m\left(\frac{\mathrm dx}{\mathrm dt}\right)^2+kx^2=2E_0m(dtdx)2+kx2=2E0

分离变量

m2E0−kx2dx=dt\sqrt{\frac{m}{2E_0-kx^2}}\mathrm dx=\mathrm dt2E0−kx2mdx=dt

两边积分

m2E0∫11−k2E0x2dx=∫dt\sqrt{\frac{m}{2E_0}}\int{\frac{1}{\sqrt{1-\frac{k}{2E_0}x^2}}\mathrm dx}=\int{\mathrm dt}2E0m∫1−2E0kx21dx=∫dt

换元令

u=k2E0xu=\sqrt{\frac{k}{2E_0}}xu=2E0kx

则

mk∫11−u2du=∫dt\sqrt{\frac{m}{k}}\int{\frac{1}{\sqrt{1-u^2}}\mathrm du}=\int{\mathrm dt}km∫1−u21du=∫dt

即

mk(arcsin⁡u+C1)=t+C2\sqrt{\frac{m}{k}}(\arcsin{u}+C_1)=t+C_2km(arcsinu+C1)=t+C2

回代得

mk(arcsin⁡k2E0x+C1)=t+C2\sqrt{\frac{m}{k}}\left(\arcsin{\sqrt{\frac{k}{2E_0}}x}+C_1\right)=t+C_2km(arcsin2E0kx+C1)=t+C2

注意到 mk\sqrt{\frac{m}{k}}km 为常数，故可合并常数

mk(arcsin⁡k2E0x+φ)=t\sqrt{\frac{m}{k}}\left(\arcsin{\sqrt{\frac{k}{2E_0}}x}+\varphi\right)=tkm(arcsin2E0kx+φ)=t

整理得

x=2E0ksin⁡(kmt+φ)x=\sqrt{\frac{2E_0}{k}}\sin{\left(\sqrt{\frac{k}{m}}t+\varphi\right)}x=k2E0sin(mkt+φ)

由此可得简谐运动最大振幅 A=2E0kA=\sqrt{\frac{2E_0}{k}}A=k2E0 ，周期 T=2πmkT=2\pi\sqrt{\frac{m}{k}}T=2πkm ，初相位 φ\varphiφ

从受力角度出发#

根据简谐运动回复力定义得到方程

−kx=ma-kx=ma−kx=ma

即

kx+mx′′=0kx+mx''=0kx+mx′′=0

特征方程

k+mλ2=0k+m\lambda^2=0k+mλ2=0

得到

λ=±kmi\lambda=\pm\sqrt{\frac{k}{m}}iλ=±mki

于是有

x=C1eλ1t+C2eλ2t% \begin{align*} x=C_1 e^{\lambda_1 t}+C_2 e^{\lambda_2 t}\\ % &=C_1\left(\cos\sqrt{\frac{k}{m}}t+i\sin\sqrt{\frac{k}{m}}t\right)+C_2\left(\cos{-\sqrt{\frac{k}{m}}}t+i\sin{-\sqrt{\frac{k}{m}}}t\right)\\ % &=(C_1+C_2)\cos\sqrt{\frac{k}{m}}t+(C_1-C_2)i\sin\sqrt{\frac{k}{m}}t % \end{align*}x=C1eλ1t+C2eλ2t

由于

x∈Rx\in\Rx∈R

所以

x=x‾x=\overline{x}x=x

即

C1eλ1t+C2eλ2t=C1‾e−λ1t+C2‾e−λ2tC_1 e^{\lambda_1 t}+C_2 e^{\lambda_2 t}=\overline{C_1}e^{-\lambda_1 t}+\overline{C_2}e^{-\lambda_2 t}C1eλ1t+C2eλ2t=C1e−λ1t+C2e−λ2t

又因为

λ1+λ2=0\lambda_1+\lambda_2=0λ1+λ2=0

故

C1=C2‾C_1=\overline{C_2}C1=C2

不妨设

C1=reiφ, C2=re−iφC_1=re^{i\varphi},\space C_2=re^{-i\varphi}C1=reiφ, C2=re−iφ

所以

x=reλ1t+φ+reλ2t−φ=reλ1t+φ+re−(λ1t+φ)=2rcos⁡(λ1t+φ)\begin{aligned} x&=re^{\lambda_1 t+\varphi}+re^{\lambda_2 t-\varphi}\\ &=re^{\lambda_1 t+\varphi}+re^{-(\lambda_1 t+\varphi)}\\ &=2r\cos{(\lambda_1 t+\varphi)} \end{aligned}x=reλ1t+φ+reλ2t−φ=reλ1t+φ+re−(λ1t+φ)=2rcos(λ1t+φ)

即可得

x=x0cos⁡(kmt+φ)x=x_0\cos{\left(\sqrt{\frac{k}{m}}t+\varphi\right)}x=x0cos(mkt+φ)

显然和上一个方法的结果是自洽的

CentOS 7 非LVM分区扩容

Sun, 02 Feb 2025 00:00:00 GMT

起因是跑在服务器上的CentOS的硬盘爆了在ESXi中扩容后没有反应需要到系统中进行设置
安装系统时图方便没有用LVM 顺便一提现在网上搜索CentOS 分区扩容全是基于LVM的并且文章也是互相Copy😡😡😡
其实非LVM的扩容反而更简单

步骤#

查看现有分区类型及大小

Terminal window

1
df -lh

进入分区编辑（以sda为例）

Terminal window

1
fdisk /dev/sda

根据操作提示删除最后一个分区并在原地（一般只需使用默认起始位置若自行更改过则记录原分区起始位置并填入）新建一个分区保存并退出

刷新分区信息

Terminal window

1
partprobe /dev/sda

刷新分区：（填入之前创建的分区号此处位sda3）

若为ext2/ext3/ext4文件系统则使用resize2fs /dev/sda3
若为xfs文件系统则使用xfs_growfs /dev/sda3

大功告成可以使用df -lh或lsblk查看现在的分区信息

一些导体棒切割磁感线的运动学方程

Sun, 13 Oct 2024 00:00:00 GMT

最近学到受某题启发来推导一下

初速度单导体棒切割磁感线运动学方程推导#

受力分析得原始方程

B2L2vR=−ma\frac{B^2 L^2 v}{R}=-maRB2L2v=−ma

微分形式

B2L2vR=−mdvdt\frac{B^2 L^2 v}{R}=-m\frac{\mathrm{d}v}{\mathrm{d}t}RB2L2v=−mdtdv

分离变量

−dt=mRdvB2L2v-\mathrm dt = \frac{mR\mathrm dv}{B^2 L^2 v}−dt=B2L2vmRdv

两边积分

−t+C=mRB2L2ln⁡v-t+C=\frac{mR}{B^2L^2}\ln v−t+C=B2L2mRlnv

代入初始条件

{t=0v=v0\begin{cases} t=0\\ v=v_0 \end{cases}{t=0v=v0

得

C=mRB2L2ln⁡v0C=\frac{mR}{B^2 L^2}\ln v_0C=B2L2mRlnv0

整理得

v=v0e−B2L2mRtv=v_0 e^{-\frac{B^2 L^2}{mR}t}v=v0e−mRB2L2t

恒定外力单导体棒切割磁感线运动学方程推导#

受力分析得原始方程

F−B2L2vR=maF-\frac{B^2 L^2 v}{R}=maF−RB2L2v=ma

微分形式

F−B2L2vR=mdvdtF-\frac{B^2 L^2 v}{R}=m\frac{\mathrm{d}v}{\mathrm{d}t}F−RB2L2v=mdtdv

分离变量

dt=mRdvFR−B2L2v\mathrm dt = \frac{mR\mathrm dv}{FR-B^2 L^2 v}dt=FR−B2L2vmRdv

两边积分

t+C=−mRB2L2ln⁡(Fm−B2L2mRv)t+C=-\frac{mR}{B^2L^2}\ln\left(\frac{F}{m}-\frac{B^2 L^2}{mR}v\right)t+C=−B2L2mRln(mF−mRB2L2v)

代入初始条件

{t=0v=v0\begin{cases} t=0\\ v=v_0 \end{cases}{t=0v=v0

得

C=−mRB2L2ln⁡(Fm−B2L2mRv0)C=-\frac{mR}{B^2L^2}\ln\left(\frac{F}{m}-\frac{B^2 L^2}{mR}v_0\right)C=−B2L2mRln(mF−mRB2L2v0)

整理得

v=(v0−FRB2L2)e−B2L2mRt+FRB2L2v=\left(v_0-\frac{FR}{B^2 L^2}\right)e^{-\frac{B^2 L^2}{mR}t}+\frac{FR}{B^2 L^2}v=(v0−B2L2FR)e−mRB2L2t+B2L2FR

特别地，v0=0v_0=0v0=0 时有

v=FRB2L2(1−e−B2L2mRt)v=\frac{FR}{B^2 L^2}\left(1-e^{-\frac{B^2 L^2}{mR}t}\right)v=B2L2FR(1−e−mRB2L2t)

公式解法（公式做题就是快）#

2025.2.22更新
之前学艺不精还不知道线性微分方程的一般解法突然发现这两个正好是一个齐次一个非齐次非常典型了

初速度#

受力分析得原始方程

B2L2vR=−ma\frac{B^2 L^2 v}{R}=-maRB2L2v=−ma

即

B2L2Rv+mv′=0\frac{B^2 L^2}{R}v+mv'=0RB2L2v+mv′=0

特征方程

B2L2R+mλ=0\frac{B^2 L^2}{R}+m\lambda=0RB2L2+mλ=0

得到

λ=−B2L2mR\lambda=-\frac{B^2 L^2}{mR}λ=−mRB2L2

于是有

v=Ceλt=Ce−B2L2mRtv=Ce^{\lambda t}=Ce^{-\frac{B^2 L^2}{mR}t}v=Ceλt=Ce−mRB2L2t

代入初始条件

{t=0v=v0\begin{cases} t=0\\ v=v_0 \end{cases}{t=0v=v0

得

C=v0C=v_0C=v0

整理得

v=v0e−B2L2mRtv=v_0 e^{-\frac{B^2 L^2}{mR}t}v=v0e−mRB2L2t

恒定外力#

受力分析得原始方程

B2L2vR+ma=F\frac{B^2 L^2 v}{R}+ma=FRB2L2v+ma=F

即

B2L2vR+mv′=F\frac{B^2 L^2 v}{R}+mv'=FRB2L2v+mv′=F

由初始条件

{t=0v=v0\begin{cases} t=0\\ v=v_0 \end{cases}{t=0v=v0

得特解

v∗=FRB2L2v^*=\frac{FR}{B^2 L^2}v∗=B2L2FR

特征方程

B2L2R+mλ=0\frac{B^2 L^2}{R}+m\lambda=0RB2L2+mλ=0

得到

λ=−B2L2mR\lambda=-\frac{B^2 L^2}{mR}λ=−mRB2L2

于是有

v=Ceλt+v∗=Ce−B2L2mRt+FRB2L2v=Ce^{\lambda t}+v^*=Ce^{-\frac{B^2 L^2}{mR}t}+\frac{FR}{B^2 L^2}v=Ceλt+v∗=Ce−mRB2L2t+B2L2FR

代入初始条件得

C=v0−FRB2L2C=v_0-\frac{FR}{B^2 L^2}C=v0−B2L2FR

整理得

v=(v0−FRB2L2)e−B2L2mRt+FRB2L2v=\left(v_0-\frac{FR}{B^2 L^2}\right)e^{-\frac{B^2 L^2}{mR}t}+\frac{FR}{B^2 L^2}v=(v0−B2L2FR)e−mRB2L2t+B2L2FR

二阶方阵求逆公式

Sun, 08 Sep 2024 00:00:00 GMT

今天在某教材上看到一个二阶方阵的求逆公式想推导一下
（包不规范的练练LaTeX\LaTeXLATEX

If M=[abcd], then M−1=1det⁡M[d−b−ca]\text{If}\space \mathbf{M}= \begin{bmatrix} a & b\\ c & d \end{bmatrix} \text{, then}\space \mathbf{M}^{-1}=\frac{1}{\det \mathbf{M}} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix}If M=[acbd], then M−1=detM1[d−c−ba]

Proof 1.14.514\bold{Proof}\space\bold{1.14.514}Proof 1.14.514
Let\text{Let}Let

M=[abcd]\mathbf{M}= \begin{bmatrix} a & b\\ c & d \end{bmatrix}M=[acbd]

we want to find M−1 so that\text{we want to find}\space\mathbf{M}^{-1}\space\text{so that}we want to find M−1 so that

MM−1=I\mathbf{M}\mathbf{M}^{-1}=\mathbf{I}MM−1=I

Let\text{Let}Let

M[xy]=[x0y0](*)\mathbf{M} \begin{bmatrix} x\\ y \end{bmatrix} = \begin{bmatrix} x_0\\ y_0 \end{bmatrix} \tag{*}M[xy]=[x0y0](*)

which is equivalent as\text{which is equivalent as}which is equivalent as

{ax+by=x0cx+dy=y0\begin{cases} ax+by=x_0\\ cx+dy=y_0 \end{cases}{ax+by=x0cx+dy=y0

solved as\text{solved as}solved as

{x=dad−bcx0+−bad−bcy0y=−cad−bcx0+aad−bcy0\begin{cases} x=\frac{d}{ad-bc}x_0+\frac{-b}{ad-bc}y_0\\ y=\frac{-c}{ad-bc}x_0+\frac{a}{ad-bc}y_0 \end{cases}{x=ad−bcdx0+ad−bc−by0y=ad−bc−cx0+ad−bcay0

so we have\text{so we have}so we have

[xy]=[dad−bc−bad−bc−cad−bcaad−bc][x0y0]=1ad−bc[d−b−ca][x0y0]=1det⁡M[d−b−ca][x0y0]\begin{aligned} \begin{bmatrix} x\\ y \end{bmatrix} &= \begin{bmatrix} \frac{d}{ad-bc} & \frac{-b}{ad-bc}\\ \frac{-c}{ad-bc} & \frac{a}{ad-bc} \end{bmatrix} \begin{bmatrix} x_0\\ y_0 \end{bmatrix}\\ &= \frac{1}{ad-bc} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix} \begin{bmatrix} x_0\\ y_0 \end{bmatrix}\\ &= \frac{1}{\det\mathbf{M}} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix} \begin{bmatrix} x_0\\ y_0 \end{bmatrix} \end{aligned}[xy]=[ad−bcdad−bc−cad−bc−bad−bca][x0y0]=ad−bc1[d−c−ba][x0y0]=detM1[d−c−ba][x0y0]

back to (∗), we have\text{back to}\space(*)\text{, we have}back to (∗), we have

M1det⁡M[d−b−ca][x0y0]=[x0y0]\mathbf{M} \frac{1}{\det\mathbf{M}} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix} \begin{bmatrix} x_0\\ y_0 \end{bmatrix} = \begin{bmatrix} x_0\\ y_0 \end{bmatrix}MdetM1[d−c−ba][x0y0]=[x0y0]

so\text{so}so

M1det⁡M[d−b−ca]=I\mathbf{M} \frac{1}{\det\mathbf{M}} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix} = \mathbf{I}MdetM1[d−c−ba]=I

here comes\text{here comes}here comes

M−1=1det⁡M[d−b−ca]\mathbf{M}^{-1}= \frac{1}{\det\mathbf{M}} \begin{bmatrix} d & -b\\ -c & a \end{bmatrix}M−1=detM1[d−c−ba]

Q.E.D.\text{Q.E.D.}Q.E.D.

正弦式交变电流的等效电流

Fri, 19 Jul 2024 00:00:00 GMT

最近了解到交流电有效值（等效电流）的概念尝试推导一下发现这是个二倍角公式的应用（记录一下

根据定义，交变电流与其等效电流在相同时间内通过相同电阻产生的热量相等
于是有
∫0Ti2Rdt=I2RT\int^T_0{i^2R\mathrm{d}t}=I^2RT∫0Ti2Rdt=I2RT
I=1T∫0Ti2dtI=\sqrt{\frac{1}{T}\int^T_0{i^2\mathrm{d}t}}I=T1∫0Ti2dt
代入正弦交变电流表达式

{i=Imsin⁡ωtω=2πT\begin{cases} i=I_m\sin{\omega t}\\ \omega=\frac{2\pi}{T} \end{cases}{i=Imsinωtω=T2π

得

I=1T∫0TIm2sin⁡2ωtdt=Im1T∫0T1−cos⁡2ωt2dt=Im1T(T2−12∫0Tcos⁡2ωtdt)=Im1T(T2−12sin⁡2ωt∣0T)=22Im≈0.707Im\begin{aligned} I&=\sqrt{\frac{1}{T}\int^T_0{I_m^2}\sin^2{\omega t\mathrm{d}t}}\\ &=I_m\sqrt{\frac{1}{T}\int^T_0{\frac{1-\cos{2\omega t}}{2}\mathrm{d}t}}\\ &=I_m\sqrt{\frac{1}{T}(\frac{T}{2}-\frac{1}{2}\int^T_0{\cos{2\omega t}\mathrm{d}t})}\\ &=I_m\sqrt{\frac{1}{T}(\frac{T}{2}-\frac{1}{2}\left.\sin{2\omega t}\right|^T_0)}\\ &=\frac{\sqrt{2}}{2}I_m\\ &\approx 0.707I_m \end{aligned}I=T1∫0TIm2sin2ωtdt=ImT1∫0T21−cos2ωtdt=ImT1(2T−21∫0Tcos2ωtdt)=ImT1(2T−21sin2ωt∣0T)=22Im≈0.707Im

CentOS 7 配网记录

Thu, 11 Jul 2024 00:00:00 GMT

最近给家里吃灰的NUC5装了CentOS7（之前重装Windows给我玩坏了而且配置实在不太跑得动）记录一下配网的常用操作

步骤#

找到网卡名称

Terminal window

1
ip address # 可简写为ip a

临时联网

Terminal window

1
wpa_supplicant -B -i <网卡名称> -c <(wpa_passphrase <WiFi名称> <WiFi密码>)
2
dhclient <网卡名称>

使用NetworkManager接管网络配置

Terminal window展开收起

1
yum -y install NetworkManager-wifi
2

3
systemctl start NetworkManager.service
4
systemctl enable NetworkManager.service
5
# 以上两行或chkconfig NetworkManager on
6

7
nmcli device set <网卡名称> managed yes
8

9
nmcli connection delete <WiFi名称>
10

11
nmcli device wifi connect <WiFi名称> password <WiFi密码>
12

13
nmcli connection modify <WiFi名称> ipv4.addresses 192.168.1.114/24
14
nmcli connection modify <WiFi名称> ipv4.gateway 192.168.1.1
15
nmcli connection modify <WiFi名称> ipv4.method manual
16
nmcli connection modify <WiFi名称> ipv4.dns "8.8.8.8"
17

18
nmcli connection up <WiFi名称>
19

20
cat /etc/sysconfig/network-scripts/ifcfg-<WiFi名称>
21
ip addr show <网卡名称>
22

23
systemctl restart NetworkManager

展开收起

C++函数模板偏特化问题较为美观的一种解决方案

Sun, 07 Jul 2024 00:00:00 GMT

C++函数模板偏特化问题较为美观的一种解决方案
使std::enable_if_t作为int并带上默认值

1
template <typename T, typename std::enable_if_t<std::is_integral_v<T>, int> = 0>
2
void foo(T x) {
3
    std::cout << "is integral\n";
4
}
5

6
template <typename T, typename std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
7
void foo(T x) {
8
    std::cout << "is floating point\n";
9
}

南师附中开发者社2023级社团教材

Fri, 28 Jun 2024 00:00:00 GMT

目录#

目录
0. 序言
1. 编程导论
2. 常识
- 2.1. 计算机基础
- 2.2 编程语言基础
  - 2.2.1 编译型语言和解释型语言
  - 2.2.2 编程语言的实现
3. 从C++开始
-1. 结语
- -1.1 编者的话

0. 序言#

本书为NSFZ2023级开发者社教材，旨在帮助读者从零开始学习编程。它将从基础语法、数据类型、流程控制、函数、面向对象编程等方面进行讲解，并结合大量的实例，帮助读者快速掌握编程技能，同时对编程的思想逐步建立理解。
（也可以在此处线上阅读）

0.1 条件检查#

您已满中华人民共和国法律规定的10周岁。
您认为您能在韦克斯勒儿童智力量检测四中达到正常水平（约80分）。
您没有令人费解的语言逻辑缺陷。
您拥有一台尚可正常开机的，外设齐全的个人电脑。
上述电脑工作正常，并搭载主流操作系统，一般是Windows（视窗操作系统）。
您的电脑RAM大小≥4GB。（RAM的概念见#2.1.1章节）

0.2 本书的适用人群#

这本书适用于所有想要学习编程的人（以及真的愿意花钱弄一本这玩意的实体书的人）。无论你是完全没有编程基础的初学者，还是想不太系统地老年复健的满级巨佬，都可以从本书中获益。

0.3 本书的特色#

本书的特色主要体现在以下几个方面：

注重实用性：本书的所有内容都以实用为导向，重点讲解与实际应用相关的知识点。
循序渐进和突然跳级：本书将编程知识分为多个阶段进行讲解，循序渐进，让读者能够轻松掌握，并且穿插跳级内容，使读者时刻认识到学无止境。
巨™多代码量：本书配有大量的代码示例，帮助读者理解和应用编程知识。

0.4 本书的使用方法#

本书可以作为一本自学教程，也可以作为编程课程的辅助教材（最好别）。如果是自学，建议读者按照书中的章节顺序进行学习，并结合书中的代码示例进行练习。如果是使用本书作为编程课程的辅助教材，建议读者在课堂上认真听讲，并结合本书的内容进行巩固。

1. 编程导论#

程序不过是更详细的需求罢了
——沃·兹基·硕德

众所周知，程序是由一条条指令构成的。每一条指令都是电脑的一个基本动作，如“使屏幕上某一个像素点变成某种颜色”，或是“将某个电路接口设置为高/低电平”。人们负责给出这些指令，由计算机按顺序完成这一系列指令，便可以达到理想的效果。然而，这里的指令不免过于基本。这时，人们会将用于实现某种功能的一系列指令捆绑在一起，形成一个较基本指令更为高级、简介、实用的指令，这就是编程中一个重要的思想：抽象。抽象思想使得人们避免一些无意义的重复劳动，但这又引入了一个新的问题：计算机不像人拥有如此先进的思想，它实际上只能完成那些最基本的指令，因此我们需要一个工具，将这些利于人们使用的高级指令翻译回计算机能够完成的底层的基础指令。这个工具就是人们使用的各类语言的编译器、解释器等。

因此，编程本质上就是提出需求的过程，需求的简洁程度与抽象程度呈正相关。同时我们可以给出编程的一般过程，即“人类提出需求->工具将抽象的需求翻译为基础指令->计算机执行这些基础指令”。

需要指出的是，本章中使用了大量不准确的说法，目的是便于理解其中的思想，当读者阅读完第二章后，可以对本章内容进行规范化的整合。

2. 常识#

在门外和门内之间，有一个小小的门槛
——沃·兹基·硕德

这些内容并不像编程语言的内容等对编程起决定性作用，但它们也是编程中时常会接触到的东西，初学编程的一部分时间总是在了解这些知识上，因此不妨先学习这些内容，再去进行实际编程的学习。

2.1. 计算机基础#

2.1.1 计算机组成#

一般来说，计算机有五大组成部分：

控制器
运算器
存储器
输入设备
输出设备

其中控制器负责控制所有硬件的运行，其他都很好理解，这里不再解释。值得注意的是，存储器分为内部存储和外部存储，后者为常见的硬盘，软盘等，而前者又分为随机存储器（RAM）、只读存储器（ROM）和其他一些存储器。

这里借用维基百科上的一张图片，可以很好的展示这五个部分之间的关系。

前文所说的五大组成部分是逻辑结构，而计算机的实际结构又包含以下几部分：

中央处理单元（CPU）
图形处理单元（GPU）
主板、固件等硬件
键盘、屏幕等输入、输出设备

其中CPU对应逻辑结构中的控制器和运算器，是这两个逻辑结构的实现形式。
CPU有几个重要的性能指标，如主频和位宽。主频是描述CPU执行指令速度的量，它的单位即为频率的单位。位宽是CPU在一条指令中可以处理的二进制数据位数，例如32bit、64bit。
CPU有多种不同的实现形式，也就是架构和指令集。常见的架构有ARM系列、x86系列、MIPS系列和PowerPC系列。ARM架构的优势有价格低、能耗低，因此常用于嵌入式开发和手机等。x86架构的优势有兼容性强、性能高，常用于个人计算机。
关于CPU更详细的介绍可以参考以下文章：
https://zhuanlan.zhihu.com/p/245119254
https://zhuanlan.zhihu.com/p/508557771

我们日常生活中所使用的电脑一般是个人计算机（PC），它是计算机的一个主要的子集。按照层级来梳理，个人计算机的层级从底向上依次是硬件、操作系统、应用程序，其中操作系统和应用程序合称软件。在不引起歧义的情况下，有时软件也可仅指应用程序。主流的操作系统有Windows、Ubuntu、CentOS、Alpine等，它们的设计理念有所不同，但对于计算机的作用是类似的，即与硬件直接交互，为程序提供抽象的较高级的接口。

2.1.2 控制台、终端、Shell等易混淆概念#

这些名词来源于大型机时代的一个个实体的设备，它们可能由不同的专业人员专职负责管理，到了今天，所有这些东西都在一台小巧的电脑里，但是由于惊人的历史遗留性，它们都被保留了下来（尽管是虚拟的），于是造成了如此混乱的体系。总的来说，它们可以分为两层：

控制台、终端、串口终端：属于计算机五大组成部分的输入/输出设备，可以将用户指令（包括键盘事件）输入给操作系统并将操作系统返回的结果输出给用户（显示字符）。电传打字机（tty）是这类设备的具体实例。在现代计算机中，虚拟的终端被称为终端模拟器。特别地，终端模拟器在UNIX/Linux内核的驱动程序模块中为伪终端（pty）。
Shell：属于应用程序，负责解析、处理、运行命令，常见的Bash、Zsh、sh属于此类。

Windows系统中内置的命令提示符（CMD）和PowerShell，是终端和Shell的集合体，因为它们既处理输入/输出事件，也负责执行命令。也可以理解为它们是由终端和Shell两个独立的部分组成的。编者甚至觉得没有必要纠结这些模糊的概念性的东西
一般情况下，编程语言编写的程序使用其输入/输出模块与Shell直接交互。

2.1.3 数据格式和编码#

我们知道，任何数据在计算机中都是以二进制的形式存储的。在操作系统中，数据以文件的形式被组织起来。那么，操作系统或程序是如何将这些文件中的数据（从底层上来说，都是二进制数据）识别为一张图片、一个文档、或是一份代码呢？这就需要数据格式。操作系统依靠文件的一些特殊信息（一般称为元数据）来识别文件的类型。一般有以下几种识别的方式：

扩展名：即文件名最后一个.之后的内容，在Windows系统中，文件的默认打开方式与扩展名绑定。利用文件名识别的特性使得它易于更改，这既是优点也是缺点。由于扩展名没有官方统一的规定，不同类型的文件可能会使用相同的扩展名，从而在Windows系统中默认打开方式无法很好地分辨。
特征签名：即文件头部几个字节的数据，它通常与文件中数据的组织形式强相关。它不易被更改（因为更改后会影响特定程序的读取），所以较扩展名更为可靠。

在很多时候，扩展名和特征签名会同时使用，因为它们被使用的时机和对象不同，存储的位置也不同。

对于一个文本文件，我们有更细致的需求，即将文件中的二进制数据识别为人类可读的，可以显示在屏幕上的字符。这时我们需要建议一个从二进制数据到字符的双向映射，于是就有了字符集。常用的字符集如下：

ASCII（美国信息交换标准代码）：用一个字节表示一个字符，最初其二进制最高位始终是0，即只能表示128中字符，其中包括大小写字母、一些符号和控制字符。
ISO8859-1（Latin1）：用一个字节表示一个字符，是对ASCII的扩展，增加了西欧语言、希腊语、泰语、阿拉伯语、希伯来语的符号。但是，由于出现得较晚，欧元符号没有被收录于其中。
GB2312：1980年中国公布的国家标准，用两个字节表示一个字符，共收录6763个汉字，同时收录了包括拉丁字母、希腊字母、日文平假名及片假名字母、俄语在内的682个字符
GBK：用两个字节表示一个字符，在兼容ASCII和GB2312的情况下可以表示的汉字达到了20902个，还有984个汉语标点符号、部首等，其中还包括繁体字。
GB18030：用四个字节表示一个字符，在兼容以上字符集的情况下新增了大量字符，最新的GB18030-2022标准中收录的汉字达到了87887个，甚至包含了少数民族汉字。
Unicode（万国码）：用四个字节表示一个字符，由美国加州的Unicode组织提出。Unicode的出现标志着字符集和字符编码的彻底分离，前文的几个既是字符集也是字符编码，而Unicode仅仅是字符集，其常用的字符编码有UTF-8、UTF-16等。

由于Unicode的独特设计，使得它可以包含世界上所有字符。借用CSDN上的一张图片总结：

关于这些字符集的具体编码方式可以参考这篇文章 https://blog.csdn.net/wn084/article/details/80363792

2.1.4 计算机程序#

可以直接运行在操作系统中的程序，即本机程序，一般是一个二进制文件，其内容包括实际指令、预定义数据等。大多数还包含导入表，如果程序中调用了操作系统中或是其他程序中的代码，那么需要导入表来标示代码的位置。
还有一类文件和本机程序的表现类似，例如在Windows系统下，如果安装了Python环境，那么可以直接双击一个.py文件来运行它，就像本机程序一样。但实际上这类文件并不是一个真正的程序，而是与它的运行环境绑定后得以实现的功能，即让另一个本机程序来解释这个文件的内容。其原理与直接打开一个.docx文档相同。

2.2 编程语言基础#

2.2.1 编译型语言和解释型语言#

上一节末尾，我们提到了本机程序和另一种类似本机程序的文件（姑且叫做非本机程序），由此可以引出编程语言的两大阵营：编译型语言和解释型语言。编译型语言的最终产物是一个本机程序，解释型语言的最终产物是一个非本机程序。之所以叫做解释型语言，就是因为在编写完成后，需要另一个本机程序来解释它运行。将编译型语言的代码翻译为本机程序的一个特殊的本机程序，是编译器工具链（编译器及其周边组件，如链接器，稍后会详细介绍）。解释解释型语言的代码运行的本机程序，是解释器。编译器和解释器其实都是第一章中所说的那个将高级指令翻译回基础指令的工具。

常见的编译型语言有C、C++、Rust等，常见的解释型语言有Python、JavaScript等。虚拟机语言如C#/.NET、Java/JVM，介于编译型和解释型语言之间，它们的分类仍是个有争议的话题，但多数人将其归为解释型语言。由此可见，编译型语言和解释型语言的分类并不是完全清晰的。
关于虚拟机语言的扩展内容可以参考这篇文章 https://www.iteye.com/blog/rednaxelafx-492667

不难发现，编译型语言更加本质化，所以我们先介绍它。将编译型语言的代码翻译为本机程序是一个复杂的操作，以C++语言为例，它的编译过程如下：

预处理（Preprocess）：预处理器会对源代码进行操作，包括展开一些简写的代码，引入其他文件等。
编译（Compilation）：编译器将预处理后的源代码文件转换为目标代码，通常是汇编语言代码。编译器会进行语法检查，如果程序有语法错误，那么会报出错误（Error）和警告（Warning）.
汇编（Assemble）：汇编过程将汇编代码转换成机器码，产生的文件叫做目标文件，是二进制格式。汇编过程需要为每一个源文件产生一个目标文件。
链接（Link）：链接器将目标文件组织起来，生成可执行文件。链接器会解析目标文件中的符号，将符号引用与符号定义关联起来，生成可执行文件.

解释型语言的运行过程是一个“模拟”的过程，即在运行时，解释器实时地根据代码执行相应的指令。可以这么理解：解释器作为一个本机程序，其中包含了解释型语言所有可能的代码所对应的的基本指令，运行代码时，解释器就根据代码找到对应的基本指令来执行。

2.2.2 编程语言的实现#

由于编程语言通常只是一个标准，一套规范，它的具体实现依靠不同的编译器或解释器。对于编译型语言来说，不同编译器的差异无非在于其实现编程语言标准之外的扩展内容。如果一份编译型语言的代码完全符合语言标准，那么它理应可以被任何符合规范的编译器编译。解释型语言的不同解释器差异很大，本质上是因为运行的过程就是解释的过程，即解释器和代码在运行时是绑定且相互依靠的。

以典型解释型语言C++为例，它的编译器工具链有以下几种：

GCC工具链：全称为GNU Compiler Collection，顾名思义，它可以处理C++、Objective-C、Go等语言，它包含预处理器/编译器cc1、汇编程序as、连接器ld（collect2）等工具。它是大多数信息学竞赛的官方编译器工具链，因此广为人知。
Clang/LLVM工具链：分为前端Clang和后端LLVM（这里指狭义LLVM，广义LLVM包含前端、优化器和后端，Clang是LLVM前端的一种），Clang将C++代码解析为统一的中间代码（IR），LLVM优化器负责优化IR，再交由后端生成本机代码。
MSVC工具链：微软出品的工具链，通常用于开发Windows应用，它依靠Windows SDK，如果把MSVC理解为工具的话，那么SDK更偏向于工具所需要的物料。

以典型解释型语言Python为例，它的解释器有以下几种：

CPython：Python官方默认的解释器，由C语言编写，它可以将Python代码编译为中间产物CPython字节码，再解释执行字节码。
PyPy：著名的CPython替代品，由Python语言编写（事实上是RPython，Python语言的子集，去除了动态类型，详见第四章），它使用即时编译技术（JIT），可以在运行时将 Python 代码动态地编译成机器码，从而提供更高的执行速度，但它与许多使用C语言编写的Python拓展库不兼容，并且由于JIT，它的启动速度较慢。
Stackless Python：一种 Python 的变体，它是在CPython的基础上进行扩展和改进的版本，提供了一些额外的特征。
Jython：即Java Python，由Java语言编写。它运行在Java虚拟机（JVM，与下文.NET虚拟机同类，类似于解释器）上，因此提供了与Java的无缝集成。
IronPython：运行在.NET虚拟机上，它可以与.NET平台无缝集成。

3. 从C++开始#

There are only two kinds of languages: the ones people complain about and the ones nobody uses.
——Bjarne Stroustrup

3.1 万物起源「Hello World」#

你说的对，但是「C++」是由Bjarne Strou-strup自主研发的一款全新开放世界冒险游戏。
——Anonymous

众所周知，学一门编程语言很显然要学习它的基础。「Hello World」是其一个非常经典的例子。
考虑以下代码。

1
// helloworld.cpp (A hello world example for dummies)
2

3
#include <iostream>
4

5
int main() {
6
    // print "hello world"
7
    std::cout << "Hello world" << std::endl;
8
    return 0;
9
}

对以上代码稍作修改，可以充分体验到C++的魅力。例如：

1
// helloworld2.cpp (An example use of std::cout)
2

3
#include <iostream>
4

5
int main() {
6
    std::cout << "You're right, " << "\n";
7
    std::cout << "but " << "the C++ programming language"
8
              << "is a new, open-world adventure game "
9
              << "solely developed by Bjarne Strou-strup"
10
              << std::endl;
11
    return 0;
12
}

……也就是本节的引言。

本节会介绍这个最基本的程序中的内容。（类似于第一章编程导论，为了易于理解、快速上手，本节也使用了不规范的说法）

3.1.1 头文件#

C++中有许多内置的头文件，它们包含了C++标准库中的函数、类型等。可以用#include来引入它们。特别地，#include <...>会使得编译器在内部目录查找文件，#include "..."会使得编译器在用户定义的目录下查找文件（一般是源文件同级目录）。下面是部分常用的头文件和它们所包含的内容：

头文件	内容
`<iostream>`	输入/输出流
`<fstream>`	文件流
`<iomanip>`	输入/输出流控制符
`<cstdlib>`	动态内存分配、随机数等常用函数和类
`<cmath>`	数学相关函数和常量

在C++中，以#开头的语句是给编译器看的，也就是说，并不会存在于编译出来的程序中。

3.1.2 主函数#

主函数是C++程序的入口（entry point），即程序从这里开始执行。在标准的C++语言中必须返回int类型。函数的内容用两个花括号括起来。约定俗成的，在没有错误的情况下，程序总应返回整数0（return 0;）。

3.1.2 注释#

在C++中，可以在代码中插入注释，这些注释不会影响编译和运行，但可以用来描述代码，让开发者（包括自己）获得更好的阅读体验。下面是单行注释和多行注释的示例：

1
// This is a single-line comment.
2
/*
3
This is a
4
multiline
5
comment.
6
*/

3.1.3 命名空间#

命名空间用于处理命名冲突问题，即如果代码中需要出现两个同名函数，那么可以将它们至于不同的命名空间中，再用namespace1::function()和namespace2::function()来调用。定义一个命名空间的格式如下：

1
namespace ns {
2
    // ...
3
}

特别地，C++标准库中的大部分内容都在std命名空间中。
如果确保一份代码中不会存在命名冲突的问题，可以使用using namespace std;来引入命名空间，从而在之后的代码中不需使用std::前缀。虽然笔者不建议引入命名空间，尤其是std（你永远也不知道标准库里有什么）

3.1.4 输入和输出#

传统C++采用“及其先进”的流式输入输出，具体来说，使用控制台输出流（std::cout）和输出流操作符（<<）来进行输出，使用控制台输入流（std::cin）和输入流操作符（>>）来进行输入。输入或输出操作符可以连用，即可以使用std::cout << var1 << var2;的方式依次输出两个值。类似的，可以使用std::cin >> var1 >> var2;的方式依次输入两个值（一般情况下，以不可见字符空格、换行符、制表符Tab等分割）显然，一条语句不能既输入又输出，所以输入和输出流操作符不能连接使用。
C++标准库中包含多种输入/输出流控制元素，例如可以通过输出std::endl来进行换行。可以通过std::cout << std::fixed << std::setprecision(n) << ...;来控制输出浮点数的小数位数为 nnn ，或去除std::fixed来控制输出浮点数的有效位数为 nnn 。

习题#

为了帮助读者巩固知识，从本节开始，每节末尾都会有相关习题，参考答案可以在代码仓库找到。

习题 3.1-1#

编写一段 C++ 程序，使得此程序输出以下内容。（经典老题）

1
I love playing
2
Genshin
3
Impact

3.2 基础数据类型和变量#

3.2.1 基础数据类型#

众所周知，程序最初就是用来计算的，在数学中，为了简化计算，或是重复利用已经计算的结果，我们常常会使用一些符号来表示具体数值。在编程中，我们也会定义一些变量代替具体值。编程中的变量较数学更为广泛，因为它可以表示数值，也可以表示字符、字符串，甚至是自定义的东西。在编程语言中，数据都是和类型相绑定的，一般来说，基础数据类型有以下几种：

整数（Integer）：与数学中的整数定义相同，因为二进制整数与十进制整数总是可以互相转换，所以不存在精度问题。在C++中，整数类型分为有符号整数（signed）和无符号整数（unsigned）两类。按照数据长度分类，可以分为16位（short）、32位（long）、64位（long long）。有符号整数可以表示的数的范围为 [−2n−1,2n−1−1][-2^{n-1}, 2^{n-1}-1][−2n−1,2n−1−1] ，无符号整数可以表示的数的范围为 [0,2n−1][0, 2^n-1][0,2n−1] ，其中n为数据长度（二进制位数）。整数类型的类型名组成为(符号限定符) (长度限定符) (int)，其中符号限定符默认为signed，长度限定符默认为long，所以int表示32为有符号整数（在一些古老的机器上，int也可能表示16位有符号整数）。符号限定符、长度限定符和int三者至少出现一个。（这不废话吗，都没了还算什么类型名）

浮点数（Float）：即小数，由于二进制小数与十进制小数不一定能恰好互相转换，所以存在浮点误差。单精度浮点（float）和双精度浮点（double）分别能表示7位和15位十进制有效数字。笔者测试得到下表。（测试代码见代码仓库）

类型	二进制位数	有效数字（十进制位数）	数值范围
float	32	6~7	[±1.17549∗10−38,±3.40282∗1038][\pm1.1754910^{-38},\pm3.4028210^{38}][±1.17549∗10−38,±3.40282∗1038]
double	64	15~16	[±2.22507∗10−308,±1.79769∗10308][\pm2.2250710^{-308},\pm1.7976910^{308}][±2.22507∗10−308,±1.79769∗10308]
long double	128	18~19	[±3.3621∗10−4932,±1.18973∗104932][\pm3.362110^{-4932},\pm1.1897310^{4932}][±3.3621∗10−4932,±1.18973∗104932]

字符（Character）：符合ASCII标准的字符，占用1个字节，类型名为char。值得一提的是，为了支持国际化，C++还有宽字符类型wchar_t等类型。
布尔值（Boolean）：仅能表示真（true）、假（false）两个值，但仍占用1个字节，因为计算机中最小的单位为字节。
指针（Pointer）：表示一个内存地址，因此其大小与去除指针后的类型大小无关，仅与程序位数有关，如32位程序的指针大小为4字节，64位程序的指针大小为8字节。一级指针的类型名组成为原类型*，但定义多个变量时应在每个变量名前加*，形如int *a, *b;。指针可以嵌套，即多级指针，形如int**。

C++的类型系统中包含非常多的基础类型，这里只介绍了常用的一部分，更多信息可参考https://zh.cppreference.com/w/cpp/language/types

3.2.2 变量#

作为一门较为底层的语言，C++是静态类型的语言，即一个变量一旦定义好了，就只能表示这一个类型的值。同时它是可变的（mutable），除非在类型名前或后（一般习惯加在前）加上类型修饰符const使其成为常量。定义变量的语法为(类型修饰符) 类型名变量名;，如int x;。之后可以用赋值运算符=对变量进行赋值操作：x = 100;。也可以在定义时同时进行赋值，如int x = 100;，还可以写成int x{100};，这两种的区别会在面向对象相关章节提到。还可以在一条语句中定义两个变量，如int a = 1, b = 2;。需要注意的是，赋值运算符是有返回值的，其返回赋值之后被赋值的变量的引用（引用将在之后的章节中介绍，这里可以暂时忽略，理解为被赋值的变量），并且它是右结合的，即从右向左运算，所以连续使用赋值运算符，如a = b = c;等价于b = c; a = b;两条语句。

C++标准对标识符（变量名、函数名、类型名等）有一定要求，可以是小写字母、大写字母、数字和下划线的组合，并且第一个字符不能是数字。但现在甚至似乎可以用中文

定义在函数中的变量为局部变量，它在该函数运行完后就会被销毁；定义在main函数外的变量为全局变量，它会在程序运行结束后被销毁。

直接出现在代码中的值称为字面量（literal），如100、123.45。一般编译器会自动推导字面量的类型，我们也可以通过字面量后缀手动指定类型，常见的后缀有l（long）、ul（unsigned long）、ll（long long）、ull（unsigned long long）、f（float）、lf（double）、llf（long double）等。特别地，可以通过字面量前缀来指定数值类型的进制，常见的有0x（16进制）、0（8进制）、0b（2进制，C++14及以后）。字符（串）字面量中有一类转义字符，即用\加一个字符表示一些常用的不可见字符，如\n表示换行符、\r表示回车符、\t表示制表符。

C++的数值类型变量和字面量都可以进行运算，与数学运算类似。特别地，两个整数进行除法操作时为整除，如果需要正常的除法，需要将其转换为浮点数再进行运算。除了常见的加减乘除运算符（+-*/），还有一个常用的整数间运算符为取余%。一般的，可以将赋值运算符和其他运算符结合，构成自操作运算符，例如a = a + b;可以改写为a += b;。当多个运算符同时使用时，运算符优先级规则，可以使用添加小括号的方式改变优先级。优先级顺序和结合性参考 https://zh.cppreference.com/w/cpp/language/operator_precedence

逻辑运算符是应用于两个bool值之间的运算符，其返回值也是bool值。常用的逻辑运算符如下表：

逻辑运算	符号	名称	真值判定
∧\land∧	`A&&B`	逻辑与	A与B同时为真
∨\lor∨	`A\|\|B`	逻辑或	A与B至少有一个为真
¬\lnot¬	`!A`	逻辑非	A为假

与逻辑运算相对应，对于整数类型，有位运算：按位与A&B、按位或A|B、按位取反~A、按位异或A^B，表示对于整数的二进制表示中每一位进行相应的操作。

3.2.3 指针、数组和引用#

由于指针的重要性以及它与引用的关系之密切，我们将其单独讲解。指针为“修改数据”和“表示数据”提供了新方法，区别于简单赋值和读取，它使得我们可以从更接近底层的角度访问数据。一般的，我们可以用取地址操作符&对一个已有的变量取地址，用解引用操作符*得到一个指针所指向的值。这样说其实并不准确，因为一个内存地址表示一个字节，但多数类型的大小是大于一个字节的，所以指针的值表示其指向的变量的第一个内存地址。记去除指针后的类型（下称原类型）的大小为 nnn ，则从这个地址开始的 nnn 个字节的位置实际存储这个变量的值。所以解引用实际上是将从这个地址开始的连续 nnn 个字节的数据解释为原类型。这样讲似乎有些抽象，我们举一个具体例子。假设我们有一个int类型的变量v，它在内存中占用1001、1002、1003、1004四个地址的空间（因为int类型大小为4字节），对其进行取地址操作就得到一个类型为int*，实际值为1001的值。指针类型的值也可以进行加减操作，但与数值类型不同的是，v + 1的实际值为1005，即按照原类型大小向后推 nnn 个字节（地址）。
指针可以嵌套使用，即多级指针。例如，int**类型表示指向int*类型的值的指针。
还有一种特殊的指针：空类型指针void*，顾名思义，这个指针类型的原类型为空（void），或者说不带有原类型信息。它可以被转换为任何类型的指针，因此在没有模板和泛型的C语言中常常被用来传递任意类型的参数，如C标准库中的qsort函数的比较函数的参数类型为void*，用于对任意类型的数组进行排序。（这样做的另一个优点是不像值传参那样耗费资源，具体会在函数传参相关章节讲解）需要注意的是，void类型不能单独使用，它只能作为指针或者返回值类型（表示不返回值）使用。

给指针加上一个长度信息，就成了数组，即一组在内存中连续的值。可以通过取下标操作符[]来获取相应下标（位置）的值的引用，需要注意的是，下标从0开始。例如，有如下定义int arr[5];，表示包含5个int型元素的数组，则arr[3]表示第4个元素。与普通变量类似，我们可以在定义时赋初始值int arr[5] = {1, 2, 3, 4, 5};。特别地，如果初始值是确定的，则可以省略中括号里的元素个数。如果指定了元素个数但设定的初始值个数小于指定的元素个数，则剩下的元素会被填充为默认值（对于数值类型来说，为0）。有一种常见的说法是数组本质上就是指针，其实不完全是，但由于C++的类型退化机制，使得数组类型在大部分情况下都被作为指针使用，甚至取下标操作符arr[3]都被编译器翻译为*(arr + 3)（读者可根据上文提到的指针加减的意义来验证这样翻译的正确性），因此我们可以写出类似3[arr]的逆天代码（并且是完全符合语法的）。
和指针相同，数组也可以有多维。例如，对于定义为int arr[2][2]的二维数组进行一次取下标操作，可以得到一个类型为int*的值。

引用（reference）是C++相较于C特有的语法，它可以被简单理解为创建一个原变量的别名（而不是复制一份出来）。特别地，字面量不能被引用。引用的底层原理与指针相同，在大部分情况下可以用来代替指针，并且可以确保安全性，因为它必须引用到一个已定义的变量上，并且它引用的地址（可以理解为底层指针的实际值）不能被修改（对引用的操作就是对原变量的操作）。如果一个引用变量仅仅作为其他变量的别名来使用，它常常会被编译器优化掉，也就不占用实际空间。（但如果作为类的成员变量（在面向对象章节会介绍），它就会老老实实地用类似指针的方法来实现，因为编译器无法推导出它是否可以被优化）

对于指针类型，我们可以在其类型名的*之后加const修饰符，表示这个指针变量所指向的地址是不可修改的，即在赋初始值之后不能再给它赋其他地址值，但是仍然可以通过解引用来修改它指向的地址的值（除非原类型为常量类型）。给引用类型本身加const修饰符是不合语法的（本身也没有意义）。

习题 3.2-1#

编写一段 C++ 程序，使其接受输入三个int范围内的正整数 a, b, ca,\space b,\space ca, b, c ，计算并输出三边长为 a, b, ca,\space b,\space ca, b, c 的三角形面积的平方。提示：使用海伦公式（S=p(p−a)(p−b)(p−c), p=a+b+c2S=\sqrt{p(p-a)(p-b)(p-c)},\space p=\frac{a+b+c}{2}S=p(p−a)(p−b)(p−c), p=2a+b+c）。

3.3 程序流程控制#

3.3.1 顺序结构#

编程中最常用的代码结构就是顺序结构，即按照代码中的顺序从前往后一行一行地执行程序。若无特殊操作（循环、多线程、异步等），直接编写的代码即为顺序执行的。

我们可以使用goto-label的方式来对顺序结构进行简单的修改，使用label:在代码中加入一个名为label的标签，然后使用goto label;来跳转至标签所在行开始向下执行。标签和goto没有先后顺序的要求。

3.3.2 分支结构#

在生活中，我们常常需要根据外界环境给出相应的不同的反馈，可以将其抽象为“如果……，那么……，否则……”。类似的，在C++中，我们可以通过如下方式进行条件判断：

1
if (condition) {
2
    // then...
3
} else {
4
    // otherwise...
5
}

其中condition是一个返回值类型为bool的表达式或值（或任何可以隐式转换为bool类型的值），如果condition为true，则执行// then...这一段代码，否则（即condition为false）执行// otherwise...这一段代码。我们也可以去除else，仅保留一个if，或并列使用多个if-else，如下：

1
if (condition1) {
2
    // condition1 is true
3
} else if (condition2) {
4
    // condition2 is true (condition1 is false)
5
} else {
6
    // condition2 is false (condition1 is false)
7
}

对于嵌套使用if-else的情况，我们推荐使用逻辑与运算符%%和逻辑或运算符||将其简化为一个或少数几个if-else（可能需要根据优先级添加小括号），如下：

1
if (condition1) {
2
    if (condition2) {
3
        // both condition1 and condition2 are true
4
    }
5
}
6
// is equivalent to the following
7
if (condition1 && condition2) {
8
    // both condition1 and condition2 are true
9
}

对于并列使用很多if-else的情况，可以考虑使用switch-cases，其完全形态如下：

1
switch (value) {
2
    case const_value_1:
3
        // value is const_value_1
4
    case const_value_2:
5
        // value is const_value_2
6
    default:
7
        // value is neither const_value_1 nor const_value_2
8
}

表示根据value的值跳转到相应的case所在行继续往下执行，如果没有匹配的case，则跳转至default（如果有，否则跳出switch）。需要注意的是，一个case并不标识一个代码块，因此如果不想让程序从一个case执行到另一个case中，可以在上一个case末尾添加break;语句来跳出switch。

3.3.3 循环结构#

如果要将一段代码执行多次，就可以用循环结构来简化代码（虽然复制粘贴加if人肉展开也不是不行）。循环常常与数组搭配使用，用来用同一套逻辑处理大量数据。最常用的循环结构实现为for循环：

1
for (init; condition; expression) {
2
    // statement
3
}
4
// is equivalent to the following
5
{
6
    init;
7
    label:
8
    {
9
        if (condition) {
10
            // statement
11
            expression;
12
            goto label;
13
        }
14
    }
15
}

展开收起

goto的翻译似乎有些抽象，我们进行一些讲解。一般来说，for循环小括号中的三个表达式依次是初始化循环变量（索引）、循环条件和修改循环变量。其执行过程为：首先执行初始化语句（第一个语句），之后判断是否满足循环条件（第二个表达式），若不满足则跳出循环，若满足则进入循环体，执行完循环体后执行修改循环变量，之后进行下一次循环（判断循环条件、执行循环体、执行修改索引为一次循环）。在循环体内，可以通过condition;语句来跳至下一次循环，通过break;语句来跳出循环。

while循环也是常用的循环结构，如下：

1
while (condition) {
2
    // statement
3
}
4
// is equivalent to the following
5
label:
6
{
7
    if (condition) {
8
        // statement
9
        goto label;
10
    }
11
}

有了理解for循环对应的goto代码后，通过goto代码理解while循环也应是trivial的。

还有一类do-while循环，实践中并不常用，但为了完整性还是介绍一下：

1
do {
2
    // statement
3
} while (condition);
4
// is equivalent to the following
5
label:
6
{
7
    // statement
8
    if (condition) {
9
        goto label;
10
    }
11
}

不难发现其与while循环的区别仅在于条件判断和循环体的先后。

习题 3.3-1#

编写一段 C++ 程序，使其接受输入一个int范围内的正整数 nnn ，输出1到 nnn （含）中所有3的倍数，一个一行。

3.4 函数#

我们可以使用3.2节和3.3节的知识来实现各种功能，但当程序达到一定大小时，这往往会使得代码难以阅读和修改，成为屎山。因此，我们需要函数（function）来对代码进行分块、抽象。程序的入口main函数就是一个重要的函数，大部分代码都在它内部进行。
一个简单的函数示例如下：

1
int add(int x, int y) {
2
    return x + y;
3
}

其中add为函数名，其之前的int为返回值类型，其之后的int x, int y为参数列表，大括号内部为函数体。可以使用类似add(1, 2)的语法来调用此函数。

函数的执行流程为：遇到函数调用时，将参数（如果有）传递给参数列表中的参数，并进入函数体执行。遇到return时将返回值（如果有）传递回来，并回到调用处向下执行。

参数列表的语法与定义变量类似，多个参数中间用逗号分隔，但不能合并相同的类型（如int x, y）。事实上，参数名对定义函数来说是无关紧要的。与变量类似，参数也可以有默认值，这时这个参数为缺省参数。缺省参数只能位于参数列表的末尾（也可以有多个），这时调用函数时可以不传入这个参数所对应的实际参数（其值就是定义的默认值）。参数列表中定义的参数为形式参数，调用函数时传入的参数为实际参数。函数体中只能对形式参数进行操作，如果需要修改传入的实际参数，可以使用引用类型。

函数被调用时返回的值的类型由返回值类型指定。特别地，如果一个函数不需要返回任何值，则可以使用空类型void。通过return ...;在函数体内部结束函数并返回值，其中...可以是任何表达式。

函数体中可以调用任何函数，包括其自己。调用自己的函数为递归函数。如下面是一个利用递归函数计算阶乘的例子：

1
int factorial(int n) {
2
    if (n == 1) {
3
        return 1;
4
    }
5
    return n * factorial(n - 1);
6
}

递归的进行并不是无限制的，这里需要引入调用栈（call stack）的概念。首先来了解栈：栈类似一摞积木，每块积木都是栈里的一个元素，并且栈只能从顶部进行操作，即只有拿走最上面的积木、往上加再一块积木两种操作。调用栈也是如此，简单来说，其中每个元素代表一个函数及其函数体中的局部变量。在程序运行时，操作系统负责维护这样一个栈，用于记录程序现在在哪个函数中执行。当元素数量达到一定限制时，就会溢出，俗称爆栈。（一般是达到编译器设定的限制，或是内存不足）

当递归函数的递归层数过多时，就有可能触发栈溢出，因此对于比较简单的代码，推荐使用循环等普通方法代替递归实现。（理论上所有递归代码都可以改写成只使用循环的普通方法，但过于复杂的递归代码会使人大脑升级小脑萎缩）

另一个典型的使用引用类型作为参数的例子是交换函数（顾名思义，该函数可以交换两个变量的值）：

1
void swap(int& x, int& y) {
2
    int t = x;
3
    x = y;
4
    y = t;
5
}

由于使用了引用类型，在函数体内部对x、y变量的操作就会反映到外部的作为实际参数传入的变量中。引用类型的另一好处为不需要把这个变量复制一份（函数体中使用的其实就是传入的变量），因此也常被用来优化。如果不想要修改传入的变量同时不希望复制一份，可以使用常量引用（const的引用）。

这里的swap函数只能对整数类型进行交换，如果我们想要交换浮点类型，则需要写另一个版本，方法也很简单，即将上面函数中的int改为double。得益于C++的函数重载机制，这两个函数可以共用swap这个名称，并且在调用时编译器会根据传入参数的类型自动判断要调用的是哪个函数。（顺便剧透一下，在模板相关章节我们会写一个能对任意类型进行交换的swap函数）

有不同的参数列表（正如上文所说，参数列表的不同指的是参数类型的不同）的函数可以使用相同的函数名，这就是函数重载。函数重载带来的最大的好处在于方便了调用者，即只要是语义相同的参数类型都可以用同一个函数名进行调用，如C++标准库中的std::sin函数提供了float、double、long double三种类型的重载。

值得一提的是，运算符也是可以被重载的，因为运算符本质上也是函数，但这只适用于自定义类型（将在面向对象编程相关章节详细介绍）。

3.5 面向对象初步#

面向对象编程（OOP，Object-Oriented Programming）是一种重要的编程范式，它使得数据和处理数据的方法紧密结合

3.5.1 类#

类是一系列变量和函数的集合体，也就是自定义类型，可以使用如下的语法来定义一个类：

1
class class_name {
2
    // ...
3
};

其中class也可以用struct代替，// ...为任意多个变量定义和函数定义，类中的变量为成员变量，类中的函数为成员函数。

可以使用类型访问修饰符public:、private:和protected:来标记从该行开始到类定义结束范围内定义的变量和函数的可访问性，public表示任何地方都可以访问，private表示只能在该类的成员函数中访问，protected表示可以在该类的成员函数和派生类的成员函数中访问。

class和struct的唯一区别在于默认的可访问性（即不写类型访问修饰符时的可访问性）：class为private，struct为public。

习惯上使struct只包含成员变量而不包含成员函数，且不修改它的可访问性（即保持默认的public）。

构造函数和析构函数使类中的特殊的成员函数，构造函数名与类名相同，析构函数名为类名前加上~，构造函数在创建一个该类型的变量时被调用，析构函数在类的示例被销毁时被调用，构造函数和析构函数都没有返回值，并且析构函数不能有参数。

可以通过成员访问运算符.来访问类的成员变量和成员函数，也可以使用->在访问时进行解引用，如x->y等价于*(x.y)。

this为类中一个特殊的指针，它指向该类的实例自己。当局部变量和类中的成员变量重名时，可以通过this->的方式访问成员变量，而直接使用变量名访问局部变量。

创建一个该类型的变量称为类的实例化，这个变量为该类的实例，实例化时可以向构造函数传递参数，

为了更好地理解，我们以如下的类为例子：

1
class Point {
2
public:
3
    int x, y;
4
    Point() {
5
        x = 0;
6
        y = 0;
7
    }
8
    Point(int x, int y) {
9
        this->x = x;
10
        this->y = y;
11
    }
12
    void set_x(int x) {
13
        this->x = x;
14
    }
15
    int get_x() {
16
        return x;
17
    }
18
    // ...
19
    ~Point() {
20
        // ...
21
    }
22
};
23

24
int main() {
25
    Point point(1, 2);
26
    std::cout << point.get_x() << '\n';
27
    return 0;
28
}

展开收起

该程序的输出应为1。其中Point point(1, 2);调用了第二个构造函数，如果使用Point point;则会调用无参数的构造函数（即默认构造函数），也可以使用Point point = Point(1, 2);。

由于特殊构造函数过于复杂，且牵涉到右值引用，这里暂时不介绍。

3.5.2 继承#

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易，这样也达到了重用代码功能和提高执行效率的效果。当创建一个类时，不需要重新编写新的成员变量和成员函数，只需指定新建的类继承了一个已有的类即可。这个已有的类称为基类，新建的类称为派生类。继承的语法为[class|struct] 派生类名: 访问修饰符基类名，其中访问修饰符为public、protected或 private，例如：

1
class Base {
2
};
3
class Derived : public Base {
4
};

这时Derived类会继承Base类的所有成员变量和成员函数，除了
当使用不同访问修饰符的继承时，遵循以下几个规则：

公有继承（public）：当一个类派生自public基类时，基类的public成员也是派生类的public成员，基类的protected成员也是派生类的protected成员，基类的private成员不能直接被派生类访问，但是可以通过调用基类的public和protected成员来访问。
保护继承（protected）：当一个类派生自protected基类时，基类的public和protected成员将成为派生类的protected成员。
私有继承（private）：当一个类派生自private基类时，基类的public和protected成员将成为派生类的private成员。

class的默认继承为private，struct为public。

3.5.3 运算符重载#

我们可以在类中重定义或重载大部分运算符，这样就可以对自定义类型使用运算符。重载运算符与定义函数几乎相同，只有函数名变成了operator加运算符。运算符的参数列表是特定的，与运算符种类和运算符重载的位置有关。例如，在类外部定义的加号+运算符需要两个参数，在类里定义的加号+运算符只要一个参数（另一个就是该类本身的实例）。

例如，对于上面的Point类，可以这样重载加号+运算符：

1
class Point {
2
// ...
3
public:
4
    Point operator+(const Point& rhs) {
5
        return Point(x + rhs.x, y + rhs.y);
6
    }
7
};

或

1
// outside the class definition
2
Point operator+(const Point& lhs, const Point& rhs) {
3
    return Point(lhs.x + rhs.x, lhs.y + rhs.y);
4
}

事实上，更常见的情况是我们会把x和y设为private，这时为了在public成员函数中访问到private成员变量，我们需要将其设为友元函数：

1
class Point {
2
// ...
3
public:
4
    friend Point operator+(const Point& lhs, const Point& rhs)
5
};
6
Point operator+(const Point& lhs, const Point& rhs) {
7
    return Point(lhs.x + rhs.x, lhs.y + rhs.y);
8
}

3.5.4 多态#

-1. 结语#

编程是一项需要不断学习和实践的技能。希望读者能够通过本书掌握编程的基本技能，并在未来的学习和工作中有所收获。

-1.1 编者的话#

在编写本书的过程中，参考了大量优秀的编程教材和资源。同时也结合了自己的学习经验，希望能够为读者提供一本系统、实用、易学的编程教材。

在本书的编写过程中，编者得到了许多人的帮助，在此向他们表示衷心的感谢。

最后，祝愿读者在编程学习的道路上取得成功！

一些Python模拟角谷猜想的性能测试

Sat, 15 Jun 2024 00:00:00 GMT

公共部分#

1
def solve(n):
2
    step = 0
3
    while n != 1:
4
        if n % 2 == 0:
5
            n //= 2
6
        else:
7
            n = 3 * n + 1
8
        step += 1
9
    return step
10
N = 1000000

v1#

没啥好说的顺序求解
主要代码：

1
x = [i for i in range(1, N + 1)]
2
y = list(map(solve, x))

v2#

测试电脑为6C12T 故采用max_workers=12
主要代码：

1
from concurrent.futures import ThreadPoolExecutor
2
x = [i for i in range(1, N + 1)]
3
with ThreadPoolExecutor(max_workers=12) as e:
4
    y = list(e.map(solve, x))

v3#

主要代码：

1
import numpy as np
2
x = np.arange(1, N + 1, 1)
3
y = solve(x)

np.vectorize版：

1
import numpy as np
2
x = np.arange(1, N + 1, 1)
3
solve_vector = np.vectorize(solve)
4
y = solve_vector(x)

测试结果#

+njit指给solve()函数加上了@njit标签
+vectorize指给solve()函数加上了@vectorize()标签
numpy不带(vec)指使用numba的#vectorize()标签而不使用np.vectorize 反之亦然

版本	说明	最大内存占用	时间1	时间2	时间3	平均时间
v1	Serial	106.1MB	10272.937ms	10022.724ms	10065.625ms	10120.429ms
v1.1	Serial+njit	119.6MB	712.524ms	699.496ms	691.721ms	701.247ms
v1.1p	Serial+njit	105.8MB	232.681ms	239.268ms	234.367ms	235.439ms
v2	ThreadPoolExecutor(12)	1750.6MB	43345.733ms	44833.593ms	40681.212ms	42953.513ms
v2.1	ThreadPoolExecutor(12)+njit	2013.0MB	17897.805ms	16293.948ms	16591.327ms	16927.693ms
v3	numpy(vec)	108.8MB	9986.405ms	10205.962ms	9894.202ms	10028.856ms
v3.1	numpy(vec)+njit	115.1MB	736.445ms	796.545ms	749.636ms	760.875ms
v3.2	numpy+vectorize	93.2MB	538.277ms	532.579ms	542.114ms	537.657ms
v3.3	numpy+vectorize+njit	99.3MB	932.287ms	907.180ms	927.224ms	922.230ms
v3.3p	numpy+vectorize+njit	92.7MB	231.020ms	227.666ms	228.072ms	228.919ms

总结#

用numba就完事了
最后放张算出来的图吧

数学随笔

Sat, 15 Jun 2024 00:00:00 GMT

在学校玩计算器时无意发现一个神奇的式子
tan(sin−1(x))→xtan(sin^{-1}(x))\rarr xtan(sin−1(x))→x
当 xxx 初始值为 110\frac{1}{10}101 时按上面的式子迭代19次会得到19\frac{1}{9}91 再继续迭代17次会得到18\frac{1}{8}81；以此类推最终到1
简单整理一下定义
an+1=an1−an2 (n∈Z)a_{n+1}=\frac{a_n}{\sqrt{1-a_n^2}}\space(n\in\Z)an+1=1−an2an (n∈Z)
若 ai=1k (i∈Z,k∈Z∩[2,+∞))a_i=\frac{1}{k}\space(i\in\Z,k\in\Z\cap[2,+\infin))ai=k1 (i∈Z,k∈Z∩[2,+∞)) 则 ai+2k−1=1k−1a_{i+2k-1}=\frac{1}{k-1}ai+2k−1=k−11
显然只要将表达式代入自身19次就能看出端倪了但由于我计算力低下且在学校没时间于是回家用代码测一测它
首先数值模拟就不必多说了（毕竟在学校用计算器模拟的足够多了）我直接import sympy

1
from sympy import Symbol, sqrt, simplify
2

3
x = Symbol('x')
4
for i in range(19):
5
    x = x / sqrt(1 - x ** 2)
6
    x = simplify(x)
7
print(x)

本来那个sqrt图省事用的是** 0.5 但是这两个在sympy里面似乎不等价 ** 0.5还是当成幂计算算了好久也算不到19
后来改sqrt之后总算快了一点但是算出来的式子有点抽象再怎么simplify()也只能得出这样的结果

x2x2−1x2−13x2−12x2−14x2−13x2−15x2−14x2−16x2−15x2−17x2−16x2−18x2−17x2−19x2−18x2−110x2−19x2−111x2−110x2−112x2−111x2−113x2−112x2−114x2−113x2−115x2−114x2−116x2−115x2−117x2−116x2−118x2−117x2−119x2−118x2−11−x2\frac{x}{\sqrt{\frac{2 x^{2} - 1}{x^{2} - 1}} \sqrt{\frac{3 x^{2} - 1}{2 x^{2} - 1}} \sqrt{\frac{4 x^{2} - 1}{3 x^{2} - 1}} \sqrt{\frac{5 x^{2} - 1}{4 x^{2} - 1}} \sqrt{\frac{6 x^{2} - 1}{5 x^{2} - 1}} \sqrt{\frac{7 x^{2} - 1}{6 x^{2} - 1}} \sqrt{\frac{8 x^{2} - 1}{7 x^{2} - 1}} \sqrt{\frac{9 x^{2} - 1}{8 x^{2} - 1}} \sqrt{\frac{10 x^{2} - 1}{9 x^{2} - 1}} \sqrt{\frac{11 x^{2} - 1}{10 x^{2} - 1}} \sqrt{\frac{12 x^{2} - 1}{11 x^{2} - 1}} \sqrt{\frac{13 x^{2} - 1}{12 x^{2} - 1}} \sqrt{\frac{14 x^{2} - 1}{13 x^{2} - 1}} \sqrt{\frac{15 x^{2} - 1}{14 x^{2} - 1}} \sqrt{\frac{16 x^{2} - 1}{15 x^{2} - 1}} \sqrt{\frac{17 x^{2} - 1}{16 x^{2} - 1}} \sqrt{\frac{18 x^{2} - 1}{17 x^{2} - 1}} \sqrt{\frac{19 x^{2} - 1}{18 x^{2} - 1}} \sqrt{1 - x^{2}}}x2−12x2−12x2−13x2−13x2−14x2−14x2−15x2−15x2−16x2−16x2−17x2−17x2−18x2−18x2−19x2−19x2−110x2−110x2−111x2−111x2−112x2−112x2−113x2−113x2−114x2−114x2−115x2−115x2−116x2−116x2−117x2−117x2−118x2−118x2−119x2−11−x2x

显然sympy有点注意力底下了连明显的分式因子都消不掉
于是启动mathematica

1
Subscript[a, n_] := Subscript[a, n-1] / Sqrt[1-Subsuperscript[a, n-1, 2]]
2
Subscript[a, 0] := x
3
Subscript[a, 19] // FullSimplify

不得不说mathematica的计算能力还是一流的很快得到结果
a19=a01−19a02a_{19}=\frac{a_0}{\sqrt{1-19a_0^2}}a19=1−19a02a0
虽然mathematica暂不能（我不会写）给出 ana_nan 关于 a0a_0a0 的表达式但经过更多数据的测试我们可以有根据地猜测
an=a01−na02 (n∈N∗)a_n=\frac{a_0}{\sqrt{1-na_0^2}}\space(n\in\N^*)an=1−na02a0 (n∈N∗)
即
an=ak1−(n−k)ak2 (n∈N∗,k∈N,n>k)a_{n}=\frac{a_k}{\sqrt{1-(n-k)a_k^2}}\space(n\in\N^*,k\in\N,n>k)an=1−(n−k)ak2ak (n∈N∗,k∈N,n>k)
由此显然可以得出开头的结论
顺便用matplotlib.pyplot画了个 a0=0.1a_0=0.1a0=0.1 时的图

alt text

下面是用desmos直接画表达式的图

【解决方案】FFmpeg推流速度过快

Mon, 10 Jun 2024 00:00:00 GMT

FFmpeg使用视频源进行推流时，处理速度往往会快于实际帧率，而默认设置下处理完了一段就直接上传，因此速度会过快
解决方法：使用-re参数

ref: https://stackoverflow.com/questions/48479141/understanding-ffmpeg-re-parameter
It’s useful for real-time output when ffmpeg is able to process a source at a speed faster than real-time. In that scenario, ffmpeg may send output at that faster rate and the receiver may not be able to or want to buffer and queue its input.

OJ答案

Wed, 29 May 2024 00:00:00 GMT

为造福同学将OJ中Python课程答案公布于此
OJ网址：https://oj.nsfz.net

章节1：输入、输出及赋值#

1120 nsfz欢迎你#

1
print('nsfz')
2
print('欢迎你')

1381 你的名字#

1
name = input()
2
print('你好', name)

1119 A+B问题#

1
a = int(input())
2
b = int(input())
3
print(a + b)

章节2：顺序结构#

1003 混合运算#

1
a, b=map(int, input().split())
2
print((a + b) * (a - b))

1001 求一个数的立方#

1
a = int(input())
2
print(a ** 3)

1008 求长方形面积和周长#

1
a, b = map(int, input().split())
2
print(a * b, (a + b) * 2)

1122 计算线段长度#

1
x1, y1 = map(int, input().split())
2
x2, y2 = map(int, input().split())
3
distance = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
4
print('%.3f'%distance)

254 细菌繁殖#

1
a = int(input())
2
print(10 * (2 ** (a - 1)))

1007 求商和余数#

1
a, b = map(int, input().split())
2
print(a // b, a % b, end=' ')
3
print('%.1f'%(a / b))

1133 分离数位#

1
x = int(input())
2
a = x // 100
3
b = x // 10 % 10
4
c = x % 10
5
print(a, b, c)

255 鸡兔同笼#

1
a = int(input())
2
b = int(input())
3
print(2*a-b//2, b//2-a)

256 分糖果#

1
a = list(map(int, input().split()))
2

3
for i in range(5):
4
    a[(i + 4) % 5] += a[i] // 3
5
    a[(i + 1) % 5] += a[i] // 3
6
    a[i] //= 3
7

8
print(a[0], a[1], a[2], a[3], a[4])

257 是0？是1？#

1
a, b, c = map(int, input().split())
2
condition = a % 2 == 1 and b % 2 == 1 and c % 2 == 1
3
print(int(condition))

章节3：关系、逻辑运算与选择语句#

1012 判断奇偶数#

1
x = int(input())
2

3
if x % 2 == 0:
4
    print('是')
5
else:
6
    print('不是')

1014 两数比大小#

1
a, b = map(int, input().split())
2

3
if a > b:
4
    print(a)
5
else:
6
    print(b)

1018 恐龙园买门票#

1
h = float(input())
2

3
if h < 1.3:
4
    print(60)
5
else:
6
    print(120)

1130 心系南方灾区#

1
from math import ceil
2
a,b = map(int, input().split())
3
print(ceil(a/b))

1013 判断闰年#

1
a = int(input())
2

3
if a % 400 == 0 or (a % 4 == 0 and a % 100 != 0):
4
    print('RUN!')
5
else:
6
    print('NO RUN!')

267 左邻右舍#

1
n, x = map(int, input().split())
2

3
a, b = x - 1, x + 1
4
if a == 0:
5
    a = n
6
if b == n + 1:
7
    b = 1
8
print(min(a, b), max(a, b))

1366 出租车计费#

1
w = float(input())
2

3
if w <= 3:
4
    print('8.0')
5
elif w <= 10:
6
    print('%.1f'%(8+(w-3)*1.8))
7
else:
8
    print('%.1f'%(8+7*1.8+(w-10)*2.4))

1010 三个数的大小关系#

1
a, b, c = map(int, input().split())
2

3
if a < b < c:
4
    print('Yes')
5
else:
6
    print('No')

1370 BMI指数#

1
a, b = map(float, input().split())
2

3
x = b / (a * a)
4
if x <= 18.4:
5
    print('偏瘦')
6
elif x <= 23.9:
7
    print('正常')
8
elif x <= 27.9:
9
    print('过重')
10
else:
11
    print('肥胖')

272 加油卡充值#

1
n = int(input())
2

3
if n >= 5000:
4
    print('%.2f'%(n+n*0.05))
5
elif n >= 3000:
6
    print('%.2f'%(n+n*0.04))
7
elif n >= 1000:
8
    print('%.2f'%(n+n*0.03))
9
else:
10
    print('%.2f'%n)

266 **解方程#

1
a, b, c = map(int, input().split())
2

3
if a == 0:
4
    if b == 0:
5
        if c == 0:
6
            print('任意实数')
7
        else:
8
            print('无解')
9
    else:
10
        print('%.1f'%(-c / b))
11
else:
12
    delta = b * b - 4 * a * c
13
    if delta > 0:
14
        print('%.1f'%((-b-delta**0.5)/2/a), end=' ')
15
        print('%.1f'%((-b+delta**0.5)/2/a))
16
    elif delta == 0:
17
        print('%.1f'%(-b/2/a))
18
    else:
19
        print('无解')

展开收起

ss13 **统计每月天数#

1
l1 = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
2
l2 = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
3

4
a, b = map(int, input().split())
5
if a % 400 == 0 or a % 4 == 0 and a % 100 != 0:
6
    print(l2[b])
7
else:
8
    print(l1[b])

章节4：循环语句for#

1436 输出多行******#

1
n = int(input())
2
for i in range(n):
3
    print('******')

1437 输出n个自然数#

1
n = int(input())
2
for i in range(1, n + 1):
3
    print(i, end=' ')

1020 求解1+2+3+…+n#

1
n = int(input())
2
print(n * (n + 1) // 2)

1021 求1+3+5+…+n#

1
n = int(input())
2
print((1 + n) * ((n - 1) // 2 + 1) // 2)

1022 求2+4+6+…+n#

1
n = int(input())
2
print((2 + n) * ((n - 2) // 2 + 1) // 2)

1023 求1+1/2+1/3+…+1/n#

1
n = int(input())
2
ans = 0.0
3
for i in range(1, n + 1):
4
    ans += 1 / i
5
print('%.3f'%ans)

1025 求11+22+…+n*n#

1
n = int(input())
2
ans = 0
3
for i in range(1, n + 1):
4
    ans += i ** 2
5
print(ans)

1124 分别求奇数和偶数和#

1
n = int(input())
2
ans1, ans2 = 0, 0
3
for i in range(n):
4
    t = int(input())
5
    if t % 2 == 0:
6
        ans2 += t
7
    else:
8
        ans1 += t;
9
print(ans1)
10
print(ans2)

1382 求约数和#

1
n = int(input())
2
ans = 0
3
for i in range(1, n + 1):
4
    if n % i == 0:
5
        ans += i
6
print(ans)

1026 求n!#

1
n = int(input())
2
ans = 1
3
for i in range(1, n + 1):
4
    ans *= i
5
print(ans)

1131 **判奇偶求和#

1
n = int(input())
2
ans = 0
3
if n % 2 == 1:
4
    for i in range(1, n + 1):
5
        if i % 2 == 0:
6
            ans += i
7
else:
8
    for i in range(1, n + 1):
9
        if n % i == 0:
10
            ans += i
11
print(ans)

1027 **求1!+2!+…+n!#

1
def factorial(n: int):
2
    ans = 1;
3
    for i in range(1, n + 1):
4
        ans *= i
5
    return ans
6

7
n = int(input())
8
ans = 0
9
for i in range(1, n + 1):
10
    ans += factorial(i)
11
print(ans)

273 **住宿费#

1
n = int(input())
2
if n % 4 == 1:
3
    print((n // 4 - 2)* 140 + 3 * 120)
4
elif n % 4 == 2:
5
    print((n // 4 - 1) * 140 + 2 * 120)
6
elif n % 4 == 3:
7
    print((n // 4) * 140 + 120)
8
else:
9
    print(n // 4 * 140)

章节5：循环语句while#

1442 理财#

1
n = 1.0
2
t = 0
3
while True:
4
    n *= 1.035
5
    t += 1
6
    if n >= 2:
7
        print(t)
8
        break

1443 折纸的厚度#

1
i = 1
2
while 0.00008 * (2 ** i) <= 8844.43:
3
    i += 1
4
print(i)

1126 求1+1/2+1/3+…+1/n>X的n最小值#

1
n = int(input())
2
s = 0
3
for i in range(1, 100000000):
4
    s += 1 / i
5
    if s > n:
6
        print(i)
7
        break

1132 至少多少#

1
n = int(input())
2
s = 0
3
for i in range(1, 10000000):
4
    s += i * 2 - 1
5
    if s >= n:
6
        print(i)
7
        break

1125 角谷猜想#

1
n = int(input())
2
step = 0
3
while n != 1:
4
    if n % 2 == 0:
5
        n //= 2
6
    else:
7
        n = n * 3 + 1
8
    step += 1
9
print(step)

1444 统计整数个数#

1
ans = 0
2
while True:
3
    n = int(input())
4
    if n == 0:
5
        break
6
    ans += 1
7
print(ans)

1367 根据AQI值判断城市的空气质量#

1
while True:
2
    n = int(input())
3
    if n == -1:
4
        exit(0)
5
    if n <= 100:
6
        print('优良')
7
    else:
8
        print('污染')

1439 辗转相除法求最大公约数#

1
import math
2
a, b = map(int, input().split())
3
print(math.gcd(a, b))

1445 求最大公约数#

1
from math import gcd
2

3
a, b, c = map(int, input().split())
4

5
print(gcd(gcd(a, b), c))

1445 求最大公约数#

1
import math
2
a , b = map(int, input().split())
3
print(a * b // math.gcd(a, b))

1369 **猜数游戏#

此题无法提交不用写

章节6：列表list#

1052 排序输出#

1
l = []
2
while True:
3
    s = input()
4
    if int(s) == -1:
5
        break
6
    l.append(int(s))
7

8
l.sort()
9

10
for i in l:
11
    print(i)
12
exit(0)

1435 评委评分#

1
n = int(input())
2
l = []
3
for i in range(n):
4
    l.append(int(input()))
5

6
l.sort()
7

8
print(sum(l[1:-1]) / (n - 2))

282 统计数字个数#

1
s = input()
2

3
l = [0 for i in range(10)]
4

5
for c in s:
6
    l[ord(c) - ord('0')] += 1
7

8
print(' '.join(map(str, l)))

1051 求平均年龄#

1
l = []
2
while (n := int(input())) != 0:
3
    l.append(n)
4

5
print('%.2f'%(sum(l) / len(l)))

1438 求平均身高#

1
n = int(input())
2
l = []
3
for i in range(n):
4
    l.append(float(input()))
5

6
print('%.2f'%(sum(l) / len(l)))

1050 寻找数m#

1
l = map(int, input().split())
2
m = int(input())
3
ans = 0
4
for i in l:
5
    if i == m:
6
        ans += 1
7
print(ans)

章节7：自定义函数#

1446 组合数#

1
def fac(n):
2
    s = 1
3
    for i in range(1, n + 1):
4
        s *= i
5
    return s
6
n, m = map(int, input().split())
7
print(fac(n) // fac(m) // fac(n - m))

1112 绝对素数#

1
def is_prime(n: int):
2
    i = 2
3
    while i ** 2 <= n:
4
        if n % i == 0:
5
            return False
6
        i += 1
7
    return True
8

9
for i in range(11, 100):
10
    if is_prime(i) and is_prime(int(''.join(reversed(str(i))))):
11
        print(i)

1129 求三角形周长#

1
def dist(x1, y1, x2, y2):
2
    return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
3

4
x1, y1, x2, y2, x3, y3 = map(int, input().split())
5

6
ans = dist(x1, y1, x2, y2) + dist(x1, y1, x3, y3) + dist(x2, y2, x3, y3)
7

8
print('%.2f' % ans)

1118 姐妹数对#

1
def cond(x, y):
2
    return (x + y) % 3 == 0 or (x + y) % 7 == 0
3

4
n = int(input())
5

6
ans = 0
7

8
for i in range(1, n + 1):
9
    for j in range(i + 1, n + 1):
10
        if cond(i, j):
11
            ans += 1
12

13
print(ans)

章节8：算法基础#

1363 递归法求斐波拉契数列第n项的值#

1
def f(n):
2
    if n == 1 or n == 2:
3
        return 1
4
    return f(n - 1) + f(n - 2)
5
n = int(input())
6
print(f(n))

1447 递归求n!#

1
import math
2
n =  int(input())
3
print(math.factorial(n))

1448 递归法实现辗转相除算法#

1
import math
2
a, b = map(int, input().split())
3
print(math.gcd(a, b))

1028 枚举法求水仙花数#

1
m, n = map(int, input().split())
2
f = True
3
for i in range(m, n + 1):
4
    if i == sum(map(lambda x: (ord(x) - ord('0')) ** 3, str(i))):
5
        print(i, end=' ')
6
        f = False
7
if f:
8
    print('no')

1031 枚举法求完美数#

1
def get_divisors_sum(n):
2
    s = 0
3
    for i in range(1, int(n ** 0.5) + 1):
4
        if n % i == 0:
5
            s += i
6
            if i * i != n and i != 1:
7
                s += n // i
8
    return s
9

10
m, n = map(int, input().split())
11

12
for i in range(m, n + 1):
13
    if i == get_divisors_sum(i):
14
        print(i, end=' ')

1362 递推法求斐波拉契数列第n项的值#

1
n = int(input())
2
a, b = 1, 1
3
if n <= 2:
4
    print(1)
5
    exit(0)
6
for i in range(n - 2):
7
    a, b = b, a + b
8
print(b)

1101 汉诺塔#

1
n = int(input())
2

3
def get_other(a, b):
4
    l = ['A', 'B', 'C']
5
    l.remove(a)
6
    l.remove(b)
7
    return l[0]
8

9
def move(n: int, src: str, dest: str):
10
    if n == 1:
11
        print(f'{src} To {dest}')
12
        return
13
    move(n - 1, src, get_other(src, dest))
14
    print(f'{src} To {dest}')
15
    move(n - 1, get_other(src, dest), dest)
16

17
move(n, 'A', 'C')

展开收起

1440 二分查找#

1
n = int(input())
2

3
l, r = 1, 1000
4

5
cnt = 0
6

7
while l < r and l != r - 1:
8
    m = (l + r) // 2
9
    cnt += 1
10
    if n > m:
11
        l = m
12
    elif n < m:
13
        r = m
14
    else:
15
        break
16

17
print(cnt)

展开收起

用Windows To Go解救机房被机械硬盘拖慢速度的电脑

Sun, 26 May 2024 00:00:00 GMT

社团课上找到机房电脑缓慢的根源了——硬盘
有同学带了块移动固态硬盘并成功从外接USB盘启动了电脑速度直接起飞
机房电脑CPU是10代i3 理论上性能不差但是被1TB的希捷机械盘极大地拖慢了速度

于是立刻买了块新固态硬盘准备装系统带机房去用
本来打算整个118GB的傲腾装系统的那样速度肯定更起飞但是要500多块钱实在太贵了（
后来还是决定买个便宜的SATA 硬盘盒加硬盘一共100到手上午买的下午就到了（京东就是快啊）
买的是128GB的长城GW560（买的时候小脑烧了都没看颗粒和TBW 后来发现是TLC就放心了有80TBW 按比例来看比1TB 600TBW还高一点（）
硬盘盒是个不知名的支持SATA3.0
到手后按照标准流程格成NTFS先测个性能再说

测试结果：

1
------------------------------------------------------------------------------
2
CrystalDiskMark 8.0.4 Shizuku Edition x64 (C) 2007-2021 hiyohiyo
3
                                  Crystal Dew World: https://crystalmark.info/
4
------------------------------------------------------------------------------
5
* MB/s = 1,000,000 bytes/s [SATA/600 = 600,000,000 bytes/s]
6
* KB = 1000 bytes, KiB = 1024 bytes
7

8
[Read]
9
  SEQ    1MiB (Q=  8, T= 1):   384.064 MB/s [    366.3 IOPS] < 21765.43 us>
10
  SEQ    1MiB (Q=  1, T= 1):   371.158 MB/s [    354.0 IOPS] <  2823.47 us>
11
  RND    4KiB (Q= 32, T= 1):    21.640 MB/s [   5283.2 IOPS] <  6020.22 us>
12
  RND    4KiB (Q=  1, T= 1):    20.802 MB/s [   5078.6 IOPS] <   196.72 us>
13

14
[Write]
15
  SEQ    1MiB (Q=  8, T= 1):   361.390 MB/s [    344.6 IOPS] < 23093.08 us>
16
  SEQ    1MiB (Q=  1, T= 1):   357.076 MB/s [    340.5 IOPS] <  2920.76 us>
17
  RND    4KiB (Q= 32, T= 1):    26.940 MB/s [   6577.1 IOPS] <  4827.29 us>
18
  RND    4KiB (Q=  1, T= 1):    25.727 MB/s [   6281.0 IOPS] <   158.92 us>
19

20
Profile: Default
21
   Test: 1 GiB (x1) [F: 0% (0/119GiB)]
22
   Mode: [Admin]
23
   Time: Measure 5 sec / Interval 5 sec
24
   Date: 2024/05/25 19:26:52
25
     OS: Windows 11 Enterprise [10.0 Build 22621] (x64)
26
Comment: Great Wall GW560 128GB

展开收起

性能差强人意虽然没有达到标称的读取540MB/s 写入400MB/s 并且被NVME盘薄纱也是必然的
（一开始由于插USB速度太慢导致被识别成USB2.0测出来速度还不如大号U盘）

之后干正事装个Windows 10
因为之前用过一个U盘做安装介质就直接用那个U盘了
用U盘启动之后正常进安装流程选择要装的磁盘的时候才发现Windows不支持在USB连接的硬盘上装系统：（
于是使用Windows To Go 用了知名工具WTGA
装了第一次进系统的时候桌面是黑屏只有个任务栏在哪闪重启之后又重新让创建账户了
但每次都在创建账户的时候出错要么就是直接重启
试了半天之后终于想到用Dism++导出主系统的驱动再让WTGA在部署的时候把这些驱动加上果然一遍过了
之后愉快地设置系统但是任务管理器突然寄了打开就闪退搜了一堆没啥用的解决方案之后终于找到个能用的
sfc /SCANNOW 扫完一遍之后立竿见影直接好了（后来又有这种情况的时候用sfc扫也没用了但是重启就好了）
之后用火绒顶掉Windows Defender的过程中还出了几次问题但通过重装软件也解决了
有趣的是Windows To Go的系统和我的主系统一直在争夺引导权但是由于我一直用Ubuntu的grub做引导经常需要重新调一下
顺便说下DiskGenius自带的启动顺序管理器还挺好用的

最终搞到凌晨12:20多算是差不多了装软件就下次再说吧效果等下周实际使用之后回来补充

学校OJ探索

Fri, 26 Apr 2024 00:00:00 GMT

社团课上与同学玩学校OJ 并尝试对评测机进行一些探索为了方便就用python代码了
已知学校OJ使用的是氦星人系统评测机禁用了os模块导致一开始没法进行系统调用遂尝试读写文件发现居然是可以的
（socket模块依赖os模块导致暂时只能通过OJ的测试功能获取代码输出）
先尝试硬写大量数据以搞爆评测机发现会报File too large错误于是放弃
根据平时使用经验（做题时的报错）得知评测机为Linux系统使用Python3.8
然后尝试向/tmp目录写文件发现可以持久化保存并且另一位同学也能读取到（顺便根据多次实验发现能读取到的概率大约50% 推测有两个评测机负载均衡）
之后尝试读取/proc等以获取系统信息如下

信息	来源	值
CPU	`/proc/cpuinfo`	Intel(R) Xeon(R) Gold 5120 CPU @ 2.20GHz
内存	`/proc/meminfo`	16GB
硬盘分区	`/proc/partitions`	104857600 blocks (sda)… （按1KB/block则为100GB）
启动镜像	`/proc/cmdline`	vmlinuz-3.10.0-1127.10.1.el7.x86_64
内核版本	`/proc/version`	Linux version 3.10.0-1127.10.1.el7.x86_64 (mockbuild@kbuilder.bsys.centos.org)
GCC版本	`/proc/version`	gcc version 4.8.5 20150623 (Red Hat 4.8.5-39) (GCC)
运行时间	`/proc/uptime`	运行：788.4天；空闲：784.2天/核心（空闲率99.46%）

回家后同学发现可以使用posix模块进行系统调用并且该模块没有被禁用于是打开新世界的大门

首先肯定是是ls 当前目录包含source、source.c、input、core.xxxxx等文件
其中source就是python代码的源文件 cat后发现评测时会在提交的python代码前加上如下代码：

1
import random
2
import sys
3
sys.modules["os"] = None

source.c和core.xxxxx分别是C++程序的源代码和编译后的程序
input则为测试输入

../../../rwl/okcall.h -> HUSTOJ

后记：
C++没禁用系统调用这下舍近求远了

一些定积分的几何意义及计算

Sun, 31 Mar 2024 00:00:00 GMT

定积分#

一重积分#

∫abf(x)dx\int_{a}^{b}f(x)dx∫abf(x)dx
几何意义：曲线 f(x)f(x)f(x) 与 xxx 轴围成的曲边梯形的有向面积
物理意义：以 f(x)f(x)f(x) 为线密度函数的曲线在 [a,b][a,b][a,b] 上的质量

计算时可使用牛顿-莱布尼茨公式
∫abf(x)dx=F(b)−F(a)\int_{a}^{b}f(x)dx=F(b)-F(a)∫abf(x)dx=F(b)−F(a)
其中 F(x)F(x)F(x) 为 f(x)f(x)f(x) 的原函数，即 F′(x)=f(x)F'(x)=f(x)F′(x)=f(x)

二重积分#

∬Df(x,y)dσ\iint_{D}f(x,y)d\sigma∬Df(x,y)dσ
几何意义：曲面 f(x,y)f(x,y)f(x,y) 与 xyxyxy 平面围成的柱体的有向面积
物理意义：

以 f(x,y)f(x,y)f(x,y) 为面密度函数的平面在区域 DDD 上的质量
以 f(x,y)f(x,y)f(x,y) 为压强函数的平面在区域 DDD 上受到的压力

计算时可在平面直角坐标系中画出 DDD ，确定 xxx 和 yyy 的范围（根据实际情况选定一个量表示另一个量的范围），将二重积分化为两个嵌套的一重积分，即
∬Df(x,y)dσ=∫ab∫ϕ(x)ψ(x)f(x,y)dydx\iint_{D}f(x,y)d\sigma=\int_{a}^{b}\int_{\phi(x)}^{\psi(x)}f(x,y)dydx∬Df(x,y)dσ=∫ab∫ϕ(x)ψ(x)f(x,y)dydx
或
∬Df(x,y)dσ=∫ab∫ϕ(y)ψ(y)f(x,y)dxdy\iint_{D}f(x,y)d\sigma=\int_{a}^{b}\int_{\phi(y)}^{\psi(y)}f(x,y)dxdy∬Df(x,y)dσ=∫ab∫ϕ(y)ψ(y)f(x,y)dxdy
然后从内向外依次求解

也可以化为极坐标形式进行计算，即换元 (x,y)→(rcos⁡θ,rsin⁡θ)(x,y)\to (r\cos\theta,r\sin\theta)(x,y)→(rcosθ,rsinθ) （注意此时 dxdy→rdrdθdxdy\to \boldsymbol{r}drd\thetadxdy→rdrdθ ），在平面极坐标系中画出 DDD ，确定 rrr 和 θ\thetaθ 的范围，于是有
∬Df(x,y)dσ=∬Dg(r,θ)dσ=∫ab∫ϕ(θ)ψ(θ)g(r,θ)rdrdθ\iint_{D}f(x,y)d\sigma=\iint_{D}g(r,\theta)d\sigma=\int_{a}^{b}\int_{\phi(\theta)}^{\psi(\theta)}g(r,\theta)rdrd\theta∬Df(x,y)dσ=∬Dg(r,θ)dσ=∫ab∫ϕ(θ)ψ(θ)g(r,θ)rdrdθ

三重积分#

∭Ωf(x,y,z)\iiint_{\Omega}f(x,y,z)∭Ωf(x,y,z)
几何意义：曲体 f(x,y,z)f(x,y,z)f(x,y,z) 与 xyzxyzxyz 三维体围成的四维体的“体积”
物理意义：以 f(x,y,z)f(x,y,z)f(x,y,z) 为体密度函数的物体在 Ω\OmegaΩ 上的质量

计算方法可以类比二重积分，这里不再赘述（其实是因为我不会:-）

曲线积分#

第一类曲线积分（对弧长）#

∫Lf(x,y)ds\int_{L}f(x,y)ds∫Lf(x,y)ds
根据几何关系，有
ds=(dx)2+(dy)2ds=\sqrt{(dx)^2+(dy)^2}ds=(dx)2+(dy)2
对于一般的曲线，由参数方程 x=ϕ(t),y=ψ(t)x=\phi(t),y=\psi(t)x=ϕ(t),y=ψ(t) 给出（其中 t∈[a,b]t \in [a,b]t∈[a,b] ），则有
ds=(ϕ′(t)dt)2+(ψ′(t)dt)2=(ϕ′(t))2+(ψ′(t))2 dtds=\sqrt{(\phi'(t)dt)^2+(\psi'(t)dt)^2}=\sqrt{(\phi'(t))^2+(\psi'(t))^2}\space dtds=(ϕ′(t)dt)2+(ψ′(t)dt)2=(ϕ′(t))2+(ψ′(t))2 dt
于是可化为一般的定积分
∫Lf(x,y)ds=∫abf(ϕ(t),ψ(t))(ϕ′(t))2+(ψ′(t))2 dt\int_{L}f(x,y)ds=\int_{a}^{b}f(\phi(t),\psi(t))\sqrt{(\phi'(t))^2+(\psi'(t))^2}\space dt∫Lf(x,y)ds=∫abf(ϕ(t),ψ(t))(ϕ′(t))2+(ψ′(t))2 dt

对于由函数 y=y(x)y=y(x)y=y(x) 给出的曲线（其中 x∈[a,b]x \in [a,b]x∈[a,b] ），则有
ds=(dx)2+(dy)2=1+(dydx)2 dx=1+(y′(x))2 dxds=\sqrt{(dx)^2+(dy)^2}=\sqrt{1+(\frac{dy}{dx})^2}\space dx=\sqrt{1+(y'(x))^2}\space dxds=(dx)2+(dy)2=1+(dxdy)2 dx=1+(y′(x))2 dx
也可化为一般的定积分
∫Lf(x,y)ds=∫abf(x,y(x))1+(y′(x))2 dx\int_{L}f(x,y)ds=\int_{a}^{b}f(x,y(x))\sqrt{1+(y'(x))^2}\space dx∫Lf(x,y)ds=∫abf(x,y(x))1+(y′(x))2 dx

特别地，若令 f(x,y)=1f(x,y)=1f(x,y)=1 ，则得到弧长公式
l=∫Ldx=∫ab1+(y′(x))2 dxl=\int_{L}dx=\int_{a}^{b}\sqrt{1+(y'(x))^2}\space dxl=∫Ldx=∫ab1+(y′(x))2 dx

C++编译期计算的探索

Mon, 07 Aug 2023 00:00:00 GMT

先放个代码在这解释下次再说吧（摸了

1
#include <iostream>
2
#include <utility>
3
#include <array>
4

5
namespace compiling {
6
#define DEF_BINARY_OP(NAME, OP)\
7
    template <auto N1, auto N2>\
8
    struct NAME##_t : std::bool_constant<N1 == N2> {};\
9
    template <auto N1, auto N2>\
10
    constexpr auto NAME##_v = NAME##_t<N1, N2>::value;
11
    DEF_BINARY_OP(less_than, <)
12
    DEF_BINARY_OP(less_than_or_equals, <=)
13
    DEF_BINARY_OP(greater_than, >)
14
    DEF_BINARY_OP(greater_than_or_equals, >=)
15
    DEF_BINARY_OP(equals, ==)
16
    DEF_BINARY_OP(not_equals, !=)
17

18
    template<typename value_type, int N>
19
    struct factorial_t : std::integral_constant<value_type, N * factorial_t<value_type, N - 1>::value> {};
20
#define SPECIALIZE_FACTORIAL_T(N, V) template <typename value_type> struct factorial_t<value_type, N> : std::integral_constant<value_type, V> {};
21
    SPECIALIZE_FACTORIAL_T(0, 0)
22
    SPECIALIZE_FACTORIAL_T(1, 1)
23
    template<typename value_type, int N>
24
    constexpr auto factorial_v = factorial_t<value_type, N>::value;
25
    template<typename value_type, auto ...N>
26
    constexpr auto _gen_factorial(std::index_sequence<N...>) {
27
        return std::array<value_type, sizeof...(N)>{factorial_t<value_type, N>::value...};
28
    }
29
    template<typename value_type, int N>
30
    constexpr auto gen_factorial() {
31
        return _gen_factorial<value_type>(std::make_index_sequence<N>{});
32
    }
33

34
    template<typename value_type, int N>
35
    struct fib_t : std::integral_constant<value_type, fib_t<value_type, N - 1>::value + fib_t<value_type, N - 2>::value> {};
36
#define SPECIALIZE_FIB_T(N, V) template<typename value_type> struct fib_t<value_type, N> : std::integral_constant<value_type, V> {};
37
    SPECIALIZE_FIB_T(0, 0)
38
    SPECIALIZE_FIB_T(1, 1)
39
    SPECIALIZE_FIB_T(2, 1)
40
    template<typename value_type, int N>
41
    constexpr auto fib_v = fib_t<value_type, N>::value;
42

43
    template<typename value_type, auto ...N>
44
    constexpr auto _gen_fib(std::index_sequence<N...>) {
45
        return std::array<value_type, sizeof...(N)>{fib_t<value_type, N>::value...};
46
    }
47

48
    template<typename value_type, int N>
49
    constexpr auto gen_fib() {
50
        return _gen_fib<value_type>(std::make_index_sequence<N>{});
51
    }
52

53
    template<int N, int INDEX>
54
    struct is_prime_t {
55
        // byd不能短路求值是吧
56
        // constexpr static bool value = INDEX * INDEX > N || N % INDEX != 0 && is_prime_t<N, INDEX + 1>::value;
57
        constexpr static bool get() {
58
            if constexpr (INDEX * INDEX > N) {
59
                return true;
60
            } else {
61
                return N % INDEX != 0 && is_prime_t<N, INDEX + 1>::get();
62
            }
63
        }
64
    };
65

66
    template<int INDEX>
67
    struct is_prime_t<2, INDEX> {
68
        constexpr static bool get() {
69
            return true;
70
        }
71
    };
72

73
    template<int N>
74
    constexpr bool is_prime_v = is_prime_t<N, 2>::get();
75

76
    template<auto ...N>
77
    constexpr auto _gen_prime(std::index_sequence<N...>) {
78
        return std::array<bool, sizeof...(N)>{is_prime_t<N, 2>::get()...};
79
    }
80

81
    template<int N>
82
    constexpr auto gen_prime() {
83
        return _gen_prime(std::make_index_sequence<N>{});
84
    }
85
}
86
void compiling_test() {
87
    // ==========static test==========
88
    // 19! = 121645100408832000
89
    static_assert(compiling::gen_factorial<long long, 20>()[19] == 121645100408832000ll);
90
    // 991 is a prime
91
    static_assert(compiling::gen_prime<1000>()[991] == true);
92
    // const string concat
93
    static_assert(std::is_same_v<concat<symbol("Hello"), symbol(" "), symbol("world"), symbol("!")>, symbol("Hello world!")>);
94
}

展开收起

Powershell美化

Fri, 04 Aug 2023 00:00:00 GMT

最近看了B站的一个视频受到启发准备给电脑终端美化一下
因为我把Windows Terminal作为终端默认程序所以和窗口相关的就不用刻意美化了（本来就很好看）

安装`Oh My Posh`#

跟着官网的教程走就可以了非常简单

Terminal window

1
winget install JanDeDobbeleer.OhMyPosh -s winget

之后一定要重启一下终端来加载环境变量PATH
然后我们会发现终端开始的信息成了这样

显然是字体出了问题

安装字体#

这里推荐Nerd Fonts 这是将各种图标符号整合到常用代码字体的一个项目到下载页面选择一个喜欢的字体用就可以了（这里使用JetBrainsMono Nerd Font）
安装好后从Windows Terminal的设置页面选择刚才的字体就可以了

终端适配#

在终端中打开PROFILE文件

Terminal window

1
code $PROFILE

把下面的内容复制进去

Terminal window

1
oh-my-posh init pwsh | Invoke-Expression

然后保存

VSCode适配#

修改VSCode的settings.json中terminal.integrated.fontFamily的值为刚才的字体名称

CSharp随笔-癫疯之作

Thu, 13 Jul 2023 00:00:00 GMT

起因是写了这样一段代码

1
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
2
{
3
    string ipString = string.Join("，", e.NewItems.Cast<IWebSocketConnection>().Select(x => x.ConnectionInfo.ClientIpAddress));
4
    WeakReferenceMessenger.Default.Send<DisplayAlertMessage>(new("有新用户连接", ipString));
5
}
6
else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
7
{
8
    string ipString = string.Join("，", e.OldItems.Cast<IWebSocketConnection>().Select(x => x.ConnectionInfo.ClientIpAddress));
9
    WeakReferenceMessenger.Default.Send<DisplayAlertMessage>(new("有用户断开连接", ipString));
10
}
11
else
12
{
13
    throw new InvalidOperationException("不支持此类操作");
14
}

这里显然是可以复用一下的而我又正好想到了C#的新特性模式匹配
于是有了下面这段@#%&%%&#@%&

1
WeakReferenceMessenger.Default.Send<DisplayAlertMessage>(((Func<(string, System.Collections.IList), (string, string)>)(t => (t.Item1, string.Join("，", t.Item2.Cast<IWebSocketConnection>().Select(x => x.ConnectionInfo.ClientIpAddress)))))(e.Action switch
2
{
3
    System.Collections.Specialized.NotifyCollectionChangedAction.Add => ("有新用户连接", e.NewItems),
4
    System.Collections.Specialized.NotifyCollectionChangedAction.Remove => ("有用户断开连接", e.OldItems),
5
    _ => throw new InvalidOperationException("不支持此类操作")
6
}).ToDisplayAlertMessage());
7
internal static class ValueTupleExtensions // C#不能把Tuple展开成多个参数 :(
8
{
9
    public static DisplayAlertMessage ToDisplayAlertMessage(this ValueTuple<string, string> tuple)
10
    {
11
        return new DisplayAlertMessage(tuple.Item1, tuple.Item2);
12
    }
13
}

.NET MAUI 踩坑

Sat, 08 Jul 2023 00:00:00 GMT

时隔数月皮燕又痒了想搞搞Android开发
由于不熟悉Android Studio的操作和Java/Kotlin 所以优先选择熟悉的VS-.NET-MAUI-C#
在这里记录一些遇到的问题以便以后参考

教程#

MSDN的文档过于零散这里按照一般项目开发的顺序整理具体细节参考MSDN

在VS中创建示例项目#

略

修改App Identifier（你也不想看到com.examplecompany.appname的包名罢）#

修改.csproj文件中的ApplicationId节点
如果进行安卓开发则修改AndroidManifest.xml中的manifest节点的package属性和manifest.application节点的android:label属性为合适的值

更改应用图标#

在网上找到或制作自己的应用图标（最好是SVG格式）放到合适的目录（如Resources/AppIcon）
修改.csproj文件中的MauiIcon节点的属性其中
- Include为背景图片如Resources\AppIcon\appicon.svg [必选]
- ForegroundFile为前景图片如Resources\AppIcon\appiconfg.svg [可选]
- TintColor为前景色如White [可选]
- Color为背景色如#512BD4 [可选]
- BaseSize为标准大小如128,128 [可选]
修改开屏图片即.csproj文件中MauiSplashScreen节点的属性其中
- Include 为开屏图片如Resources\Splash\splash.svg
- Color为背景色如#512BD4 [可选]
- BaseSize为标准大小如128,128 [可选]

问题#

MAUI:错误 APT2000 系统找不到指定的文件#

原因：工作目录中含有中文
解决方案：将项目移动至不含中文字符的目录（可能引发下面一个问题）
参考自：https://www.cnblogs.com/z415353144/p/15957583.html

error APT2126: file not found#

原因：移动项目后缓存依然是原来的目录（从LOG中可以看出）
解决方案：清理、重新生成项目
参考自：https://github.com/dotnet/maui/issues/5956

更改全局appicon后安卓生成出错#

原因：没有更新AndroidManifest.xml中Application icon
解决方案：在VS中打开AndroidManifest.xml并更改Application icon的值
或编辑AndroidManifest.xml并将manifest.application节点的android:icon属性更改为合适的值（如@mipmap/appicon）

uses-sdk 19 cannot be smaller than version 21 declared in library#

原因：我也不知道为什么反正就是Android SDK版本出问题了
解决方案：更改.csproj文件中<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">19.0</SupportedOSPlatformVersion>的值为合适的值并修改AndroidManifest.xml中manifest.uses-sdk节点的android:minSdkVersion android:targetSdkVersion属性的值使之匹配.csproj文件中的值

DisplayAlert方法卡住#

原因：不到
解决方案：不要使用.Wait()

代码片段

Thu, 06 Jul 2023 00:00:00 GMT

一些-study项目中有用的代码片段

[C++]生成GUID(仅Windows下可用)#

1
#include <objbase.h>
2

3
GUID CreateGuid() {
4
    GUID guid;
5
    if (CoCreateGuid(&guid) == S_OK) {
6
        return guid;
7
    }
8
    throw exception("generate guid failed!");
9
}
10

11
string GuidToString(const GUID& guid) {
12
    char buf[64] = { 0 };
13
    snprintf(buf, sizeof(buf),
14
        "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
15
        guid.Data1, guid.Data2, guid.Data3,
16
        guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
17
        guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
18
    return string(buf);
19
}

展开收起

[C++]高斯消元#

1
#include <vector>
2
class Matrix : public std::vector<std::vector<double> > {
3
public:
4
  void Init(int row, int col) {
5
    assign(row, vector<double>());
6
    for (int i = 0; i < row; i++) {
7
      at(i).assign(col, 0);
8
    }
9
  }
10
};
11
/*要求系数矩阵可逆
12
此处A为增广矩阵，即A[i][n]为第i个方程右边的常数bi
13
运行结束后A[i][n]为第i个未知数的值 */
14
void gauss_elimination(std::vector<std::vector<double> >& A, int n) {
15
  int i, j, k, r;
16
  //消元过程
17
  for (i = 0; i < n; i++) {
18
    //选一行r并与第i行交换
19
    r = i;
20
    for (j = i + 1; j < n; j++) {
21
      if (fabs(A[j][i]) > fabs(A[r][i])) {
22
        r = j;
23
      }
24
    }
25
    if (r != i) {
26
      for (j = 0; j <= n; j++) {
27
        std::swap(A[r][j], A[i][j]);
28
      }
29
    }
30
    //与第i+1至第n行进行消元
31
    for (k = i + 1; k < n; k++) {
32
      double f = A[k][i] / A[i][i];
33
      for (j = i; j <= n; j++) {
34
        A[k][j] -= f * A[i][j];
35
      }
36
    }
37
  }
38
  //回代过程
39
  for (i = n - 1; i >= 0; i--) {
40
    for (j = i + 1; j < n; j++) {
41
      A[i][n] -= A[j][n] * A[i][j];
42
    }
43
    A[i][n] /= A[i][i];
44
  }
45
}

展开收起

[C++]多项式拟合#

1
#include <iostream>
2

3
// 高斯消元，定义在上一节
4
void gauss_elimination(std::vector<std::vector<double> >& A, int n)
5
inline bool fequal(double a, double b) {
6
  return fabs(a - b) < 1e-6;
7
}
8
void fxformatprint(std::vector<std::vector<double> > a, int n) {
9
  bool first = 1;
10
  int last = 0;
11
  std::cout << std::fixed << "f(x)=";
12
  for (int i = 0; i < n; i++) {
13
    if (fequal(a[i][n], 0)) {
14
      continue;
15
    }
16
    last = i;
17
    if (a[i][n] > 0 && !first) {
18
      std::cout << '+';
19
    }
20
    if (!fequal(a[i][n], 1)) {
21
      if (fequal(a[i][n], -1)) {
22
        std::cout << '-';
23
      }
24
      else {
25
        std::cout << a[i][n];
26
      }
27
    }
28
    if (n - (i + 1) > 1) {
29
      std::cout << "x^" << n - (i + 1);
30
    }
31
    else if (n - (i + 1) == 1) {
32
      std::cout << "x";
33
    }
34
    first = 0;
35
  }
36
  if (fequal(a[last][n], -1)) {
37
    std::cout << 1;
38
  }
39
}
40
// 仅支持{(1, a1),(2, a2),...,(n, an)}的数据
41
int main() {
42
    std::vector<std::vector<double> > a;
43
    int n;
44
  std::cin >> n;
45
    a.assign(row, vector<double>());
46
    for (int i = 0; i < row; i++) {
47
        a.at(i).assign(col, 0);
48
    }
49
  for (int i = 0; i < n; i++) {
50
    std::cin >> a[i][n];
51
  }
52
  for (int i = 0; i < n; i++) {
53
    for (int j = 0; j < n; j++) {
54
      a[i][j] = pow(i + 1, n - (j + 1));
55
    }
56
  }
57
    // 高斯消元
58
  gauss_elimination(a, n);
59
    // 多项式输出
60
  fxformatprint(a, n);
61
  return 0;
62
}

展开收起

[C++]斗地主牌型解析(?)#

1
const int CardTypeCount = 13;
2
enum CardType {
3
  Single,
4
  Double,
5
  Triple,
6
  TripleSingle,
7
  TripleDouble,
8
  Straight,
9
  DoubleStraight,
10
  TripleStraight,
11
  PlaneWithSingle,
12
  PlaneWithDouble,
13
  Bomb,
14
  SuperBomb,
15
  BombDouble,
16
};
17
std::map<std::multiset<int>, CardType> CardTypeMap{
18
  {std::multiset<int>({4}),CardType::Bomb},
19
  {std::multiset<int>({4,2}),CardType::BombDouble},
20

21
  {std::multiset<int>({3}),CardType::Triple},
22
  {std::multiset<int>({3,1}),CardType::TripleSingle},
23
  {std::multiset<int>({3,2}),CardType::TripleDouble},
24

25
  {std::multiset<int>({3,3}),CardType::TripleStraight},
26
  {std::multiset<int>({3,3,3}),CardType::TripleStraight},
27
  {std::multiset<int>({3,3,3,3}),CardType::TripleStraight},
28
  {std::multiset<int>({3,3,3,3,3}),CardType::TripleStraight},
29

30
  {std::multiset<int>({3,3,1,1}),CardType::PlaneWithSingle},
31
  {std::multiset<int>({3,3,3,1,1,1}),CardType::PlaneWithSingle},
32

33
  {std::multiset<int>({3,3,2,2}),CardType::PlaneWithDouble},
34
  {std::multiset<int>({3,3,3,2,2,2}),CardType::PlaneWithDouble},
35

36
  {std::multiset<int>({2}),CardType::Double},
37

38
  {std::multiset<int>({2,2,2}),CardType::DoubleStraight},
39
  {std::multiset<int>({2,2,2,2}),CardType::DoubleStraight},
40
  {std::multiset<int>({2,2,2,2,2}),CardType::DoubleStraight},
41
  {std::multiset<int>({2,2,2,2,2,2}),CardType::DoubleStraight},
42
  {std::multiset<int>({2,2,2,2,2,2,2}),CardType::DoubleStraight},
43
  {std::multiset<int>({2,2,2,2,2,2,2,2}),CardType::DoubleStraight},
44

45
  {std::multiset<int>({1}),CardType::Single},
46
  {std::multiset<int>({1,1}),CardType::Double},
47

48
  {std::multiset<int>({1,1,1,1,1}),CardType::Straight},
49
  {std::multiset<int>({1,1,1,1,1,1}),CardType::Straight},
50
  {std::multiset<int>({1,1,1,1,1,1,1}),CardType::Straight},
51
  {std::multiset<int>({1,1,1,1,1,1,1,1}),CardType::Straight},
52
  {std::multiset<int>({1,1,1,1,1,1,1,1,1}),CardType::Straight},
53
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
54
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
55
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
56
  {std::multiset<int>({1,1,1,1,1,1,1,1,1,1,1,1,1}),CardType::Straight},
57
};
58
class CardToken {
59
private:
60
  std::string BaseString;
61
  CardType Type;
62
  template<class T>
63
  std::multiset<std::pair<int, T>> Count(std::vector<T> v) {
64
    constexpr int tmpsize = std::numeric_limits<T>::max() - std::numeric_limits<T>::min();
65
    int tmp[tmpsize];
66
    memset(tmp, 0, sizeof(tmp));
67
    for (int i = 0; i < v.size(); i++) {
68
      tmp[v[i]]++;
69
    }
70
    std::multiset<pair<int, T>> ans;
71
    for (int i = 0; i < tmpsize; i++) {
72
      if (tmp[i] != 0) {
73
        ans.insert(pair<int, T>(tmp[i], i));
74
      }
75
    }
76
    return ans;
77
  }
78
  template<class T>
79
  CardType GetCardTypeByCountResult(std::multiset<std::pair<int, T>> CountResult) {
80
    std::multiset<int> times, cards;
81
    for (typename std::multiset<std::pair<int, T>>::const_iterator iter = CountResult.begin(); iter != CountResult.end(); iter++) {
82
      times.insert(iter->first);
83
      cards.insert(iter->second);
84
    }
85
    CardType ans = CardTypeMap[times];
86
    if (ans == CardType::Double && cards.count('S') && cards.count('L')) {
87
      ans = CardType::SuperBomb;
88
    }
89
    return ans;
90
  }
91
public:
92
  CardToken(std::string BaseString) :BaseString(BaseString) {};
93
  CardToken() { BaseString = ""; }
94

95
  CardType GetCardType()const { return Type; }
96
  void SetCardType(CardType Type) {
97
    if (Type >= CardTypeCount || Type < 0) {
98
      throw "CardType undefined!";
99
    }
100
    this->Type = Type;
101
  }
102
  std::string GetBaseString()const { return BaseString; }
103
  void SetBaseString(const std::string& BaseString) {
104
    this->BaseString = BaseString;
105
    this->Type = GetCardTypeByCountResult(Count(std::vector<char>(BaseString.begin(), BaseString.end())));
106
  }
107
};
108
//3-10(X is 10),JQK,small and large king
109
//const std::string SortedCards = "3456789XJQK12SL";

展开收起

[C++]分数类#

1
#pragma once
2
#include <sstream>
3

4
template<class Integer>
5
class FractionBase {
6
private:
7
  inline const Integer& gcd(const Integer& a, const Integer& b) {
8
    return b > 0 ? gcd(b, a % b) : a;
9
  }
10
  inline const Integer& lcm(const Integer& a, const Integer& b) {
11
    return a * b / gcd(a, b);
12
  }
13
  inline const Integer& pow(const Integer& a, int b) {
14
    Integer result = 1;
15
    for (int i = 1; i <= b; i++) {
16
      result *= a;
17
    }
18
    return result;
19
  }
20
  inline int GetDecimalLength(double a) {
21
    std::stringstream ss;
22
    ss << a - (int)a;
23
    return ss.str().length() - 2;
24
  }
25
  inline int GetDecimalLength(long double a) {
26
    std::stringstream ss;
27
    ss << a - (int)a;
28
    return ss.str().length() - 2;
29
  }
30
  inline void Simplify() {
31

32
    Integer gcdValue = gcd(numerator, denominator);
33
    numerator /= gcdValue;
34
    denominator /= gcdValue;
35
  }
36
  Integer numerator, denominator;
37
public:
38
  FractionBase(const Integer& numerator, const Integer& denominator):
39
    numerator(numerator), denominator(denominator) {
40
    Simplify();
41
  }
42
  FractionBase(double a) {
43
    (*this) = a;
44
  }
45
  FractionBase(long double a) {
46
    (*this) = a;
47
  }
48
  FractionBase(const Integer& a) {
49
    (*this) = a;
50
  }
51
  FractionBase() { }
52
  // 获取分子
53
  Integer& GetNumerator() { return numerator; }
54
  // 获取分母
55
  Integer& GetDenominator() { return denominator; }
56
  // 获取倒数
57
  inline FractionBase GetReversed() { return FractionBase(denominator, numerator); }
58

59
  void SetNumerator(Integer numerator) {
60
    this->numerator = numerator;
61
  }
62
  void SetDenominator(Integer deno) {
63
    if (deno == 0) {
64
      throw "The denominator cannot be 0!";
65
    }
66
    denominator = deno;
67
    //std::cout << denominator << ' ' << deno << std::endl;
68
  }
69

70
  FractionBase& operator=(FractionBase a) {
71
    numerator = a.numerator;
72
    denominator = a.denominator;
73
    Simplify();
74
    return *this;
75
  }
76
  FractionBase& operator=(const Integer& a) {
77
    SetNumerator(a);
78
    SetDenominator(1);
79
    Simplify();
80
    return *this;
81
  }
82
  FractionBase& operator=(double a) {
83
    int DecimalLength = GetDecimalLength(a);
84
    SetNumerator(a * pow(10, DecimalLength));
85
    SetDenominator(pow(10, DecimalLength));
86
    Simplify();
87
    return *this;
88
  }
89
  FractionBase& operator=(long double a) {
90
    int DecimalLength = GetDecimalLength(a);
91
    SetNumerator(a * pow(10, DecimalLength));
92
    SetDenominator(pow(10, DecimalLength));
93
    Simplify();
94
    return *this;
95
  }
96

97
  friend FractionBase operator+(FractionBase& a, FractionBase& b) {
98
    return FractionBase(a.GetNumerator() * b.GetDenominator() + a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
99
  }
100
  friend FractionBase operator-(FractionBase& a, FractionBase& b) {
101
    return FractionBase(a.GetNumerator() * b.GetDenominator() - a.GetDenominator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
102
  }
103
  friend FractionBase operator*(FractionBase& a, FractionBase& b) {
104
    return FractionBase(a.GetNumerator() * b.GetNumerator(), a.GetDenominator() * b.GetDenominator());
105
  }
106
  friend FractionBase operator/(FractionBase& a, FractionBase& b) {
107
    return a * b.GetReversed();
108
  }
109
  friend FractionBase& operator+=(FractionBase& a, const FractionBase& b) { return a = a + b; }
110
  friend FractionBase& operator-=(FractionBase& a, const FractionBase& b) { return a = a - b; }
111
  friend FractionBase& operator*=(FractionBase& a, const FractionBase& b) { return a = a * b; }
112
  friend FractionBase& operator/=(FractionBase& a, const FractionBase& b) { return a = a / b; }
113

114
  friend bool operator>(const FractionBase& a, const FractionBase& b) {
115
    return a.GetNumerator() * b.GetDenominator() > a.GetDenominator() * b.GetNumerator();
116
  }
117
  friend bool operator<(const FractionBase& a, const FractionBase& b) {
118
    return a.GetNumerator() * b.GetDenominator() < a.GetDenominator() * b.GetNumerator();
119
  }
120
  friend bool operator==(const FractionBase& a, const FractionBase& b) {
121
    return a.GetNumerator() == b.GetNumerator() && a.GetDenominator() == b.GetDenominator();
122
  }
123
  friend bool operator>=(const FractionBase& a, const FractionBase& b) {
124
    return a > b || a == b;
125
  }
126
  friend bool operator<=(const FractionBase& a, const FractionBase& b) {
127
    return a < b || a == b;
128
  }
129
  friend bool operator!=(const FractionBase& a, const FractionBase& b) {
130
    return !(a == b);
131
  }
132

133
  template<class T>
134
  friend std::ostream& operator<<(std::ostream& os, FractionBase<T> a);
135
  template<class T>
136
  friend std::istream& operator>>(std::istream& is, FractionBase<T>& a);
137
};
138

139
template<class Integer>
140
std::ostream& operator<<(std::ostream& os, FractionBase<Integer> a) {
141
  return os << a.GetNumerator() << '/' << a.GetDenominator();
142
}
143
template<class Integer>
144
std::istream& operator>>(std::istream& is, FractionBase<Integer>& a) {
145
  Integer numerator, denominator;
146
  is >> numerator >> denominator;
147
  a.SetNumerator(numerator);
148
  a.SetDenominator(denominator);
149
  return is;
150
}
151

152
typedef FractionBase<int> frac;

展开收起

[C++]随机数生成器类(梅森旋转法)#

从一个实际项目中抽出来的所以使用了functional

1
#pragma once
2
#include <functional>
3
#include <ctime>
4

5
class Random
6
{
7
private:
8
  int MTindex;
9
  long long MT[624];
10
  void csrand(int seed) {
11
    MTindex = 0;
12
    MT[0] = seed;
13
    for (int i = 1; i < 624; i++) {
14
      int t = 1812433253 * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i;
15
      MT[i] = t & 0xffffffff;
16
    }
17
  }
18
  inline void generate() {
19
    for (int i = 0; i < 624; i++) {
20
      long long y = (MT[i] & 0x80000000) + (MT[(i + 1) % 624] & 0x7fffffff);
21
      MT[i] = MT[(i + 397) % 624] ^ (y >> 1);
22
      if (y % 2 == 1) MT[i] ^= 2147483647;
23
    }
24
  }
25
public:
26
  std::function<int()> RandInt = [this] {
27
    if (MTindex == 0) generate();
28
    int y = MT[MTindex];
29
    y = y ^ (y >> 11);
30
    y = y ^ ((y << 7) & 1636928640);
31
    y = y ^ ((y << 15) & 1022730752);
32
    y = y ^ (y >> 18);
33
    MTindex = (MTindex + 1) % 624;
34
    return y;
35
  };
36
  std::function<int(int, int)> RandIntEx = [this](int Min, int Max) {
37
    if (Min > Max) Min = Max;
38
    if (Min == Max) return Min;
39
    else return RandInt() % (Max - Min + 1) + Min;
40
  };
41
  std::function<long long()> RandLongLong = [this] {
42
    return ((long long)(RandInt()) << 31) + RandInt();
43
  };
44
  std::function<long long(long long, long long)> RandLongLongEx = [this](long long Min, long long Max) {
45
    if (Min > Max) Min = Max;
46
    if (Min == Max) return Min;
47
    else return RandLongLong() % (Max - Min + 1) + Min;
48
  };
49
  std::function<bool()> RandBool = [this] {
50
    return RandIntEx(0, 1);
51
  };
52
  std::function<char()> RandVisibleChar = [this] {
53
    return RandIntEx(32, 126);
54
  };
55
  std::function<char()> RandUpperLetter = [this] {
56
    return RandIntEx('A', 'Z');
57
  };
58
  std::function<char()> RandLowerLetter = [this] {
59
    return RandIntEx('a', 'z');
60
  };
61
  std::function<char()> RandLetter = [this] {
62
    return RandBool() ? RandUpperLetter() : RandLowerLetter();
63
  };
64
  std::function<char()> RandFormatChar = [this] {
65
    const char fmtc[5] = { '\n','\t','\r','\v','\f' };
66
    return fmtc[RandIntEx(0, 4)];
67
  };
68
  std::function<std::string(int)> RandWord = [this](int Length) {
69
    std::string result = "";
70
    for (int i = 0; i < Length; i++) {
71
      result = result + RandLetter();
72
    }
73
    return result;
74
  };
75
  std::function<std::string(int, int, int)> RandArticle = [this](int WordSum, int WordLengthMin = 1, int WordLengthMax = 10) {
76
    std::string result;
77
    result = RandWord(RandIntEx(WordLengthMin, WordLengthMax));
78
    for (int i = 1; i < WordSum; i++) {
79
      result = result + " " + RandWord(RandIntEx(WordLengthMin, WordLengthMax));
80
    }
81
    return result;
82
  };
83

84
  Random() {
85
    csrand((int)time(NULL));
86
  }
87
  ~Random() {
88

89
  }
90
};

展开收起

C#随笔

Thu, 22 Jun 2023 00:00:00 GMT

最近写项目的时候用到这样一段代码

1
Console.WriteLine(
2
    string.Join('\n', (await api.Download(3174))
3
        .Split('\n')
4
        .Where(
5
            line => !string.IsNullOrWhiteSpace(line)
6
        )
7
    )
8
);

理想情况下中间打算写成.Where(!string.IsNullOrWhiteSpace)
但是C#好像不支持这样的运算符重载
于是写一个函数处理一下

1
public static class Functional
2
{
3
    public static Func<T, bool> Not<T>(Func<T, bool> func)
4
    {
5
        return (T para) =>
6
        {
7
            return !func(para);
8
        };
9
    }
10
}

然后就可以做到这样的效果

1
Console.WriteLine(
2
    string.Join('\n', (await api.Download(3174))
3
        .Split('\n')
4
        .Where(
5
            Functional.Not<string>(string.IsNullOrWhiteSpace)
6
        )
7
    )
8
);

PS: 不知道为什么C#推不出来泛型的类型必须手动加上<string>
ASS: 打算扩充一下Functional类做成常用库

.NET 7中System.IO.Compression的性能测试

Sat, 10 Jun 2023 00:00:00 GMT

之前我对一个字符串格式的文本文档进行了整理将其转换为了二进制文件其格式如下

field (per row)	type	size
field1	int64	8byte
field2	int64	8byte

这不仅使得体积从约16GB减小到约10GB 还大幅提升了读取和检索的速度
从在WSL1中使用cat+grep最高300MB/s的速度
提升到用C写一个简单的程序进行读取的最高约1GB/s的速度
最近为了进一步压缩体积我决定对其进行压缩

当然一切的前提是便于检索数据即可以通过流式方法读取数据
于是我决定使用GZip 一方面GZip是比较广泛的压缩格式
另一方面C#在System.IO.Compression中提供了GZipStream 便于读取
同时也可以用这个进行压缩

压缩测试#

GZipStream提供了CompressionLevel的选项包括Optimal Fastest SmallestSize和NoComression
为了选择使用哪个等级压缩我写了一个简单的基准测试来比较代码如下

1
static void Compress(CompressionLevel compressionLevel)
2
{
3
    Console.WriteLine($"input file: {rawFile}");
4
    Console.WriteLine($"output file: {gzFile}");
5
    using var inputStream = File.OpenRead(rawFile);
6
    using var outputStream = File.OpenWrite(gzFile);
7
    using var gzipStream = new GZipStream(outputStream, compressionLevel);
8
    var sw = Stopwatch.StartNew();
9
    inputStream.CopyTo(gzipStream);
10
    var seconds = sw.Elapsed.TotalSeconds;
11
    Console.WriteLine($"Time used: {seconds}s");
12
    long rawSize = new FileInfo(rawFile).Length;
13
    long compressedSize = new FileInfo(gzFile).Length;
14
    Console.WriteLine($"Compressed {rawSize} bytes to {compressedSize} bytes, compression ratio: {Math.Round((double)compressedSize / rawSize, 5) * 100}%");
15
    Console.WriteLine($"Average speed: " +
16
        $"Read: {Math.Round((double)rawSize / 1024 / 1024 / seconds, 3)}MB/s, " +
17
        $"Write: {Math.Round((double)compressedSize / 1024 / 1024 / seconds, 3)}MB/s");
18
}
19
static void Main(string[] args)
20
{
21
    foreach (var compressionLevel in Enum.GetValues<CompressionLevel>())
22
    {
23
        Console.WriteLine($"====================[{compressionLevel}]====================");
24
        Compress(compressionLevel);
25
        Console.WriteLine();
26
    }
27
}

展开收起

使用NativeAot编译后运行得到结果
测试平台:
CPU: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
RAM Size: 16GB
OS Version: Win11 22H2 22621.1778
测试结果:

1
====================[Optimal]====================
2
input file: D:\Files\裤子\qq8e.bin
3
output file: D:\Files\裤子\qq8e.gz
4
Time used: 263.0331656s
5
Compressed 11519053264 bytes to 5577536686 bytes, compression ratio: 48.42%
6
Average speed: Read: 41.764MB/s, Write: 20.222MB/s
7

8
====================[Fastest]====================
9
input file: D:\Files\裤子\qq8e.bin
10
output file: D:\Files\裤子\qq8e.gz
11
Time used: 133.5304461s
12
Compressed 11519053264 bytes to 5577536686 bytes, compression ratio: 48.42%
13
Average speed: Read: 82.269MB/s, Write: 39.835MB/s
14

15
====================[NoCompression]====================
16
input file: D:\Files\裤子\qq8e.bin
17
output file: D:\Files\裤子\qq8e.gz
18
Time used: 30.9754716s
19
Compressed 11519053264 bytes to 11520778240 bytes, compression ratio: 100.01500000000001%
20
Average speed: Read: 354.649MB/s, Write: 354.702MB/s
21

22
====================[SmallestSize]====================
23
input file: D:\Files\裤子\qq8e.bin
24
output file: D:\Files\裤子\qq8e.gz

展开收起

SmallestSize实在等不及了根据任务管理器的数据估算Read在2MB/s Write在200KB/s
照这个速度要91.55小时才能压缩完

根据数据选择Fastest即可满足需求

读取并检索#

先写一个读取原始二进制数据的代码

1
var BatchSize = Prompt.Input<int>("Please enter batch size", 65536);
2
using var inputStream = File.OpenRead(rawFile);
3
byte[] bytes = new byte[BatchSize * 16];
4
long target = 114514L;
5
var sw = Stopwatch.StartNew();
6
while (inputStream.Read(bytes) > 0)
7
{
8
    for (int i = 0; i < BatchSize; i++)
9
    {
10
        long field1 = BitConverter.ToInt64(bytes, i * 16);
11
        long field2 = BitConverter.ToInt64(bytes, i * 16 + 8);
12
        if (uid == target)
13
        {
14
            double seconds = sw.Elapsed.TotalSeconds;
15
            Console.WriteLine($"field1: {field1}, field2: {field2}");
16
            Console.WriteLine($"time used: {seconds}s");
17
            Console.WriteLine($"average speed: {Math.Round((double)inputStream.Position / 1024 / 1024 / sw.Elapsed.TotalSeconds, 3)}MB/s");
18
            goto found;
19
        }
20
    }
21
}
22
Console.WriteLine("Not found!");

展开收起

BatchSize为65536时速度达到了约1500MB/s

再看看压缩后的数据
代码差异不大只不过把FileStream改成GZipStream
可惜的是这时Read的速度只有约25MB/s 几乎不能使用
然而我又发现无论压缩时选用的ComressionLevel是什么(即使是NoCompression)
读取时速度都是这么慢可能是我代码写得有点问题但由于时间原因无法深入研究

总结#

寄

Gitee 你妈死了

Wed, 05 Apr 2023 00:00:00 GMT

就在刚才，我想把这个博客部署到Gitee Pages上
Gitee Pages pull后要手动重新部署不说它居然给我报了这个

我一看大抵又是我的名字触发违禁词了罢
有一说一这屏蔽词技术网易看了都要甘拜下风

至此 Gitee只作备份

晦气

【解决方案】Visual Studio写C/C++时没有语法高亮

Wed, 05 Apr 2023 00:00:00 GMT

最近突然用VS写了一下C，发现没有语法高亮了，非常难受，如图

解决方案如下
在 工具->选项->文本编辑器->C/C++->高级中
将禁用语义着色设为False
然后就恢复了

「RAV Endpoint Protection」我测你的码

Sat, 04 Feb 2023 00:00:00 GMT

经过#

在爬一个app的api时无意间发现了一个奇怪的东西

1
s1 = 3dd69923c5041f4259b5a81b4cd17226
2
s2 = 13cwmSwE72FR83aziyDpZxLPptygJpqcE6

当我复制s1的内容再粘贴时会变成s2的内容
剪贴板的内容也是s2
于是我很快进行了一些测试得出了这样的结论
当复制的内容中有一行文字以s1开头时复制的内容中所有的s1都会被替换为s2
写成代码是这样

1
var s1 = "3dd69923c5041f4259b5a81b4cd17226";
2
var s2 = "13cwmSwE72FR83aziyDpZxLPptygJpqcE6";
3
if (text.Split('\n').Any(line => line.StartWith(s1)))
4
{
5
    text = text.replace(s1, s2);
6
}

为了进行更多的测试我重启了电脑
这时候就没有这个问题了
当我打开QQ后这个问题又出现了于是我断定是QQ搞的鬼
但另一个我不得不注意到的是打开QQ和登录时有明显的卡顿甚至假死了一会
按理说我的电脑还没有差到这种地步（事实上性能还可以而且这是刚开机的时候）
我又联想到刚才翻Geek看程序列表时发现的一个新东西「RAV Endpoint Protection」

在进行了一些搜索之后我又断定就是这个B搞的问题
网友对于这个东西的评价是「比360还毒的流氓软件」（这个东西表面上也是一个杀毒软件）
占用很大的资源而且不好删掉
基本上都是在下载Cheat Engine和BitComet的时候被捆绑安装的
看到这里我就瞬间理解了因为我早上刚好装了新版本的BitComet
从而带来了这个东西

用一些常规手段将其删除后我又重启了电脑
这一次再也没有出现这个问题了

总结#

「RAV Endpoint Protection」傻逼
捆绑安装的流氓软件之流傻逼
一切损害用户正常使用体验的应用/厂商傻逼

博客域名迁移

Tue, 27 Dec 2022 00:00:00 GMT

今天想到vercel对Next.js的宣传，心血来潮想要把博客迁到vercel上，顺便测试一下github pages和vercel的速度感谢17ce提供的测速服务

测速结果#

使用Cloudflare CDN#

vercel#

http://www.17ce.com/site/http/20221227_5fb56cc085df11ed8cb737dbeefbfc25:1.html

github#

http://www.17ce.com/site/http/20221227_6b5e807085df11ed8cb737dbeefbfc25:1.html

不使用Cloudflare CDN#

vercel#

http://www.17ce.com/site/http/20221227_32c09b6085e211eda16def0f096a0469:1.html

github#

http://www.17ce.com/site/http/20221227_dbbca5b085e211ed8cb737dbeefbfc25:1.html

结论#

从结果可以看出，Cloudflare CDN起到了一定效果(尤其是境外地区)，但对于大陆地区没有显著效果
(不知道为什么vercel-cloudflare的结果有很多地方测不到)
最后还是决定把https://blog.truebigsand.top给vercel-cloudflare

说说域名#

truebigsand.top
在阿里云买的 top域名是综合最便宜的 9元首年之后29一年
还算承担得起准备一直续着
目前部署了一些api

已知的问题#

Github Pages似乎每次更新都会充值自定义域名

「更新」: 使用阿里云拨测 #

才发现阿里云还有这样的服务挺好用的 (截图不整了)

使用Cloudflare CDN#

vercel#

https://boce.aliyun.com/detect/http/0d0a16f20c0a4cf9b746fca110fbf573

github#

https://boce.aliyun.com/detect/http/f7cdca54674149e1bb1beaee3eec50ce

不使用Cloudflare CDN#

vercel#

https://boce.aliyun.com/detect/http/8ca769ad5bb34c85bd75a35adf02d78f

github#

https://boce.aliyun.com/detect/http/c2d4b3bf9ae14ebe912b7b9f708360c8

「更新2」#

测链接过期了阿里云果然没这么好心

imgloc图床寄了

Tue, 27 Dec 2022 00:00:00 GMT

imgloc图床寄了幸亏没把所有图片存在上面只有一个头像
看来不能相信这些小网站只能找成熟的解决方案了

关于「寄青年」

Sat, 20 Aug 2022 00:00:00 GMT

关于「寄青年」#

起因是语文课学到鲁迅的《藤野先生》
我闲着没事改编了一篇关于我们语文老师的
即《正林先生》
后来历史课学到“新文化运动的时候”
一方面平时离大谱的事很多
另一方面受到书上英雄故事的鼓舞
借此抒发愤怒之情
后来因为没时间/没兴趣/没热情就停止了

目录#

寄告青年 - 沙子
学个寄 - 沙子
鸟人日记 - 鬼鬼银鱼
短文两篇 - 沙子
家长会 - 沙子
仓鼠学生的日记 - 沙子
正林先生 - 沙子
死地 - 风起流星
日寄 - 沙子
（不是按顺序排的因为我的太多了我实在太闲了）

创作流程#

一开始是手写后来准备整成电子稿
于是周末回家打成电子稿

迁移#

目前已全部迁至本博客

PDF文件#

jiqingnian.pdf
蓝奏云

Hello world!

Sat, 20 Aug 2022 00:00:00 GMT

关于这个博客#

其实很早就想搞一个博客但是没有找到合适的平台和方法
各种虚拟主机/云服务器也捣鼓过一段时间（现在还在）
WordPress等框架也玩过
但是最终都因为钱包或者感到无聊就停了

现在因为想要contribute某个项目进群问题是个人主页然后就心血来潮整了这个博客

主要目的就是记录一些东西不然等时间一长全都忘了
以前也写过一点东西后来都找不到了
以后会不定期写点东西

鸟人日记

Sat, 20 Aug 2022 00:00:00 GMT

某Z君，今隐其名，皆余昔日在中学时良友，分隔多年，消息渐缺。日前偶闻其一大病，适归故乡，迂道往访，则仅晤一人，言病者晨瑞也。劳君远道来视，然已早愈，赴某地候补矣。因大笑，出示日记二册，谓可见当日病状，不妨献诸旧友。持归阅一过，知所患盖“鸟人”一类。语颇错杂无伦次，又多寄吧之言，亦不著月日，惟墨色字体不一，知非一时所书。间亦有略具联络者，今撮录一篇，以供组长研究。记中语误，一字不易，惟人名虽皆学校人，不为世间所知，无关大体，然亦悉易去。至于书名，则本人愈后所题，不复改也。一年十一月十一日识。

一#

今天晚上，很好的月光。
我不见他，已是两多年，今天见了，精神分外爽快。才知道以前的两年，全是发昏，然而须十分小心。不然，那十八班的狗，何以看我两眼呢？
我怕得有理。

二#

今天全没月光，我知道不妙。早上课间小心，方见博的眼色便怪：似乎怕我，似乎想害我。还有七八个人，交头接耳的议论我，张着嘴，对我笑了一笑，我便从头直冷到脚跟，晓得他们布置，都已妥当了。
我可不怕，仍旧走我的路。前面一伙小孩子，也在那议论我，眼色也同方见博一样，脸色也铁青。我想我同小孩子有什么仇，他也这样，忍不住大声说：“你寄吧谁啊！？”他们可就跑了。
我想，我同方见博有什么仇，同走廊上的人又有什么仇？只有两年以前，把正林先生的陈年作业，踹了一脚，正林先生很不高兴。方见博虽然不认识他，一定也听到风声，代抱不平，约定走廊上的人，同我作冤对。但是小孩子呢？那时候，他们还没有入学，何似今天也睁着怪眼睛，似乎怕我，似乎想害我。这真教我怕，教我纳罕且伤心。
我明白了，这是他们班主任教的！

三#

晚自习总是睡不着。凡事须得研究，才会明白。
他们——也有被老师夸过的、也有拿过奖学金的、也有进年级前十的、也有语文考九十一的，他们那时候的脸色，全没有昨天这么怕，也没有这么凶。
最奇怪的是昨天走廊上的那个老师，骂他学生，嘴里说道：“真不讨喜！”他眼睛却看着我。我吃了一惊，遮掩不住，那青面獠牙的一伙人，便都哄笑起来。Z君赶上前，硬把我拖回教室中了。
拖我回教室，教室里人都装作不认识我，他们的脸色，也全同别人一样。进了教室，便反扣上门，宛然是关了一只鸟人。这一件事，越叫我猜不出底细。
前几天，二十班的同学来告状，对Z君说，他们班里的一个大差生，给大家骂了，几个人便把他拉到考场去，让他考八门。我插了一句嘴，二十班的和Z君便都看我几眼。今天才晓得他们的眼光，全同外面的那伙人一模一样。
想起来，我从顶上直冷到脚跟。
他们拉人考试，就未必不会拉我去。
你看那老师“不讨喜”的话，和一伙青面獠牙人的笑，和前天二十班的话，明明是暗号。我看出他话中全是毒，笑中全是刀。他们文具，全整齐的排着，这就是拉人的家伙。
照我自己想，虽然不是差生，自从踹了正林的作业，可就难说了。他们似乎别有心思，我全猜不出。况且他们一翻脸，便说人是差生。我还记得Z君教我做论，无论怎样好人，翻他几句，他便打上几个圈；原谅坏人几句，他便说“翻天妙手，与众不同”。我哪里猜得到他们心思究竟怎样，况且是要拉人的时候。
凡事总的研究，才会明白。古来时常考试，我也还记得，可是不甚清楚。我翻开历史一查，这历史没有年代，歪歪斜斜的每页上都写着“双减政策”几个字。我横竖睡不着，仔细看了半夜，才从字缝里看出字来，满本都写着两个字是“考试”！
书上写着许多字，二十班的说了这许话，却都笑吟吟地睁着怪眼看我。
我也是学生，他们想要拉我去考试了！

四#

早读，我静坐了一会儿，Z君送进作业来，两页自主学本，两页课时精练。这作业，白而且薄，全是字，同那一伙出卷子的出的一样。写了几题，干巴巴的不知是试卷还是作业，便把它连图带字地撕掉。
我说：“Z君，对F君说，我闷得慌，想到走廊上走走。”Z君不答应，走了，停一会，可就来开了门。
我也不动，研究他们如何摆布我，知道他们一定不肯放松。

日寄

Sat, 20 Aug 2022 00:00:00 GMT

十一月十五日#

班主任又到班上来了。说了些无关紧要的话，大致是说让健与阿姨换回位置，免得阿姨与瑞闲谈。U盘插入电脑，我的心寄动不已，我等不及要看君主专制丑陋的嘴脸了！没有歌曲，虚晃一枪，明天才能看到了。
学校用六十万吧信息科调到今天来了。到了之后，没有开门，只得干等着。也有人学着FBI敲门，结末是吧阿姨关到了旁边。我们几个便往天台徘徊。很好的日色。刚要玩狼人插消磨时光，不知哪里来的老师害我们大费口舌一番，不过终是没有拉我们去考试，只好到别处等着。不只是班主任失责还是去处理六十万了，不过终于是来了。
对于每周一歌，我的评价是：“太假了，一群假人”。
世界是时间的函数，对于时间的每个值，都有唯一的世界状态与之对应，所以还是珍惜当下罢。
早自习，班主任又不安稳了，偏要觉得我们班的课是最难上的，课堂无人发言，寂静无声，可能是多带了两个版的缘故。可是为何其他任课老师也有同感呢？说来也怪，我们班从初一以来一直如此。思考过后，得到一个结论，我们班的支柱是中差生。这些人上课积极，声音大，可话里总要参入几句不该说的，便开始被打压。而优生呢，因为看到这些的状况，不愿与他们同流，便也沉默着，于是就成了这个状况。
“明天让你们自己选”
“这次声音可得大点”

十一月十六日#

体育课欲借球，与瑞、璟傲、银鱼等人共至器材室。入门：
“体育徐老师让我们借十二副羽毛球，两个篮球。”
“徐建明？十九班啊？”
“对”
“不要来这么多人，只有一个课代表”
只好出门，留瑞一人在内。后又想到瑞拿不动，于是回头到门口等着。这寄岂能再赶我们？没想到，高攀了属于是。
“出去！都出去！“
“？“
可怜瑞独自把那一筐搬出来。那核心价值观也不来创我们了，真是悲哀。也许是去创它了呢？
体育课后，回到教学楼，日色很好，也没有在电梯里苟活的人。饮料机纸币又停用了，寄。到得班上，专职已经开始了。不但五变成了二，实际却成了一。难道我们看不出4到5与10到11之间的空缺吗？现在看来，似乎确实，毕竟三个月的空隙也不曾觉察。
“这个好听吗？”
“这个太难了。”
“这个不错，就这个吧”
“你们先练这个吧”
“看看隔壁唱什么；他们瞎唱什么呢，我们不管“
“好好唱“ ”就这个吧“
于是，完了。我已经看到那天的情景了。好像说星期五就要唱的。
是时候把桢扬了。

十一月十七日#

还是没扬。
他们又找到新的乐趣了。中心竟是邱阳，实在不可思议——也是当然的，他只能靠这个来取得一席之地。因为那群人，他似乎也无法依靠这个了。说到底不过是一把未开锋的刀，在手上舞来舞去，无论上课下课，像仓鼠一般，也要弄出不小的声响。也有在指缝捅来捅去的，结末是将银鱼的本子变得千疮百孔，而后得到瑞合力的痛打罢。

十一月十八日（因事务繁多，本日及后日寄于二十二日写）#

时间一长，便只记得些重要的事了。
终于扬了，不过是与鸟人先生的作者换了个位置，也是很好的，至少仔细的吵闹不如从前了，不过上课也偶要冒几句话的。
然后是灯光晚会。开头倒也值六十万，还颇有电音节的意思，越往后就越无趣了，对面楼的人也仿佛要来骂一句“你寄吧谁啊“。我便和东哥找到新的乐趣了。起因是坏了的灯光棒，和东哥研究一番后竟理解了一切，也帮别人修好了。唯一的遗憾即为四个初中部的老师中没有任教我们班的罢。也无意外，毕竟都是上了年纪的。不过自从得知有网上投票后也便改变想法了。
之前还有个机会的，即一起在班上吃所谓“垃圾食品“，然后看些社死的视频罢。也是很好的，不过听人说是几个家委用大家的钱”做好事”，所以十分迷惑。

十一月十九日（写于十一月二十三日，同上）#

大概确实是我们不讨喜罢。晚自习很快便有了数学限时练习，我并不讨厌数学，但倘以这种形式，便有些不耐烦了。在这之前确有一家委进来发布通知了，大概是说周六的也要付钱了，实在也不贵，十四乘上九十六便得一千三百四十四罢了，就是这数字实在不大吉利。但后来便有班主任进来说话了：
“这不是天经地义的吗，哪有人免费给你们上课”
“再说这么便宜，有什么好叫的‘
接着便摆出了那个式子，便陆续没有声音了。
寄！忘了函数垂直乎！

十一月二十二日（写于十一月二十三日，同上）#

周末实为没有可写的事，不过是减九十六罢。
中午班主任宣布了每周一歌的不在，而将一二九定为了《黄河大合唱》之一，据说是与二十班老师商定的，具体就无从知道了。还有下午换课的事宜，为了周三的数学竞赛，早上竟还说错了的。
今天开始做操改为跑步了。寄！刚跑两步就扭到脚了，于是可以摸两天鱼了。
晚自习结束终于理解了意思，原来很简单的事，可能没有说清楚罢。

十一月二十三日#

今天没有甚么事，摸了。

十一月二十四日#

今天没有甚么事，摸了。
还是有一件事的。即班主任中午又来班上讲话了。是说入团积分的事，大略是想要的人分数不高罢——我们可不管，毕竟事他们让我们自己填的。他们也可能觉得没有办法，就按这个来了。于是便有四个人出去填了东西，其中也有我的，我不知道是幸运还是不幸。再谈谈讲话的内容，又是说我们不爱班级，没有积极向上，总之归为一条：不好。

十一月二十五日#

今天没有甚么事，摸了。

十一月二十六日#

今天没有甚么事，摸了。

十一月二十七日#

不能再这么摸下去了。还有很多要公布于世的。

十一月二十八日#

今天不知道怎么写起，摸了。

十一月二十九日#

为了唱歌的事，班主任又开始了。“没有声音”的话大概听了几十遍罢，也带着我们模仿，不过自娱自乐罢了。
他们急了。市里教育部的纪检委要到我们这里来了，却还没有确定要来我们学校，或者我们班，就已经被要求收起教辅了。

十二月七日#

很久没有写日寄了。大概事事务繁重罢，我竟没有觉察。只得凭记忆写些了。
首先是唱歌。要唱的不仅是“谢谢你”，又增加了《保卫黄河》——大概是定下来了。也不止一遍说过“花了很多钱请外面的老师”。我们已没有感觉，活成了木偶。不过外面的老师还是不错的，引用一句是“很有精神”，于是便跟着唱了，毕竟九日就要每周一歌，二十二日便要大合唱了。

十二月十日#

昨晚的会议实在无趣，实际大约是浪费了一小时。不过班主任竟能把整个英语组都忽悠成这首歌，也是很惊人的。
外面的老师总归是要更好一点的，已经第二次来了，不过原来八次排练因为时间只剩下三四次了，毕竟不能动了那些课。
前两天说要买的监控到了。我一向很反对再班上装监控，为了那几个人何必坏了全班的信任呢？说的远些，这与监控又有何区别呢？不过终于不能说出。“鸟以为把鱼举在空中是一种慈善的举动。”这是来自泰戈尔的飞鸟集里的。那时尚且知道这个道理，现在怎么又迷惑了呢？好在和我先前的想法一样，不会装的。但总会有办法的，毕竟上午就被问了会不会装。我当然是不会的。
周六又要上课了，也就上面检查的那周休了一次而已，毕竟我们可是被自愿签了保证书的。不过相比初三的整天，高中的周日还有半天还是好的。自从双减之后就一直如此了，最近听到党员领导要带头生三胎，也不知道是哪位贵人一时兴起想来的。这些本是不好说的，毕竟“对未来充满信心”已经在教种书上，成为政治义务了罢。

十二月十三日#

今天，很好的月光，不知那三十多万人能否欣赏到呢？正好今天历史课学到此课，使我于是又重温了这一段历史。我翻开历史书一看，这历史没有好坏，我横竖听不进，看了半天才看出，这历史书满本都歪歪斜斜写着三个字：“小日本”，使我们又惊呼：“********小日本！”

十二月十四日#

监控终于是装上了。班主任不用到教室来就能监视我们了，只有我们受伤的世界完成了。我至今没有明白这初心是什么，是为了帮助自己还是监督我们。我的理智控制着我不去拿点什么水杯之类的东西砸它，但我还是托人明天带个镜子和我的凸透镜一起用了。唉，我不知何时才能与它不见！
还有一件事，即周六下面上课的事。最后一节的物理课，西西于是就坐到我们当中来了。钱看到自然要骂，并且把西西拎到前排去了，但转过头来便说我们不讨喜，随意换座位，并且下节课一定要我们分开。
到了周一，班主任也知道了这件事，原因是钱私发了消息说：“十九班的男生上课不能静下来，提醒十九班的九个同学注意纪律”这句话不知怎的竟被理解成了我们几个男生丢了全班的脸了，我很是疑惑：换座位的西西和那些女生，和我们有什么关系？但总归是喜提钱和班主任两顿痛骂。

十二月十六日#

班主任曾说的“全年级一半的班装了监控”似乎也被提上日程了，毕竟已经向地理老师推销成功，并且在十七班启用了。看来需要和十七班交流并联合了。
下午的评教，便使我回想起一些事了：
“你们这个班比较好，我以前带的班胆子肥，把老师多布置的作业和批评都记着，并且想：‘你等着，看我到评教怎么写你’。所以每次评教前我都要正儿八经地给他们上一节班会。其实这不是假，老师这么做的原因你们都不理解，也没有资格评价老师教得怎么样，只能是喜欢或不喜欢罢了。“
既然如此，那评教的意义不也就是假了吗？而且我并不觉得我们不能评价老师，毕竟我们也上了近十年的学了，可能比有的老师的教龄还要长，没吃过猪肉还没见过猪跑吗？鸣呼，无法可想！
我仿佛又听见物理老师的评价了：演员。

“老大郭在看着你。 Big Mrs. Guo is watching you.” ——鬼鬼银鱼《体面的自由》

十二月十七日#

今天，很冷的天气。
音乐课和平时一样，并没有什么特殊。
下午还是有些奇怪的。首先是前两节课被拿去保卫黄河，并且使瑞成了工具人，使东哥社死了罢。后两节课因为老师有活动所以自习，做了一张物理练习，这并使我装到了。即摸了一下午罢。
在初一后面的高尔夫馆建好了，不过是一个罩子，美其名曰“馆”，并大肆宣扬，凡是通往那里的路都要贴上告示，听说是可以选修的，不过班上也没有动静。
明天被参加了金钥匙，好像是类似那种题库的比赛，都是些离谱的题，不过也因此不用周六到学校来了。物理学本作业总要等到周六再发，于是我便无法拿到了，马上就要英语练习了，便是瑞成为工具人的原因。

一月十日#

已经有很久没有写日寄了，也有得很想写的的候，不过事情一多便忘却了。前日生了一场大病，有一个星期，也因此拖延了事务。大概是还有些不顺罢，拿起笔却无从下手，明后日就是期末考试，不便多言，就先写这些罢。

死地

Sat, 20 Aug 2022 00:00:00 GMT

死地 ——为璟傲而作
张璟傲已死了！寄！
——煎炸着的那万米的寄吧
是他的尸体

他死在冲的时候；
旧终时
依然睁着枯干的眼
巴望手机里
出现一个金光……

没有金光
甚至保底也没有

看见的到处是：
像被火烧过的
焦黑的试卷
与枯黄的寄吧
与到处用过的废纸

那些寄吧¹呢？
那些曾用大眼
偷看试卷的伞兵呢？
一切都晚了！

几千万的“讨喜²之子”
从语文到数学，
从数学到英语，
寻找着，寻找着
一个答案，
再抄些吧……

向着天
千万人一齐大呼
寄！什么牛马³试卷乎！

但是，
没有改变！

千万的“不讨喜之子”
从生物到地理
从政治到历史
找不到答案
找不到希望
疲乏地扶着头……

哪儿去了？
——那些每年背了试卷的大包
来卷⁴
我们留在柜中的
最后的试卷到哪儿去了？

还有那些
在卷时带走了
我物理笔记本的人呢？

班上不再有伞兵的“狼人插⁵”
晚自习⁶也不再发出笑声了
到处是璟傲的叹息
与知非的哀嚎
你再卷？！

于是他们——千万的“数学代师”
拿出无数的试卷
像冬天林木般的用完之笔芯
向死亡般的试卷
挖掘分数

于是他们
相继地倒毙了
——像寄
像伞兵
在牛马的智学网
在充满“寄”声的数学课

从死亡的期中
到死亡的期末
你知道
那开挂般的“大陀螺⁷”
旋转着的
到底渴望着什么呢？

我说
如有人点燃了内卷之火啊……
寄乎哀哉

璟傲先生不再冲了
他开始在地府中卷起了数学

寄！这吃人的试卷！

注#

Footnotes#

寄吧，原指牛子，这里用作引申义，指伞兵般的人。 ↩
讨喜，讨喜欢的孩子，尤为老师所赞赏。 ↩
牛马，与伞兵成近义词，较为委婉。 ↩
卷，指内部竞争。 ↩
狼人插，一种古老的游戏，以杀光平民为赢，多在12人一组。 ↩
晚自习，此处原文为晚自己，为作者笔误。 ↩
大陀螺，用指CSGO中开挂玩家，这里比作大聪明 ↩

学个寄

Sat, 20 Aug 2022 00:00:00 GMT

当今学涯，可谓是个寄吧。血海无涯，难道要一直寄下去吗？人民从一生下来到二十多岁，做了小半辈子工，学也练也，不过是纸糊的老虎，都是虚有其表……
其时听到一个看法：“学习不过是为了分层，知识仅为附属品罢了”，我是不相信的。既有老师教导：“学习是为了自己，现在辛苦是为了以后幸福”，也听到过“你们不学没人逼你们“，而后又强迫学生默写的。
学校里时常听到“我是寄吧“，又是为何呢？不过是瑞的语文到了年级第一，而自己还在几百名开外罢。（所谓瑞，即有一篇《瑞转》，还可以看看的）其大多因为不合理二出现，而剩下的，也无从知晓罢。下举几例，皆为不合理之处。
期初赴乐韵课，立于走廊，既言：“女进，男静则进“。立于教室，又言：“女坐，男静则坐”。坐毕，师抚琴，错音，皆乐，怒言：“会否？不会则静！”即会，不敢言，只好作罢。课半，众言，师曰：“何以如此放肆！”众静，又曰：“何以无声！”众怒，或言或否。课毕，众怒而奔，惊呼：“寄！”
某日体育课，借三球，一球予健，一球予博，一球予众。博，球人也，娱球强甚。众不说，不与博娱。博孤，遂将球予健。健者，贱也，长居榜尾，大不周正。另班求球于健，健曰：“善”。众觉，大怒，怒言：“寄！”

正林先生

Sat, 20 Aug 2022 00:00:00 GMT

初中部也无非是这样。校园的樱花烂漫的时节，望去确也像绯红的轻云，但花下也缺不了三两成群的“国际高中部”的狗男女，[数据删除]，实在标致极了。
初二年级的走廊里有几本书看，有时还值得去一转；倘在上课，里面的几个沙发倒也还可以坐坐的。但到课间，有几层的地板便长不免要咚咚咚地响得震天，兼以满楼振聋发聩。问问精通时事的人，答道，“那是在数手指”。
到别的地方去看看，如何呢？
我就往五楼的十九班去。从楼底出发，不久便到一处屋舍，写道：初二语文组。不知怎地，我到现在还记得这名目。其次却只记得英语了，这是苏联的遗民鬼鬼银鱼先生客死的地方。十九班是一个教室，并不大，冬天暖的厉害，还没有别班的学生。
大概是人以喜为贵罢。讨喜的孩子，运往四楼，便用金丝玉锦缀着，裱在英语组前，尊为“讨喜的孩子什么都好”；苏州野生的东哥，一到十九班就请进教室前，且美其名曰“进步快”。我到十九班也颇受了这样的优待，不但班主任法不责众，几个职员还为我的食宿操心。我先是住在食堂旁边的一个草屋里的，初冬已经颇冷，蚊子却还多，后来用被盖了全身，用衣服包了头脸，只留两个鼻孔出气。在这呼吸不息的地方，蚊子也见缝插针，居然睡不安稳。饭食也不坏。但一位先生却以为这客店也包办校长的饭食，我住在那里不相宜，几次三番，几次三番地说。我虽然觉得客店兼办校长的饭食和我不相干，然而好意难却，也只得别寻相宜的住处了。
从此就看见许多陌生的先生，听到许多新鲜的讲义。
语文是一个教授独任的。其时进来的是一个黑壮的先生，没有须，戴着眼镜，挟着一叠大大小小的书。一将书放在讲台上，便用了缓慢而很有顿挫的声调向学生介绍自己到：
“我就是叫做正林的……”
后面有几个人笑起来了。他接着便讲述语文在中考发达的历史，那些大大小小的书，便是从最初到现今关于这一门学问的著作。起初有几本是线装的；还有翻刻外国译本的，他们的翻译和研究新的文学，并不比中国早。
那坐在后面发笑的是同组的人，在校已经一年，掌故颇为熟悉的了。他们便给新生讲演每个教授的历史。这正林先生，据说是有了孙子太高兴了，有时竟会忘了上课；冬天是一件旧外套，寒颤颤的，有一回上语文组去，致使别的老师疑心他是扒手，叫组里的老师，大家小心些。
他们的话大概是真的，我就亲见他有一次上讲堂谈起自己的孙子。
过了一星期，大约是星期日，他便让同学叫来叫我了。到得他家，见他在坐在书和许多单独的讲义中，——他其时正在研究着文学，后来有一篇致辞在本校的典礼上发表出来。
“我的讲义，你能抄下来吗？”他问。
“可以抄一点。”
“拿来我看！”
我交出所抄的讲义，他收下了，当天便还我，并且说此后每一星期要送给他看一回。我拿下来打开看时，很吃了一惊，同时也感到一种不安和感激。原来我的讲义已经从头到末，都用红笔添改过了，不但增加了许多脱漏的地方，连翻译的错误也都一一订正。这样一直继续到教完了他所担任的功课：现代文、古文、历史。
可惜我那时太不用功，有时也很任性。还记得有一回正林先生将我叫到他家去，翻出我那讲义上的一道题来，是宋朝的古文，指着，向我和蔼的说道：
“你看，你将这句话翻译错了一点了。——自然，这样翻译，的确比较通顺些，然而翻译不是写作，原文是那么样的，我们没法改换它。现在我给你改好了，以后你要全照着黑板上的那样写。”
但我还是不服气，口头答应着，心里却想道：
“心里却想道：“翻译还是我写的不错；至于正确的译文，我心里自然记得的。”
学年试验完毕之后，我便在南京玩了一夏天，秋初再回学校，成绩早已发表了，同学八百余人中，我在前列，不过是没有星光。这回正林先生所担任的功课，还是语文和历史。语文学习了大概一星期，他又叫我去了，很高兴地，仍用了极有抑扬的声调对我说道：
“我因为听说十九班只会学习，所以很担心，怕你不肯报名体育会，现在总算放心了，没有这回事。”
但他也偶有使我很为难的时候。他听说十九班的老师是独裁的，但不知道详细，所以要问我怎么裁法，学生变成怎样的听话，还叹息道：“总要看一看才知道，究竟是怎么一回事呢？”
有一天，本级的自管会干事到我班里来了，要借班上的体育成绩看。我检出来交给他们，却只翻检了一通，并没有带走。但他们一走，别班学生就送到一封很厚的信，拆开看时，第一句是：
“你改悔罢！”
这是《新约》里的句子罢，但经托尔斯泰新近引用过的。其时正值日俄战争，托老先生写了一封给俄国和日本皇帝的信，开首便是这一句。日本报纸上很斥责他的不逊，爱国青年也愤然，然而暗地里却早受了他的影响了。其次的话，大略是说上年运动会的成绩，是建明先生在记分册上做了手脚，改动了成绩，所以能有这样的奖项。末尾是匿名。
我这才回忆到前几天的一件事。因为要开同级会，干事便在公告上写广告，末一句是：“请全数到会勿添足”，而且在“添”字旁边加了一个加。我当时虽然觉到加的可笑，但是毫不介意，这回才悟出那字也在讥讽我们了，犹言我们得了教员特别的优待。
我便将这事告诉了正林先生；有几个我班的同学也很不平，一同去诘责干事托辞检查的无礼，并且要求他们将检查的结果，发表出来。终于这流言消灭了，干事却又竭力运动，要收回那一封匿名信去。结末是我们便将这托尔斯泰式的信退还了他们。
十九班学习好，所以十九班人自然只会学习，运动会得奖项，便不是自己的能力了：也无怪他们疑惑。但我接着便有参观十九班窝里斗的命运了。第二年颁奖，舞台的背景是全用电影来显示的，一段落已完而还没有到结束的时候，便影几片时事的片子，自然都是中国战胜日本的情景，但偏有章文轩夹在里边给，俄国人做侦探，被日本军捕获，要枪毙了，围着看的也是一群中国人；在讲堂里的还有一个我。
“万岁！”他们都拍掌欢呼起来。
这种欢呼，是每看一片都有的。但在我，这一声却特别听得刺耳。此后回到十九班来，我看见那些闲看批斗英雄的人们，他们也何尝不酒醉似的喝彩，——呜呼，无法可想！但在那时那地，我的意见却变化了。
到第二学年的终结，我便去寻正林先生，告诉他我将不学文学，并且不来这语文组。他的脸色仿佛有些悲哀，似乎想说话，但竟没有说。
“我想去学尻♁股学，先生教给我的知识，也还有用的。”其实我并没有决意要学尻♁股学，因为看得他有些凄然，便说了一个慰安他的谎话。
“为文学而焦的股♁文，怕于尻♁股学也没有什么大帮助。”他叹息说。
将走的前几分，他叫我到语文组去，交给我一张他和孙子的照相，后面写着两个字道：“惜别”，他叫我到语文组去交给我一张他和孙子的照相后面写着两个字道：“惜别”，还说希望将我的也送他。但我这时适值没有照相了；他便叮嘱我将来照了寄给他，并且时时通信告诉他此后的状况。
我离开语文组后，就多日没有照过相，又因为状况也无聊，说起来无非使他失望，连信也怕敢写了。经过的时日一多，话更无从说起，所以虽然有时想写信，却又难以下笔，这样的一直到现在，竟没有寄过一封信和一张照片。从他那一面看起来，是一去之后，杳无音信了。
但不知怎的，我总还时时记起他，在我所认为我师的之中，他是最使我感激，最给我鼓励的一个。有时我常常想，他的对于我的热心的希望，不倦的教诲，小而言之，是为十九班，就是希望十九班的成绩提高；大而言之，是为学术，就是希望新的语文传到19班去。他的性格，在我的眼里和心里是伟大的，虽然他的姓名并不为许多人知道。
他所改正的讲义，我曾订成三厚本，收藏着的，将作为永久的纪念。不幸七日前迁组的时候，中途被劫了一口书箱，失去半箱书，恰巧这讲义也遗失在内了。责成那帮人去找寻，寂无回信。只有他的照相，至今还挂在十九班的伟人墙上，讲台对面，每当夜间疲倦，正想偷懒时，仰面在灯光中瞥见他黑壮的面貌，似乎正要捧腹大笑起来，使我忽又良心发现，而且增加勇气了；于是斟上一杯水，再继续写些为“正人君子”之流所深恶痛疾的文字。
十月十八日

寄告青年

Sat, 20 Aug 2022 00:00:00 GMT

寄告青年#

当今社会，有许多不合理之处，令我们常不免要感慨一句，“这合理吗！”青年总是追求合理的，而不合理，总会逐渐让人觉得他是合理的。难道我们真要等到不合理成为合理，而原先的合理早已无人知晓吗？于是便有了这篇文章和本刊：“寄”即为“致”，“给”，而另有别意为感叹语，即昭示着不合理。希望有志之学子联合起来。即使无法消除，也要时刻提醒人们，不合理不合理，切忌成为合理。
十一月十一日。

短文两篇

Sat, 20 Aug 2022 00:00:00 GMT

家长会#

呜呼，无法可想！我实在无法理解这家长会究竟是怎样的一件事。
开头几位老师的讲话还算正常，基本做了一些总结，然后是未来与要求。从班主任开始就有些奇怪了。首先是期中成绩的汇报——都是老生常谈了，接着是班级情况的汇报，便由班长和课代表来讲了。既由同学汇报，结果也就不得而知了。纪律方面提到四个组，也有我们组的，但被班主任略了去，不知是故意还是无意，剩下两个组不知有何技巧，没有被提到。
语文课代表的汇报也如同预料，用词比较委婉，基本是些空话，但大家自己都能补全了的。接下来的数学便要有鸟人先生来汇报了。刚上台就被质问“怎么又是你”，就言出了我不愿上台，却又被接着问“为什么”，也便无言以对了。然后预定了下次由我上台。内容也都是些无关紧要的了。
课代表的汇报之后，又由班主任接管了。是不是也要点到些人。讲到某一刻，脸上突然好像流露出极其厌恶的神情，大概事看到“手机”二字罢。也要求要严控，课为何周末往往又有听力作业呢？
既然说到手机，就不免要提到游戏了。这二字仿佛洪水猛兽，使人还没听到就要发慌，躲得越远越好。我已提前预判到那九人的被点名，可没想到，竟一转攻势，把我们组点了遍，从老六到瑞，一个不差。我还没弄清楚她对游戏的定义，就也被列入其中了。我无法想到两个字竟会有如此大的杀伤力，使一切跟好沾边的，都是它的相反数。难道学生经历了一周朝六晚十，周末还奔波在各个辅导班，沉浸在各科额外的作业中，就这么忙里偷闲地花一个小时，或是仅仅半个小时来放松一下都成了犯罪吗？怎么就成了一些人口中的不思进取，自甘堕落呢？
于是便这么匆匆结束了。学生低着头，梦游似的走出校门，家长伸长脖子，忙于看自己或他人的成绩，老师则忙于各种阿谀奉承中。于是，完了。现在回想起来，仍觉得背后发凉，好像有什么盯着自己，使人不敢多想。

仓鼠学生的日记#

9月1日，星期天#

今天是我的纪念日。可没人注意到这一点。一年了。一年前的今天，他们把我从“小学”“摇”上来。

9月7日，星期二#

我决定永远不碰作业。

9月9日，星期日#

我决定还是写作业吧，但只在晚上写，晚上他们都睡了。我在教室里，写呀，划呀，修呀，总之要弄出声音烦他们，让他们知道我可不玩那些小把戏，要是我卷点儿什么，那都是为他们，绝非为我自己。

9月12日，星期一#

为什么存在？

9月20日，星期三#

他们俩今天都来了，把我从教室里拽出来，放进一个用作业和试卷搭建起来的近似于迷宫的东西里面。一座没有出口的迷宫。他们把这当作油田，想要从中榨取些什么。看着我在死胡同里转来转去，他们笑呀，叫呀。但我知道，这不是油田。他们试图击溃我的意志，压迫我，折磨我。他们可以拿走我的人身自由，但他们永远无法夺走我的灵魂。
我叫沙子，我是个寄吧。

9月22日，星期六#

在这里，我有我所需要的一切，我没有理由不开心。

9月24日，星期三#

对于作业的评价：
它在燃烧。
它张牙舞爪。
它要将我吞没。
我不该再写作业了。

9月26日，星期五#

写作业。
上课。喝水。

9月27日，星期六#

今天我先上了一节课，又喝了一些水。

9月30日，星期二#

作业上课水
作业上课水
就没点儿别的了吗？
我要借此机会表明自己的立场，为自己以及所有受压迫者们的权利；杀一杀那些冷酷无情的教育家的嚣张气焰。
我打算从现在开始不写作业，不听不学直到自由……或者说直到死。

下午2:33#

不写作业两分钟了。我意志坚定。

下午2:36#

不写作业五分钟了。我开始感到心慌。

下午2:41#

作业。他们在嘲笑我。

下午2:45#

我的智商下降了一点，没准儿更多，

下午2:47#

今天的牺牲已经够大了，就到此为止吧，一只智障学生对抵抗运动来说有什么用？所以我写了50页作业，喝饱水。

下午2:48#

手废了！手废了！内卷之神就那么瞪着我。

下午4:00#

从轻度内卷过度中恢复过来。真是漫长的一天啊。

…………

11月6日，星期四#

我多日的祈祷终于有了回应：学校的门开了。今夜，我将踏上一段完全未知的旅途。

【解决方案】关闭Visual Studio后仍有PerfWatson2.exe占用文件夹

Sat, 20 Aug 2022 00:00:00 GMT

经常有关闭Visual Studio后删除代码文件夹时提示文件夹被占用
用火绒查一下发现是被PerfWatson2.exe占用了
关掉也没事了
最近发生的概率提高了很多
我就上网搜有没有相同的问题
果然搜到一堆比如这个
http://www.zhushiyao.com/?p=84473
又是“体验改善计划” 太典了
在中国由于众所周知的原因这种东西很多都访问不到
于是就被阻塞在后台了