有时候我还真不明白，为什么现在大家把AI吹得那么牛逼。因为就是我的使用体验而言，我觉得在写代码的时候，AI真的是挺糟糕的.我用的AI是Deepseek。

理论上无论我用的是什么AI，它们都应该是写代码的高手，无论是写什么类型的代码都应该没什么问题。我这么低端的用户，也不会提出一些什么高端的要求，但事实证明，不知道是我提要求提的不够精准还是怎么着，反正出来的结果我个人感觉基本上没有一次就能符合我的要求。有些时候的确能接近生成我想要的结果，但更多时候那串代码当你复制下来运行的时候会发现根本运行不了。对一个什么都不知道的小白在代码运行不了的时候可以怎么办呢？换一个AI继续提问继续复制粘贴？但如果这个AI有问题，其它AI会不会也有问题呢？为什么人家觉得那个玩意那么神奇，但我自己的使用体验却那么差呢？是不是因为AI已经判断出我这个人是个挑剔的完美主义者，所以故意给我些有瑕疵的东西？每一次都有瑕疵，每一次的瑕疵都说不准在什么地方，幸好绝大多数情况之下，我要的不是AI的全过程，我只是要参考一下它的思路而已。当我要求它给我写某个代码的时候，实际上我更看重的是它用什么途径，而不是它的代码具体是什么。如果它的代码能顺利运行，那当然好，但实际上我感觉一次性就能成功运行的几率可能不足10%。

当我给出一串数字，要求它给我做数据分析。噼里啪啦一大段字很牛逼，一贴进去发现根本出不了结果，仔细看Python的那些错误代码，原来一开始那个屌丝把原始数据都给我整没了一些，因为长度不对，所以整不出结果。我要用Excel的公式实现某些功能，的确噼里啪啦有好多个方案。有些方案一看就直接可以忽略，因为又长又臭，另外一些我感觉有些希望的却发现到Excel里面同样也是出不了结果。至于为什么我也不去纠结了，我直接去研究这些方法的思路到底是什么。我让它用Power Query，也就是M语言给我实现某个功能，结果发现把那堆代码贴到高级编辑器，甚至都无法按确定提交，因为显示语法错误。那个编辑器是一个神经的存在，说语法错误，但定位的那个点实际上没有问题，但那个问题到底在哪里，你得人肉上下文去找。我使用的通常是对半检索法，首先留一半，然后一半的一半。理论上是这么找的，但实际上后面某些功能不要我觉得都无所谓，所以我只要找到那些我需要的就可以了。最终发现，某个用了函数的地方，理论上应该是“=>”。DS给我的代码是“->”。如果这份代码是由图片识别过来的，出现这种等号变成减号，我觉得可以理解，但显然这种事情怎么可能发生？！对一个什么都不懂的人来说，你叫他怎么可能人肉找得出这样的低级错误呢？！那个代码除了那个等号变成了减号以外，最后的结果还有一些无厘头的数据合并，那些数据在前面几个步骤里面已经不复存在了，在最后那个步骤又突然间被提起，真牛逼！

在这种情况下，说AI可以取代人类完成编程，我觉得起码暂时是不行的，尤其是要实现一些高度定制的功能的时候。

USACO（美国计算机奥林匹克竞赛）是全球最具影响力的信息学竞赛之一，其题库和真题资源是每位信竞选手必备的训练宝库。无论你是准备USACO月赛，还是备战NOI/NOIP，掌握USACO资源的使用方法都至关重要。

中国计算机学会（CCF）推出的GESP编程能力等级认证是为青少年量身打造的编程能力评估体系，覆盖图形化、Python和C++三大编程语言，分为1-8级（C++/Python）和1-4级（图形化）。本文主要梳理GESP的考试安排、跳级机制及与信息学奥赛的衔接政策，并详细解读C++ 1-8级的考核标准与能力要求。

CSP 初赛告一段落，复赛即将来袭！ NOI Linux 2.0作为NOI系列比赛和CSP-J/S等比赛必备的系统，了解和熟悉相关操作是赛前必备技能。目前正处于系统更换的过渡期，大家一定要注意自己省份使用哪个版本，提前熟悉、提前下载，了解操作环境，更好地应对比赛中出现的一些状况！

之前分享过《教育部2025-2028学年全国性竞赛活动最新白名单解读》，但由于部分比赛项目是新加入进来的，一时半会不知道怎么了解其具体信息及报名通道，于是在网上搜集了一些，建议大家根据兴趣和特长选择适合的赛事，并密切关注官方通知，避免错过报名和参赛时间。本文相关信息仅供大家参考，具体以官方信息为准，请大家仔细甄别。

使用原子 TAS 指令实现自旋锁

使用原子 TAS 指令实现自旋锁 Implementing a Spinlock Using the Atomic TAS Instruction 从零实现自旋锁：基于 TAS 的最小同步原语 Building a Spinlock from Scratch with Atomic TAS 用 test-and-set 实现最简单的互斥锁 Implementing a Minimal Mutex Using Test-and-Set 自旋锁的底层原理：TAS、原子性与忙等待 Inside Spinlocks: TAS, Atomicity, and Busy Waiting 原子操作与自旋锁：用 C 语言实现线程同步 Atomic Operations and Spinlocks: Thread Synchronization in C 从原子指令到锁：全面理解 TAS 和自旋锁 From Atomic Instructions to Locks: A Complete Guide to TAS and Spinlocks 动手写一个自旋锁：tryLock / lockAcquire / lockRelease 全实现 Hands-On Spinlock Implementation: tryLock, lockAcquire, and lockRelease 你的第一个自旋锁：基于 C 语言的 TAS 实现 Your First Spinlock: A TAS-Based Implementation in C 原子交换与线程互斥：自旋锁实现指南 Atomic Exchange and Thread Mutual Exclusion: A Guide to Implementing Spinlocks

int TAS(int* memory, int newVal) {
    int old = *memory;
    *memory = newVal;
    return old;
}

• lockAcquire()
• lockRelease()

typedef struct {
    int lock;
} lockType;

typedef struct {
    int val;
} threadArgType;

void threadFunc(void* arg) {
    lockAcquire((static_cast<lockType*>arg)->lock);
    (static_cast<threadArgType*>arg)->val++;
    lockRelease((static_cast<lockType*>arg)->lock);
}

实现 tryLock

enum {
    UNLOCKED = 0,
    LOCKED = 1
}

int tryLock(lockType* lock) {
    // 如果之前已锁定返回 1，如果之前未锁定返回 0
    int old = TAS(lock->lock, LOCKED);
    return (old == UNLOCKED);   // true (1) = 成功获取锁
}

实现 lockAcquire()

void lockAcquire(lockType* lock) {
    while (!tryLock(lockType* lock)) {
        // 自旋直到锁可用
    }
}

void lockAcquire(lockType* lock) {
    do {
       if (tryLock(lockType* lock)) {
          break;
       }
    } while (1);
}

void lockAcquire(lockType* lock) {
    do {
       int old = TAS(lock->lock, LOCKED);
       // 无论锁是否已被获取，锁都已设置为 LOCKED
       if (old == UNLOCKED) {
           break;
       }
    } while (1);
}

实现 lockRelease()

void lockRelease(lockType* lock) {
    TAS(lock->lock, UNLOCKED);
}

总结

• 一个 tryLock() 尝试
• 一个 lockAcquire() 自旋锁
• 一个 lockRelease() 解锁操作

理解 Sigma 函数：因子、乘法性与公式推导

一文看懂 Sigma 函数：因子分解的终极威力！ σ(n) 完全解析：为什么求和函数能“自动”变成乘积？ 数学之美：Sigma 函数的推导、公式与 Python 实现 从几何级数到质因数：Sigma 函数的魔法公式大揭秘 搞懂 σ(n) 的那一天，我看到了数学的秩序 为什么 σ(n) = 乘积？带你走进数论的核心思想 Divisor 终极指南：Sigma 函数推导 + 代码 一篇搞定

可除性符号

质因数分解与因子的结构

关键性质：Sigma 函数是乘法性的

质数幂的 Sigma 公式

示例：计算 σ(12)

Python 实现：高效的 Sigma 函数

def sigma(n: int) -> int:
    """高效计算因子和函数 σ(n)。"""
    total = 1
    x = n

    # 处理质因数 2
    count = 0
    while x % 2 == 0:
        x //= 2
        count += 1
    if count > 0:
        total *= (2 ** (count + 1) - 1) // (2 - 1)

    # 处理奇质数
    p = 3
    while p * p <= x:
        if x % p == 0:
            count = 0
            while x % p == 0:
                x //= p
                count += 1
            total *= (p ** (count + 1) - 1) // (p - 1)
        p += 2

    # 若剩下的是质数
    if x > 1:
        total *= (x**2 - 1) // (x - 1)

    return total

结语

C++ 一直在不断增加新特性，以便程序员能够区分在编译时运行的代码和在运行时执行的代码。其中两个重要工具是函数 std::is_constant_evaluated()（C++20）和语言级别的 if consteval（C++23）。本文将解释这两者，展示实际示例，比较它们的保证和权衡，并建议在何时使用各自的方法。 这两种技术都允许你编写分支，根据当前的求值是在常量求值（编译时）上下文中还是运行时上下文中而表现不同。差异虽然细微，但非常重要：一个是返回布尔值的函数，另一个是编译器视为仅在编译时检查的特殊 if 语句，编译器会进行特殊处理。

std::is_constant_evaluated() (C++20)

#include <type_traits>
constexpr bool std::is_constant_evaluated() noexcept;

#include <iostream>
#include <type_traits>

constexpr int f() {
    if (std::is_constant_evaluated()) {
        return 42; // 编译时
    } else {
        return 0; // 运行时 
    }
}

int main() {
constexpr int a = f(); // 编译时求值 -> 42
    int b = f(); // 运行时求值 -> 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

if consteval (C++23)

if consteval {
    // 仅编译时代码
} else {
    // 仅运行时代码
}

#include <iostream>

constexpr int f() {
    if consteval {
        return 42; // 编译时版本
    } else {
        return 0; // 运行时版本
    }
}

int main() {
    constexpr int a = f(); // 编译时上下文 -> 返回 42
    int b = f(); // 运行时上下文 -> 返回 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

主要区别（总结）

• 形式： std::is_constant_evaluated() 是一个函数；if consteval 是一个语言级条件语句。
• 标准： std::is_constant_evaluated() 出现在 C++20 中；if consteval 出现在 C++23 中。
• 保证： if consteval 为编译器提供编译时保证，并拒绝编译时无法使用的 consteval 分支中的代码。 std::is_constant_evaluated() 的执行环境更为宽松：它返回布尔值，但不会强制编译器拒绝其他分支中无效的编译时构造。
• 在表达式内部使用： std::is_constant_evaluated() 可以在语句形式的 if 无法使用的表达式内部使用（例如，在三元运算符内部）。if consteval 需要语句级上下文。

具体比较示例

// if-consteval 示例
constexpr int f() {
    if consteval {
        return 1; // 仅在编译时
    } else {
        return 2; // 仅限运行时
    }
}

// std::is_constant_evaluated() 示例
#include <type_traits>
constexpr int g() {
    if (std::is_constant_evaluated()) {
        return 1; // 可能仍会编译运行时路径
    } else {
    return 2;
    }
}

// 使用 if consteval 时，编译器将拒绝无效的仅限编译时构造
constexpr int bad() {
    if consteval {
        std::cout << "compile-time"; // ❌ 错误 — 常量求值中不允许 I/O
    }
    return 0;
}

// 使用 std::is_constant_evaluated() 时，编译器会更加宽容，可能会编译通过，直到代码
// 实际用于常量表达式上下文。
#include <type_traits>
constexpr int perhaps_bad() {
    if (std::is_constant_evaluated()) {
        std::cout << "compile-time"; // 可能会编译通过；只有在 const-expr 中求值时才会出现错误
    }
    return 0;
}

使用场景

• 如果您的目标是 C++23（或更高版本），并且想要清晰的、编译时强制的分支：请优先使用 if consteval。
• 如果您必须仅支持 C++20 环境：请使用 std::is_constant_evaluated()。
• 如果您需要在表达式（而非语句）中进行检查，请使用 std::is_constant_evaluated()，因为 if consteval 是语句级的。
• 如果您希望编译器拒绝编译时无法使用的代码，if consteval 可以提供更强的保证。

实际用例

• 为编译时和运行时（快速预计算 vs 较慢的运行时）编写不同的实现逻辑）。
• 保护仅运行时操作（例如 I/O、动态分配或系统调用），以免它们被意外地用于常量求值路径。
• 在编写可在 constexpr 上下文和正常运行时上下文中使用的库时，提供更清晰、更能揭示意图的代码。

简短实用的检查清单

• 需要表达式级检查？→ std::is_constant_evaluated()。
• 想要编译器强制执行的仅编译时分支？→ if consteval。
• 仅针对 C++20？→ std::is_constant_evaluated()。
• 针对 C++23+ 并更注重清晰度和安全性？ → if consteval.

TL;DR

• 编译器将其视为仅编译时分支的语言级条件语句；
• 更强的编译时执行力和更清晰的意图。

结束语

如何证明 √2 是无理数 — 两种方法（反证法与几何无限下降）

方法一 — 反证法

方法二 — 几何无限下降（等腰直角三角形中线构造）

• 如果假设存在整数边长满足 [math]a^2=2b^2[/math]，则这种几何构造（或等价的、保持整数关系的中点构造）会产生一个更小的正整数解。
• 无限重复下去会得到一个严格递减的正整数序列，这显然不可能。

• 方法一（反证法）利用奇偶性，说明若假设分数为最简形式则会导致分子和分母都为偶数，从而矛盾。
• 方法二（几何无限下降）通过在等腰直角三角形中作中线并利用相似性得到更小的整数解，从而与最小性矛盾。

概况

家里的NAS是我主要文件存储系统，Aria2作为日常常用下载工具也一同部署在上面。

该Aria2以docker容器的形式部署，这样可以带来更好的独立性以便于日常维护。由于众所周知的原因，尝试过一段时间通过openwrt对其进行留学分流，但效果不是太理想。总会发生偶发性的偷跑流量情况，且会损失部分下载速度。为避免钱袋受到伤害，最终还是把Aria2设置为直连方式下载。

直连方式也带来一个问题：部分种子在墙外被限制直连，若直接将链接地址发送到Aria2，是无法被正确下载的。每次遇到这种情况，我只能先通过浏览器把种子文件下载下来后，再通过Aria2NG发种子发送到Aria2进行下载，显得比较繁琐。Aria2NG也有一个问题：每次只能上传一个种子。如果有多个种子文件，操作就显得相当机械繁琐而无趣。我想，能不能一步到位直接把下载好的种子文件统一推送到Aria2自行下载呢？搜索了一下，果然有老哥为此建了个项目，该项目是通过xmlrpc的方式管理Aria2，但缺少密钥验证功能。因此我拿该大佬的项目改了一下，以支持密钥验证方式。有需要的朋友可以直接抄下作业。

实现我需求的思路主要是两个部分，第一部分是脚本处理，第二部分是系统快捷键的部署（我的是MacOS，win部分可能需要一些系统快捷键软件支持才能实现）。

批量提交BT文件到Aria2

脚本

import xmlrpc.client
import xmlrpc
import os
import argparse

def handle(s, btFile, token):
    print('handle bittorrent file: ', str(btFile))
    token = "token:" + token
    ret=s.aria2.addTorrent(token,xmlrpc.client.Binary(open(btFile, mode='rb').read()),[],{'pause':'true'})
    print("add bt: ",str(ret))
    waiting = s.aria2.tellWaiting(token,0, 1000,
                              ["gid", "totalLength", "completedLength", "uploadSpeed", "downloadSpeed", "connections",
                               "numSeeders", "seeder", "status", "errorCode", "verifiedLength",
                               "verifyIntegrityPending", "files", "bittorrent", "infoHash"])
    for w in waiting:
        gid=w['gid']
        if gid!=ret:
            continue
        #print(w['gid'],w['files'])
        # max-selection strategy
        maxLen=0
        maxFPath=''
        maxFIndex='0'
        for f in w['files']:
            #print(f['length'],f['path'])
            if int(f['length'])>maxLen:
                maxLen=int(f['length'])
                maxFPath=f['path']
                maxFIndex=f['index']
        print('max file: ',str(maxLen),maxFIndex,str(maxFPath))
        # max-selection strategy end
        cret=s.aria2.changeOption(token,gid,{'select-file':maxFIndex})# select multiple files example: 'select-file':'5,6,7,8'
        print('select file: ',cret)
        tret=s.aria2.tellStatus(token,gid)
        print('after selection: ', tret['files'][int(maxFIndex)-1])
        uret=s.aria2.unpause(token,gid)
        print('unpause: ',uret)
    print('over: ',str(btFile))



if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.description = 'bt批量导入aria2，并选择文件大小最大的文件进行下载'
    parser.add_argument("server", help="like: http://192.168.3.99:6800", type=str)
    parser.add_argument("token", help="验证密钥", type=str)
    parser.add_argument("dir", help="存放种子目录", type=str)
    args = parser.parse_args()
    s = xmlrpc.client.ServerProxy(args.server+"/rpc")
    flist=os.listdir(args.dir)
    for i in range(0, len(flist)):
        if flist[i].endswith(".torrent"):
            btFile = os.path.join(args.dir, flist[i])
            if os.path.isfile(btFile):
                handle(s,btFile, args.token)
    print("Done")

使用方法

把上述代码保存为bb2a.py，需要使用Python3运行。

帮助（Help):

python3 bb2a.py --help

启动（Start to Add):

python3 bb2a.py <server> <token> <bt-dir>

参数（parameters）：

server      如（like): http://192.168.3.99:6800
token       验证密钥：设置在Aria2配置文件的密钥
bt-dir      bt文件的目录（the dir of your bittorrents）

例子（example):

python3 /path/to/bb2a.py http://192.168.1.100:6800 123456 /home/root/bts/

MacOS增加快捷指令

command + 空格，在快捷运行窗口输入“快捷指令”打开系统的快捷指令模块。点击窗口右上角➕新增一个快捷指令。

按照下图方式创建快捷指令内容

参考shell内容如下，请按照自己配置情况修改相关参数。sleep 3是暂停3秒。后面的rm命令是顺便删除下载目录中的bt种子文件。

python3 /Users/ccchen/autobt/bb2a.py http://192.168.12.5:6800 123456 /Volumes/FAT12T/down2025/
sleep 3
rm -f  /Volumes/FAT12T/down2025/*.torrent

按窗口右上角的详情按钮，设置快捷指令的允许执行shell权限。

最后给快捷指令设置快捷键.我设置的快捷键是“Ctrl + Option + W”这个组合键。

完结

到此，所有配置已完成。只要下载bt种子到对应的目录。完毕后按快捷键“Ctrl + Option + W”，脚本便自动将该目录中所有种子文件发送到aria2进行下载。同时会把下载目录中对应的种子清理掉。

本篇主要介绍 OJ 中新人 用 python 做题可能会遇到的问题以及解决方法

本篇主要介绍程序设计的三种结构，即顺序、选择和循环，并重点讲解选择结构和循环结构的概念和应用。

本文是 Python 系列的第二篇，介绍 Python 的基础数据类型及如何进行输入输出操作。

本文是 Python 系列的第一篇，将带你打破对编程的神秘感，理解编程的本质，并亲手运行你的第一个 Python 程序。

好多大学生之前都没使用过电脑，安装和卸载软件之类的都不会。本文将介绍学习编程前的一些默认应该知道的知识，全部都是本人踩过的坑。

在 C++ 程序执行时，是如何管理内存的？本文将介绍 C++ 程序的内存布局，包括代码区、全局/静态区、栈区和堆区，并通过示例代码帮助理解这些概念。

HTML 是网页的基础，了解 HTML 的基本结构和语法是学习前端开发的第一步。本文将介绍 HTML 的基本概念和常用标签。

KernelSU 不支持非 GKI 设备，所以需要手动编译内核，本文手把手教你构建一加 6 的 PixelExperience 内核并启用 KernelSU 支持

在现代的开发过程中，GitHub Flow 已经成为一种非常流行的工作流程。本文将详细介绍 GitHub Flow 的流程以及在实际项目中如何应用它。

本篇文章介绍了环境搭建、递归的基本概念、基本数列递归的求解方法。