1def quicksort_lomuto(arr: list[int], low: int, high: int) -> None:
 2    """Lomuto partition scheme — 简单直观但交换次数较多"""
 3    if low >= high:
 4        return
 5
 6    pivot = arr[high]           # 选最后一个元素作为 pivot
 7    i = low - 1                 # i 指向"小于 pivot 的区域"的末尾
 8
 9    for j in range(low, high):
10        if arr[j] < pivot:
11            i += 1
12            arr[i], arr[j] = arr[j], arr[i]
13
14    i += 1
15    arr[i], arr[high] = arr[high], arr[i]  # 将 pivot 放到正确位置
16
17    quicksort_lomuto(arr, low, i - 1)
18    quicksort_lomuto(arr, i + 1, high)

1def quicksort_pythonic(arr: list[int]) -> list[int]:
2    """Functional-style quicksort — NOT in-place"""
3    if len(arr) <= 1:
4        return arr
5    pivot = arr[len(arr) // 2]
6    left  = [x for x in arr if x < pivot]
7    mid   = [x for x in arr if x == pivot]
8    right = [x for x in arr if x > pivot]
9    return quicksort_pythonic(left) + mid + quicksort_pythonic(right)

 1// 三路划分 (Three-way Partition) —— 适合大量重复元素
 2void quicksort_3way(int arr[], int low, int high) {
 3    if (low >= high) return;
 4
 5    // 小数组切换到插入排序
 6    if (high - low < 16) {
 7        insertion_sort(arr + low, high - low + 1);
 8        return;
 9    }
10
11    int lt = low, gt = high;
12    int pivot = arr[low];
13    int i = low;
14
15    while (i <= gt) {
16        if (arr[i] < pivot)      swap(arr + lt++, arr + i++);
17        else if (arr[i] > pivot) swap(arr + i, arr + gt--);
18        else                     i++;
19    }
20
21    quicksort_3way(arr, low, lt - 1);
22    quicksort_3way(arr, gt + 1, high);
23}

 1func BenchmarkQuicksort(b *testing.B) {
 2    data := make([]int, 1_000_000)
 3    for i := range data {
 4        data[i] = rand.Intn(1_000_000)
 5    }
 6    b.ResetTimer()
 7    for i := 0; i < b.N; i++ {
 8        copy := append([]int(nil), data...)
 9        quicksort(copy)
10    }
11}
12// BenchmarkQuicksort-16    4    286 ms/op

1def sigmoid(x: float) -> float:
2    s = 1.0 / (1.0 + math.exp(-x))
3    return s
4
5def sigmoid_backward(d_out: float, s: float) -> float:
6    # sigmoid 导数: sigma(x) * (1 - sigma(x))
7    return d_out * s * (1.0 - s)

 1import torch
 2from torch.autograd import Function
 3
 4class MyLinear(Function):
 5    """自定义线性层的前向与反向传播"""
 6
 7    @staticmethod
 8    def forward(ctx, input, weight, bias=None):
 9        # 保存反向所需变量
10        ctx.save_for_backward(input, weight, bias)
11        output = input.mm(weight.t())
12        if bias is not None:
13            output += bias.unsqueeze(0).expand_as(output)
14        return output
15
16    @staticmethod
17    def backward(ctx, grad_output):
18        input, weight, bias = ctx.saved_tensors
19        grad_input = grad_weight = grad_bias = None
20
21        # 根据链式法则计算各梯度
22        if ctx.needs_input_grad[0]:
23            grad_input = grad_output.mm(weight)        # dL/dX = dL/dY · W
24        if ctx.needs_input_grad[1]:
25            grad_weight = grad_output.t().mm(input)    # dL/dW = Y_grad^T · X
26        if bias is not None and ctx.needs_input_grad[2]:
27            grad_bias = grad_output.sum(0)             # dL/db = sum(dL/dY, dim=0)
28
29        return grad_input, grad_weight, grad_bias

1# 使用 gradcheck 验证自定义反向传播
2$ python -c "
3import torch
4from my_linear import MyLinear
5input = torch.randn(20, 10, dtype=torch.double, requires_grad=True)
6weight = torch.randn(5, 10, dtype=torch.double, requires_grad=True)
7torch.autograd.gradcheck(MyLinear.apply, (input, weight), eps=1e-6, atol=1e-4)
8print('Gradient check passed!')
9"

 1package main
 2
 3import (
 4    "fmt"
 5    "time"
 6)
 7
 8func main() {
 9    go func() {
10        fmt.Println("Hello from goroutine!")
11    }()
12
13    time.Sleep(10 * time.Millisecond) // 等待 goroutine 执行完毕
14}

 1// runtime/runtime2.go (简化示意)
 2type g struct {
 3    stack     stack       // goroutine 栈
 4    sched     gobuf       // 调度上下文 (sp, pc, bp...)
 5    atomicstatus uint32   // _Gidle / _Grunning / _Gwaiting...
 6}
 7
 8type p struct {
 9    runq     [256]guintptr // 本地运行队列
10    runnext  guintptr      // 下一个优先运行的 G
11    m        muintptr      // 当前绑定的 M
12}

 1// Fan-in pattern: 多路输入合并为单路输出
 2func fanIn(ch1, ch2 <-chan string) <-chan string {
 3    out := make(chan string)
 4    go func() {
 5        for {
 6            select {
 7            case s := <-ch1:
 8                out <- s
 9            case s := <-ch2:
10                out <- s
11            }
12        }
13    }()
14    return out
15}

 1package crawler
 2
 3import (
 4    "context"
 5    "fmt"
 6    "net/http"
 7    "sync"
 8    "time"
 9)
10
11type Result struct {
12    URL      string
13    StatusCode int
14    Duration   time.Duration
15    Err        error
16}
17
18func Crawl(ctx context.Context, urls []string, concurrency int) []Result {
19    limiter := make(chan struct{}, concurrency) // 并发度控制
20    var wg sync.WaitGroup
21    results := make([]Result, 0, len(urls))
22    var mu sync.Mutex
23
24    for _, u := range urls {
25        select {
26        case <-ctx.Done():
27            break // 全局超时，不再启动新请求
28        default:
29        }
30
31        wg.Add(1)
32        go func(url string) {
33            defer wg.Done()
34
35            limiter <- struct{}{}        // 获取令牌
36            defer func() { <-limiter }() // 释放令牌
37
38            start := time.Now()
39            resp, err := http.Get(url)
40            d := time.Since(start)
41
42            mu.Lock()
43            defer mu.Unlock()
44
45            r := Result{URL: url, Duration: d}
46            if err != nil {
47                r.Err = err
48            } else {
49                r.StatusCode = resp.StatusCode
50                resp.Body.Close()
51            }
52            results = append(results, r)
53        }(u)
54    }
55
56    wg.Wait()
57    return results
58}

 1// Stage 1: 生成数字流
 2func generator(ctx context.Context, nums ...int) <-chan int {
 3    out := make(chan int)
 4    go func() {
 5        defer close(out)
 6        for _, n := range nums {
 7            select {
 8            case out <- n:
 9            case <-ctx.Done():
10                return
11            }
12        }
13    }()
14    return out
15}
16
17// Stage 2: 平方运算
18func square(ctx context.Context, in <-chan int) <-chan int {
19    out := make(chan int)
20    go func() {
21        defer close(out)
22        for n := range in {
23            select {
24            case out <- n * n:
25            case <-ctx.Done():
26                return
27            }
28        }
29    }()
30    return out
31}
32
33// Stage 3: 过滤结果
34func filter(ctx context.Context, in <-chan int, predicate func(int) bool) <-chan int {
35    out := make(chan int)
36    go func() {
37        defer close(out)
38        for n := range in {
39            if predicate(n) {
40                select {
41                case out <- n:
42                case <-ctx.Done():
43                    return
44                }
45            }
46        }
47    }()
48    return out
49}

 1// ❌ BAD: 如果 ctx 被取消，ch 永远不会被读取，goroutine 永久阻塞
 2func bad(ctx context.Context) <-chan int {
 3    ch := make(chan int)
 4    go func() {
 5        result := expensiveComputation()
 6        ch <- result // ctx 取消后无人接收，goroutine 泄漏！
 7    }()
 8    return ch
 9}
10
11// ✓ GOOD: 使用 select 响应取消
12func good(ctx context.Context) <-chan int {
13    ch := make(chan int)
14    go func() {
15        result := expensiveComputation()
16        select {
17        case ch <- result:
18        case <-ctx.Done():  // 安全退出
19            return
20        }
21    }()
22    return ch
23}

1// panic: close of closed channel
2func safeClose() {
3    ch := make(chan int)
4    var once sync.Once
5    closeCh := func() { once.Do(func() { close(ch) }) }
6
7    go func() { closeCh() }()
8    go func() { closeCh() }() // 使用 sync.Once 保证只关一次
9}

 1// ❌ BAD (Go < 1.22): 循环变量在迭代间复用
 2for _, v := range items {
 3    go func() {
 4        process(v) // v 被所有 goroutine 共享！
 5    }()
 6}
 7
 8// ✓ GOOD: 将变量作为参数传入
 9for _, v := range items {
10    go func(val Item) {
11        process(val)
12    }(v)
13}
14// 或 Go ≥ 1.22 中循环变量自动具有每次迭代独立的作用域