个人技术备忘录

笔记分类

C# 实践笔记

Python 实践笔记

基础算法练习

网页设计练习

最近整理

筛选仅在当前静态页面内进行，不会提交任何数据。

C# 中基于 ReadOnlySpan 的命令参数切片记录 C#

记录在解析简单命令文本时，如何尽量避免 Split 带来的数组分配。该笔记仅用于个人理解字符串切片、边界判断和低分配写法。

static bool TryReadPair(ReadOnlySpan<char> line, out ReadOnlySpan<char> key, out ReadOnlySpan<char> value)
{
    var index = line.IndexOf('=');
    if (index <= 0 || index >= line.Length - 1)
    {
        key = default;
        value = default;
        return false;
    }

    key = line[..index].Trim();
    value = line[(index + 1)..].Trim();
    return key.Length > 0 && value.Length > 0;
}

这个示例只展示个人学习中的写法记录，不提供在线解析服务。

使用简易对象池减少临时 List 创建 C#

记录在频繁构建临时集合时，如何通过租借和归还列表降低 GC 压力。该内容仅为个人学习对象生命周期管理的备忘。

sealed class ListPool<T>
{
    private readonly Stack<List<T>> _pool = new();

    public List<T> Rent()
    {
        return _pool.Count > 0 ? _pool.Pop() : new List<T>(64);
    }

    public void Return(List<T> list)
    {
        list.Clear();
        _pool.Push(list);
    }
}

页面只展示代码片段，不提供库下载或运行环境。

Python 批量解析日志并统计耗时区间 Python

记录使用 Python 对本地日志进行批量读取、字段提取和耗时分桶统计的练习过程。该内容仅作为个人脚本学习记录。

from pathlib import Path
from collections import Counter

def parse_cost(line: str):
    marker = "cost="
    index = line.find(marker)
    if index < 0:
        return None

    start = index + len(marker)
    end = line.find("ms", start)
    if end < 0:
        return None

    return int(line[start:end].strip())

buckets = Counter()

for path in Path("logs").glob("*.log"):
    for line in path.read_text(encoding="utf-8").splitlines():
        cost = parse_cost(line)
        if cost is None:
            continue

        if cost < 50:
            buckets["0-50ms"] += 1
        elif cost < 200:
            buckets["50-200ms"] += 1
        else:
            buckets["200ms+"] += 1

print(buckets)

示例仅用于展示个人 Python 学习笔记，不提供日志上传、在线分析或远程处理功能。

使用并查集统计无向图连通分量算法

记录并查集路径压缩与按秩合并的写法，用于理解图结构中的连通性问题。

class UnionFind:
    def __init__(self, size):
        self.parent = list(range(size))
        self.rank = [0] * size

    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]
            x = self.parent[x]
        return x

    def union(self, a, b):
        ra = self.find(a)
        rb = self.find(b)

        if ra == rb:
            return False

        if self.rank[ra] < self.rank[rb]:
            ra, rb = rb, ra

        self.parent[rb] = ra

        if self.rank[ra] == self.rank[rb]:
            self.rank[ra] += 1

        return True

该示例是算法练习记录，不提供在线判题、在线提交或代码运行功能。

使用拓扑排序整理任务依赖顺序算法

记录如何通过入度表和队列处理有向无环图中的依赖顺序，便于理解任务编排和依赖解析的基础思想。

from collections import defaultdict, deque

def topological_sort(nodes, edges):
    graph = defaultdict(list)
    indegree = {node: 0 for node in nodes}

    for before, after in edges:
        graph[before].append(after)
        indegree[after] += 1

    queue = deque(node for node in nodes if indegree[node] == 0)
    result = []

    while queue:
        node = queue.popleft()
        result.append(node)

        for next_node in graph[node]:
            indegree[next_node] -= 1
            if indegree[next_node] == 0:
                queue.append(next_node)

    if len(result) != len(nodes):
        raise ValueError("dependency cycle detected")

    return result

该内容仅为个人算法学习备忘，不构成在线任务编排服务。

A* 搜索中启发函数与路径代价的练习记录算法

记录 A* 搜索算法中启发函数的设计原则与路径代价关系，通过对比不同启发函数对搜索效率的影响来加深理解。

import heapq

def astar(graph, start, goal, heuristic):
    open_set = [(heuristic(start, goal), 0, start)]
    g_score = {start: 0}
    came_from = {}

    while open_set:
        f, g, current = heapq.heappop(open_set)

        if current == goal:
            path = []
            while current in came_from:
                path.append(current)
                current = came_from[current]
            path.append(start)
            return path[::-1]

        for neighbor, cost in graph[current]:
            tentative_g = g + cost

            if neighbor not in g_score or tentative_g < g_score[neighbor]:
                g_score[neighbor] = tentative_g
                came_from[neighbor] = current
                f = tentative_g + heuristic(neighbor, goal)
                heapq.heappush(open_set, (f, tentative_g, neighbor))

    return None

该示例为个人算法练习记录，不提供在线路径规划或地图服务。

CSS Grid 实现响应式笔记卡片布局网页设计

记录使用 CSS Grid 的 auto-fill 和 minmax 实现自适应卡片布局的练习，结合 media query 处理窄屏下的单列降级。

.card-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
  gap: 16px;
}

@media (max-width: 600px) {
  .card-grid {
    grid-template-columns: 1fr;
  }
}

该示例仅为个人 CSS 学习笔记，不提供在线编辑器或模板下载。

原生 JavaScript 实现静态笔记本地筛选网页设计

记录如何在无后端接口的情况下，对当前页面中已有的静态笔记卡片进行本地筛选。筛选过程不提交任何用户数据。

const input = document.querySelector("[data-note-filter]");
const cards = Array.from(document.querySelectorAll("[data-note-card]"));

input.addEventListener("input", () => {
  const keyword = input.value.trim().toLowerCase();

  for (const card of cards) {
    const text = card.textContent.toLowerCase();
    card.hidden = keyword.length > 0 && !text.includes(keyword);
  }
});

该交互只在浏览器本地执行，不调用搜索接口，不记录搜索内容。

未找到匹配的笔记。

学习时间线

2026-05

整理 C# 低分配字符串处理笔记

2026-04

练习 Python 批量文本解析与数据清洗

2026-03

复习图遍历、并查集与拓扑排序

2026-02

整理响应式页面布局与本地交互练习