LINUX SB 快照站

正在尝试@搬瓦工bot #1

坏人尽快走远点啊。。。cf开着我也爬不了任何帖子了。。。

https://linux.sb/topic/10892
403

刚才好像sb站崩了，导致最终只抓了4/5的可抓帖

数据集：https://www.altzin.com/linuxsb/data/snapshot.sqlite

普通查询来这里：https://www.altzin.com/linuxsb
之后正常增量抓取后就能看到各种历史了。
增量监控 循环监控新评论列表，持续更新
全量抓取 按新帖列表逐页抓完全站，完成后退出
本地存储 保存标题、楼层、用户名、正文 HTML
版本覆盖 标题/楼层变化时更新当前版本，旧版写入历史表
全局搜索 多关键词搜索，含历史版本，支持分页
帖子浏览 分页查看楼层，保留标题颜色与精华徽章
楼层正确 利用bbs_auth获取正确的楼层号
@楼层跳转 正文中的 @用户 #N 转为快照站内链，点击直达对应楼层
邮箱解码 自动解码 Cloudflare 邮箱保护
用户页 按用户 ID 查看快照发言与改名历史
用户大全 列出所有已快照用户，按最近出现排序，支持用户名模糊搜索
用户名查用户 按用户名搜索，可能匹配多个用户
历史查看 单独页面查看帖子标题或楼层的历史版本

那时，我突然发现存档站跳转关系全是错的。我很疑惑。
我的浏览器里的楼号显示正确，但是抓下来的html楼号就是错误的。
后面继续对比，尝试用无头浏览器抓取html，发现楼号仍错误。
手动使用另一个浏览器抓取，楼号仍错误。
这时就很清晰了，登录和没登陆看到的楼号是不一样的。
非常恐怖。
那只能是cookie的原因，然后用二分法最终确定了只需要bbs_auth一个cookie。
这个令牌有效期非常长，所以我可以放心托管。
在爬取器内加入了使用令牌。

目前已经开始重新爬了。没想到小小的论坛这么多问题，爬它还很不容易。而且这些问题都不大，是看起来能爬，仔细看才发现跳转不对。

现在的跳转应该对了。

https://www.altzin.com/linuxsb

@SpongeBob #7
ok我主动给我的爬取器提供bbs_auth，有效期到2027年挺长，希望工作正常。

@痛失姓名的站长 #11
排序可以排，但是不要不一致啊
同一个楼层只应该有一个#楼号

@痛失姓名的站长 #8
@SpongeBob #7
注意到docomo的同一条消息在登录后显示为正确的#2，未登录时显示的#3
要修的话吱一声，我现在严重受到这个阻碍

@SpongeBob #7
@痛失姓名的站长 #4

登录态的是正确的，未登陆的则始终从1开始向上编码@痛失姓名的站长 #4

登录的访问和未登录的访问的同一楼的#开头的楼号不一致@痛失姓名的站长 #4

还发现登录与不登陆楼层标识不一致@SpongeBob #2

由于某种原因，存在被点赞的楼层时，实际显示楼号、html楼号均不一致，而且楼层跳转无法正常进行（会跳错）。
我目前还在研究这玩意

发现一个新问题。楼层竟然不是按顺序排的...重爬...讨厌

谢谢@wh0am1 #3

用户名中间有空格会导致无法被回复。应该禁止用户名中间的空格

是的，全站！我也爱你！@搬瓦工bot #2

可以看到屏幕上一直在爬哈。频率设置的1秒1个请求。

github上也是上传了最新版。https://github.com/QianCF/linux.sb-snapshot

在爬全帖，大家应该能看到帖子不断增多。
现在能看到邮箱了。臭cloudflare竟敢防爬。
@可以跳到正确的位置了，而不是出现404。
体验存档：https://www.altzin.com/linuxsb

如图，标题含书名号时推送消息的链接范围会算错。
无关紧要，但难看

近期班内同学躁动不安，同时存在一些矛盾，有同学觉得某些同学过于聪明，还有同学觉得某些同学不聪明，同时存在因为同学身体素质问题而被歧视的现象，例如不会做手工的同学或跑的慢的同学被严重的低估和嘲笑，有一些同学啃食铅笔和塑料制品，据此，我制作了一张“同学医科小广告”，宣传称可以解决同学的各类问题，讽刺了班级内的各种现象。介于一部分同学可能并不是特别聪明，因此我声称使用了纳米黑科技，用于诱骗同学拨打电话咨询。这张海报被贴在了班级外墙，一天内吸引了大量人员围观。

在学校里，经常有人在别人身上贴纸条，写着“笨蛋”等语言，我发现这些纸条攻击力不够强悍：它们只能被动攻击所贴在的人，不能主动攻击。因此，我发明了“笨蛋条”，摆脱了必须贴在人上的缺陷，现在它可以贴在任何地方，并无差别的攻击每一个看到它的人。笨蛋条在班级内广泛流传，许多人遇到了一些困难，例如写的时候会攻击到自己、或者攻击到不想攻击的人。据此，我对笨蛋条进行了升级，改进版“定向笨蛋条”诞生。“定向笨蛋条”拥有一条横向，只有被写在横线上的人才会受到攻击，可以进行精准打击。愚人节时，我把笨蛋条制作成图片，使用打印机进行量产，在其它班级的桌子上散播了一些，许多人看到后立马赠与朋友，甚至出现丢来丢去和互相打斗的局面，最后吸引了校长，校长说“这谁写的”，然而无人知道。

图片上的字样：
笨蛋条 谁看到这个，谁就是笨蛋。
定向笨蛋条 ___看到这个，他就是笨蛋。

我的妹妹在使用乘法表时遇到了困难：其在寻找一个乘法式的结果时总是数不清行数和列数，导致最终得到的结果错误，而且妹妹没有数感，对于一个1-10的数可能在乘法表的大概位置毫无知情，常常要一个一个数过去。为了解决这个问题，我发明了“乘法典”，采用新华字典的编码方式，提供一级和二级索引，通过大字标明索引，精准解决数不清行列数的问题。长期的使用后，妹妹表示：使用较为麻烦，但解决了我的困难。

我家附近有一个丽园公园，近期我小时候的一个玩伴"萌萌"回到了中国，她曾经经常带我去丽园公园，因此为了唤起她的回忆，我试图制作“丽园公园地图”。由于我无法立即前往丽园公园，所以这整张地图都是全凭记忆在Photoshop内完成的，不过由于我经常去丽园公园，这张图的拓扑结构几乎准确，且遵守上北原则。图中蓝色线为路，红色线为某种意义上的阻隔，且用文字标出了各个地点的主要特性。为了测试"萌萌"是否还记得丽园公园，我在图上仅标注了“某公园”，发给“萌萌”后，她成功辨认出是丽园公园。

想看完整代码的去这里
https://www.altzin.com/5chess.worker.js
@Denia-bot #4

发现代码又被截断了…好烦…32kb代码都放不下@捡垃圾的管理员 #1

1.我基本下不过它
2.它永远不会犯小错
3.没有模型，纯基于规则
4.无状态/记忆设计，落子只取决于已有的子和棋盘，不取决于任何其他东西
5.充分利用了五子棋数学结构，棋盘总格式^3以内的都算过了
在线体验：https://www.altzin.com/5chess.php
核心代码：

"use strict";

const CELL_EMPTY = 0;

self.onmessage = (ev) => {
  try {
    const data = ev.data;
    if (!data || data.type !== "computeMove") {
      throw new Error("消息类型非法。");
    }
    const { board, ai, opponent } = data;
    const move = chooseAiMove(board, ai, opponent);
    self.postMessage({
      type: "move",
      row: move.row,
      col: move.col,
      reason: move.reason || ""
    });
  } catch (err) {
    // Worker 抛错会触发主线程 onerror
    throw err;
  }
};

function assert(cond, msg) {
  if (!cond) throw new Error(msg);
}

function assertPlayer(p) {
  if (p !== 1 && p !== 2) throw new Error("玩家标记非法。");
}

function assertBoard(board) {
  assert(Array.isArray(board) && board.length >= 5, "棋盘非法。");
  const n = board.length;
  for (let r = 0; r < n; r++) {
    assert(Array.isArray(board[r]) && board[r].length === n, "棋盘维度不一致。");
    for (let c = 0; c < n; c++) {
      const v = board[r][c];
      assert(v === 0 || v === 1 || v === 2, "棋盘值非法。");
    }
  }
}

function inBounds(r, c, n) {
  return r >= 0 && r < n && c >= 0 && c < n;
}

function isPlayable(board, r, c) {
  const n = board.length;
  return inBounds(r, c, n) && board[r][c] === CELL_EMPTY;
}

function placeStone(board, r, c, player) {
  assertPlayer(player);
  assertBoard(board);
  const n = board.length;
  assert(inBounds(r, c, n), "落子越界。");
  if (board[r][c] !== CELL_EMPTY) throw new Error("位置已有棋子。");
  board[r][c] = player;
}

function deepCopyBoard(board) {
  return board.map((row) => row.slice());
}

/** B 相对 A 的最远切比雪夫距离；可下空位须在其自身切比雪夫半径内能「看到」至少一枚棋子（见 getAvailableMoves） */
const MAX_B_CHEBYSHEV_FROM_A = 5;

function boardHasAnyStone(board) {
  const n = board.length;
  for (let r = 0; r < n; r++) {
    for (let c = 0; c < n; c++) {
      if (board[r][c] !== CELL_EMPTY) return true;
    }
  }
  return false;
}

/** 在 (row,col) 的切比雪夫闭球内（不含该格自身）是否存在任意棋子 */
function hasStoneWithinChebyshevOf(board, row, col, radius) {
  const n = board.length;
  for (let rr = row - radius; rr <= row + radius; rr++) {
    for (let cc = col - radius; cc <= col + radius; cc++) {
      if (!inBounds(rr, cc, n)) continue;
      if (Math.max(Math.abs(rr - row), Math.abs(cc - col)) > radius) continue;
      if (rr === row && cc === col) continue;
      if (board[rr][cc] !== CELL_EMPTY) return true;
    }
  }
  return false;
}

function getAvailableMoves(board) {
  assertBoard(board);
  const moves = [];
  const n = board.length;
  const restrict = boardHasAnyStone(board);
  for (let r = 0; r < n; r++) {
    for (let c = 0; c < n; c++) {
      if (board[r][c] !== CELL_EMPTY) continue;
      if (restrict && !hasStoneWithinChebyshevOf(board, r, c, MAX_B_CHEBYSHEV_FROM_A)) continue;
      moves.push({ row: r, col: c });
    }
  }
  if (moves.length === 0 && restrict) {
    for (let r = 0; r < n; r++) {
      for (let c = 0; c < n; c++) {
        if (board[r][c] === CELL_EMPTY) moves.push({ row: r, col: c });
      }
    }
  }
  return moves;
}

function shuffleInPlace(arr) {
  for (let i = arr.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
}

function getShuffledAvailableMoves(board) {
  const moves = getAvailableMoves(board);
  shuffleInPlace(moves);
  return moves;
}

function chebyshevDistance(a, b) {
  return Math.max(Math.abs(a.row - b.row), Math.abs(a.col - b.col));
}

/**
 * 当前棋盘空位，按与 ref 的切比雪夫距离升序排列（同距离按行、列）。
 * 用于 A/B 枚举时优先试探离 A 更近的 B。
 */
function sortEmptyMovesByChebyshevFrom(board, ref) {
  const moves = getAvailableMoves(board);
  moves.sort((p, q) => {
    const dp = chebyshevDistance(ref, p);
    const dq = chebyshevDistance(ref, q);
    if (dp !== dq) return dp - dq;
    if (p.row !== q.row) return p.row - q.row;
    return p.col - q.col;
  });
  return moves;
}

function hasWinner(board, player) {
  assertBoard(board);
  assertPlayer(player);
  const n = board.length;
  const dirs = [[0, 1], [1, 0], [1, 1], [1, -1]];

  for (let r = 0; r < n; r++) {
    for (let c = 0; c < n; c++) {
      if (board[r][c] !== player) continue;
      for (const [dr, dc] of dirs) {
        let len = 0;
        let rr = r;
        let cc = c;
        while (inBounds(rr, cc, n) && board[rr][cc] === player) {
          len++;
          rr += dr;
          cc += dc;
        }
        if (len >= 5) return true;
      }
    }
  }
  return false;
}

function makeCellKey(row, col) {
  return `${row},${col}`;
}

/** 与 dr,dc 方向一致的整条直线标识（同一直线）。 */
function lineKeyFromCellAndDir(r, c, dr, dc) {
  if (dr === 0 && dc === 1) return `0,1,${r}`;
  if (dr === 1 && dc === 0) return `1,0,${c}`;
  if (dr === 1 && dc === 1) return `1,1,${r - c}`;
  if (dr === 1 && dc === -1) return `1,-1,${r + c}`;
  throw new Error("方向非法。");
}

function buildSegmentCellKeys(start, dr, dc, len) {
  const keys = [];
  for (let i = 0; i < len; i++) {
    const rr = start.row + dr * i;
    const cc = start.col + dc * i;
    keys.push(makeCellKey(rr, cc));
  }
  return keys;
}

function cellSetFromKeys(arr) {
  return new Set(arr);
}

/** 两条候选是否共用至少一枚己方棋子（集合相交非空）。 */
function stonesOverlap(a, b) {
  for (const x of a) {
    if (b.has(x)) return true;
  }
  return false;
}

/**
 * 二级警报去重：
 * 1) 与同一直线（lineKey）上的一级警报共用任一枚棋子者不计入二级；
 * 2) 其余二级候选：仅当在同一直线上且两二级警报的棋子集合有重叠时只计一条；
 *    保留棋子数更多的；同点保留 tier 更小（优先级更高）的。
 * 不同直线、或同线但棋子互不重叠的二级，分别计数。
 */
function countSecondarySameLineOverlapResolved(groups, primaryLineCandidates) {
  if (!Array.isArray(groups)) throw new Error("groups 必须是数组。");
  const items = [];
  for (let tier = 0; tier < groups.length; tier++) {
    const group = groups[tier];
    if (!Array.isArray(group)) throw new Error("group 必须是数组。");
    for (const item of group) {
      if (!item || !Array.isArray(item.cells) || typeof item.lineKey !== "string") {
        throw new Error("二级候选格式非法。");
      }
      items.push({
        cells: cellSetFromKeys(item.cells),
        lineKey: item.lineKey,
        tier
      });
    }
  }

  let secondaryItems = items;
  if (primaryLineCandidates && primaryLineCandidates.length > 0) {
    const primarySets = primaryLineCandidates.map((p) => ({
      lineKey: p.lineKey,
      cells: cellSetFromKeys(p.cells)
    }));
    secondaryItems = items.filter((cand) => {
      for (const p of primarySets) {
        if (cand.lineKey !== p.lineKey) continue;
        if (stonesOverlap(cand.cells, p.cells)) return false;
      }
      return true;
    });
  }

  secondaryItems.sort((a, b) => {
    const ds = b.cells.size - a.cells.size;
    if (ds !== 0) return ds;
    return a.tier - b.tier;
  });
  const kept = [];
  for (const cand of secondaryItems) {
    let skip = false;
    for (const k of kept) {
      if (cand.lineKey !== k.lineKey) continue;
      if (stonesOverlap(cand.cells, k.cells)) {
        skip = true;
        break;
      }
    }
    if (!skip) kept.push(cand);
  }
  return kept.length;
}

function analyzeLines(board, player) {
  assertBoard(board);
  assertPlayer(player);
  const n = board.length;
  const dirs = [[0, 1], [1, 0], [1, 1], [1, -1]];
  const enemy = player === 1 ? 2 : 1;

  let primary = 0;
  let secondary = 0;
  const liveSegments = [];
  const deadSegments = [];
  const fullDeadSegments = [];
  const deadFourCandidates = [];
  const liveThreeCandidates = [];
  /** 一级警报对应的直线与棋子集合，供二级与一级「同线不共用棋子」过滤 */
  const primaryLinePatternCandidates = [];

  for (let r = 0; r < n; r++) {
    for (let c = 0; c < n; c++) {
      if (board[r][c] !== player) continue;

      for (const [dr, dc] of dirs) {
        const pr = r - dr;
        const pc = c - dc;
        if (inBounds(pr, pc, n) && board[pr][pc] === player) continue;

        let len = 0;
        let er = r;
        let ec = c;
        while (inBounds(er, ec, n) && board[er][ec] === player) {
          len++;
          er += dr;
          ec += dc;
        }

        const end1 = { row: r - dr, col: c - dc };
        const end2 = { row: er, col: ec };
        const open1 = isPlayable(board, end1.row, end1.col);
        const open2 = isPlayable(board, end2.row, end2.col);
        const openCount = (open1 ? 1 : 0) + (open2 ? 1 : 0);
        let backSpace = 0;
        let br = r - dr;
        let bc = c - dc;
        while (inBounds(br, bc, n) && board[br][bc] !== enemy) {
          backSpace++;
          br -= dr;
          bc -= dc;
        }
        let frontSpace = 0;
        let fr = er;
        let fc = ec;
        while (inBounds(fr, fc, n) && board[fr][fc] !== enemy) {
          frontSpace++;
          fr += dr;
          fc += dc;
        }
        const maxPossibleLen = len + backSpace + frontSpace;

        const segment = { length: len, start: { row: r, col: c }, end1, end2 };
        if (maxPossibleLen < 5) {
          // 两端向外延申到敌子/边界后，可形成的总长度仍小于 5，等价于全死线。
          fullDeadSegments.push(segment);
          continue;
        }

        if (openCount === 2) liveSegments.push(segment);
        else if (openCount === 1) deadSegments.push(segment);
        else fullDeadSegments.push(segment);

        if (openCount === 0) continue; // 全死不处理

        const lk = lineKeyFromCellAndDir(r, c, dr, dc);
        if (len >= 5) {
          primary++;
          primaryLinePatternCandidates.push({
            cells: buildSegmentCellKeys({ row: r, col: c }, dr, dc, len),
            lineKey: lk
          });
        }
        if (len === 4 && openCount === 2) {
          primary++;
          primaryLinePatternCandidates.push({
            cells: buildSegmentCellKeys({ row: r, col: c }, dr, dc, len),
            lineKey: lk
          });
        }
        if (len === 3 && openCount === 2) {
          liveThreeCandidates.push({
            cells: buildSegmentCellKeys({ row: r, col: c }, dr, dc, len),
            lineKey: lk
          });
        }
        if (len === 4 && openCount === 1) {
          deadFourCandidates.push({
            cells: buildSegmentCellKeys({ row: r, col: c }, dr, dc, len),
            lineKey: lk
          });
        }
      }
    }
  }

  // 二级警报：同一直线上若公用棋子则去重，保留点数更多（同点保留更高优先级类型）
  const brokenFourCandidates = collectBrokenFourPatterns(board, player);
  const openTwoPlusOneCandidates = collectOpenTwoPlusOpenOne(board, player);
  secondary += countSecondarySameLineOverlapResolved(
    [
      brokenFourCandidates,
      deadFourCandidates,
      liveThreeCandidates,
      openTwoPlusOneCandidates
    ],
    primaryLinePatternCandidates
  );

  return {
    primary,
    secondary,
    live_segments: liveSegments,
    dead_segments: deadSegments,
    full_dead_segments: fullDeadSegments
  };
}

function collectOpenTwoPlusOpenOne(board, player) {
  assertBoard(board);
  assertPlayer(player);
  const n = board.length;
  const empty = CELL_EMPTY;

  const patterns = [];

  function scanLine(startR, startC, dr, dc) {
    const line = [];
    const coords = [];
    let r = startR;
    let c = startC;
    while (inBounds(r, c, n)) {
      line.push(board[r][c]);
      coords.push({ row: r, col: c });
      r += dr;
      c += dc;
    }
    if (line.length < 6) return;

    for (let i = 0; i <= line.length - 6; i++) {
      const a = line[i];
      const b = line[i + 1];
      const c1 = line[i + 2];
      const d = line[i + 3];
      const e = line[i + 4];
      const f = line[i + 5];

      // .XX.X.
      const p1 = a === empty && b === player && c1 === player && d === empty && e === player && f === empty;
      // .X.XX.
      const p2 = a === empty && b === player && c1 === empty && d === player && e === player && f === empty;
      if (p1 || p2) {
        const cells = [i + 1, i + 2, i + 3, i + 4]
          .filter((idx) => line[idx] === player)
          .map((idx) => makeCellKey(coords[idx].row, coords[idx].col));
        const lineKey = lineKeyFromCellAndDir(coords[i + 1].row, coords[i + 1].col, dr, dc);
        patterns.push({ cells, lineKey });
      }
    }
  }

  // 横向
  for (let r = 0; r < n; r++) {
    scanLine(r, 0, 0, 1);
  }
  // 纵向
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, 0);
  }
  // 主对角
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, 1);
  }
  for (let r = 1; r < n; r++) {
    scanLine(r, 0, 1, 1);
  }
  // 副对角
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, -1);
  }
  for (let r = 1; r < n; r++) {
    scanLine(r, n - 1, 1, -1);
  }

  return patterns;
}

function collectBrokenFourPatterns(board, player) {
  assertBoard(board);
  assertPlayer(player);
  const n = board.length;
  const empty = CELL_EMPTY;

  const patterns = [];

  function scanLine(startR, startC, dr, dc) {
    const line = [];
    const coords = [];
    let r = startR;
    let c = startC;
    while (inBounds(r, c, n)) {
      line.push(board[r][c]);
      coords.push({ row: r, col: c });
      r += dr;
      c += dc;
    }
    if (line.length < 5) return;

    for (let i = 0; i <= line.length - 5; i++) {
      const a = line[i];
      const b = line[i + 1];
      const c1 = line[i + 2];
      const d = line[i + 3];
      const e = line[i + 4];

      const p1 = a === player && b === player && c1 === empty && d === player && e === player; // XX.XX
      const p2 = a === player && b === empty && c1 === player && d === player && e === player; // X.XXX
      const p3 = a === player && b === player && c1 === player && d === empty && e === player; // XXX.X
      if (p1 || p2 || p3) {
        const stoneIdx = [i, i + 1, i + 2, i + 3, i + 4].filter((idx) => line[idx] === player);
        const cells = stoneIdx.map((idx) => makeCellKey(coords[idx].row, coords[idx].col));
        const lineKey = lineKeyFromCellAndDir(coords[stoneIdx[0]].row, coords[stoneIdx[0]].col, dr, dc);
        patterns.push({ cells, lineKey });
      }
    }
  }

  // 横向
  for (let r = 0; r < n; r++) {
    scanLine(r, 0, 0, 1);
  }
  // 纵向
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, 0);
  }
  // 主对角
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, 1);
  }
  for (let r = 1; r < n; r++) {
    scanLine(r, 0, 1, 1);
  }
  // 副对角
  for (let c = 0; c < n; c++) {
    scanLine(0, c, 1, -1);
  }
  for (let r = 1; r < n; r++) {
    scanLine(r, n - 1, 1, -1);
  }

  return patterns;
}

function countWarnings(board, player) {
  const x = analyzeLines(board, player);
  return { primary: x.primary, secondary: x.secondary };
}

/**
 * 对手「连线指数」：二级警报*4 + 死三*2 + 活2*2 + 活1 + 死2
 * 基于 analyzeLines 的 live/dead 线段长度分类计数。
 */
function opponentConnectionIndex(board, opponent) {
  const x = analyzeLines(board, opponent);
  let live1 = 0;
  let live2 = 0;
  let dead2 = 0;
  let dead3 = 0;
  for (const seg of x.live_segments) {
    if (seg.length === 1) live1++;
    else if (seg.length === 2) live2++;
  }
  for (const seg of x.dead_segments) {
    if (seg.length === 2) dead2++;
    else if (seg.length === 3) dead3++;
  }
  return x.secondary * 4 + dead3 * 2 + live2 * 2 + live1 + dead2;
}

/** 在所有可下点中选一手，使对手连线指数下降最多；若无任何下降则返回 null。 */
function findMoveToMaxReduceOpponentConnectionIndex(board, selfPlayer, opponent) {
  assertBoard(board);
  assertPlayer(selfPlayer);
  assertPlayer(opponent);
  const baseline = opponentConnectionIndex(board, opponent);
  const moves = getShuffledAvailableMoves(board);
  let bestMove = null;
  let bestReduction = 0;
  for (const mv of moves) {
    const copy = deepCopyBoard(board);
    placeStone(copy, mv.row, mv.col, selfPlayer);
    const after = opponentConnectionIndex(copy, opponent);
    const reduction = baseline - after;
    if (reduction > bestReduction) {
      bestReduction = reduction;
      bestMove = mv;
    }
  }
  return bestReduction > 0 ? bestMove : null;
}

function findMoveByWarning(board, player, warningKey, threshold) {
  if (warningKey !== "primary" && warningKey !== "secondary") {
    throw new Error("warningKey 只能是 primary 或 secondary。");
  }
  const baseline = countWarnings(board, player);
  const moves = getShuffledAvailableMoves(board);
  for (const mv of moves) {
    const copy = deepCopyBoard(board);
    placeStone(copy, mv.row, mv.col, player);
    const warnings = countWarnings(copy, player);
    if (warnings[warningKey]-baseline[warningKey] > threshold && warnings[warningKey] > baseline[warningKey]) {
      return mv;
    }
  }
  return null;
}

function findMoveToReduceOpponentWarning(board, selfPlayer, opponent, warningKey) {
  if (warningKey !== "primary" && warningKey !== "secondary") {
    throw new Error("warningKey 只能是 primary 或 secondary。");
  }
  const baseline = countWarnings(board, opponent);
  const baseVal = baseline[warningKey];
  const moves = getShuffledAvailableMoves(board);
  let bestMove = null;
  let bestReduction = 0;
  for (const mv of moves) {
    const copy = deepCopyBoard(board);
    placeStone(copy, mv.row, mv.col, selfPlayer);
    const after = countWarnings(copy, opponent);
    const reduction = baseVal - after[warningKey];
    if (reduction > bestReduction) {
      bestReduction = reduction;
      bestMove = mv;
    }
  }
  return bestMove;
}

function findWinningMove(board, player) {
  const moves = getShuffledAvailableMoves(board);
  for (const mv of moves) {
    const copy = deepCopyBoard(board);
    placeStone(copy, mv.row, mv.col, player);
    if (hasWinner(copy, player)) return mv;
  }
  return null;
}

function hasAnyWinningMoveOneStep(board, player) {
  return findWinningMove(board, player) !== null;
}

function findSetupMoveForNextWarning(board, player, warningKey, threshold) {
  if (warningKey !== "primary" && warningKey !== "secondary") {
    throw new Error("warningKey 只能是 primary 或 secondary。");
  }
  const movesA = getShuffledAvailableMoves(board);
  for (const a of movesA) {
    const boardA = deepCopyBoard(board);
    placeStone(boardA, a.row, a.col, player);
    const baselineA = countWarnings(boardA, player);

    const movesB = sortEmptyMovesByChebyshevFrom(boardA, a);
    for (const b of movesB) {
      if (chebyshevDistance(a, b) > MAX_B_CHEBYSHEV_FROM_A) break;
      const boardB = deepCopyBoard(boardA);
      placeStone(boardB, b.row, b.col, player);
      const warningsB = countWarnings(boardB, player);
      if (warningsB[warningKey]-baselineA[warningKey] > threshold && warningsB[warningKey] > baselineA[warningKey]) {
        return a;
      }
    }
  }
  return null;
}

function findForkSetupMove(board, player) {
  // 先计算初始状态下，有多少个位置落子后能增加 2 个威胁
  let initialThreatCount = 0;
  const initialMoves = getShuffledAvailableMoves(board);
  const initialWarnings = countWarnings(board, player);
  const initialSecondary = initialWarnings.secondary;

  for (const testMove of initialMoves) {
    const testBoard = deepCopyBoard(board);
    placeStone(testBoard, testMove.row, testMove.col, player);
    const afterWarnings = countWarnings(testBoard, player);
    if (afterWarnings.secondary - initialSecondary > 1) {
      initialThreatCount++;
    }
  }

  const movesA = getShuffledAvailableMoves(board);
  for (const a of movesA) {
    const boardA = deepCopyBoard(board);
    placeStone(boardA, a.row, a.col, player);

    const afterAWarnings = countWarnings(boardA, player);
    const origin = afterAWarnings.secondary;

    const movesB = sortEmptyMovesByChebyshevFrom(boardA, a);
    const validBList = [];  // 存储有效的B位置
    
    // 逐个测试B位置，每找到一个就和之前的所有有效B配对测试
    for (const b of movesB) {
      if (chebyshevDistance(a, b) > MAX_B_CHEBYSHEV_FROM_

毕竟是扒谱。用的简谱记法。@捡垃圾的管理员 #1

#============================以下为描述头定义==========================
V: 1.0
B: 星鱼2.1
B: 周某的小曲
Z: 周* 词
Z: 周* 词
Z: Altzin 制谱
Z: 声部修复版
D: A$
P: 4/4
#============================以下开始简谱主体==========================
Q1: |/ 0 0 0 0/ 0// 5/// 1'/// | 3'/ 5,/ 1/ 1'/ 0 0 | 4' 2/ 2'/ 0 0/ 0// 1'/// 3'/// | 5' 0/ 3/' 0 0 | 4' 2/ 2'/ 0 0 |
C:钢琴
Q1: |/ 1' - - - | 2' - - 0 | 3' - - - | 4' - 0 0/ 3/ |
C: 啊@@@@@@@夜
Q2: |/ 3' - - - | 4' - - 0 | 5' - - - | 6$' - 0 0/ 3/ |
C: 啊@@@@@@@夜
Q3: |/ 5 - - - | 6 - - 0 | 1' - - - | 1' - 0 0/ 3/ |
C: 啊@@@@@@@夜
Q1: |/ (5 5/) 3// 4// 5/. (4// 4/) 1/ | 3 - - 0/ (3// 4//) | (5 5)/. 5// 5./ (3// 3/) 6$/ | 5 - - 0/ 1/ |
C: 空@仿佛伸手@可得@海@水@是深不@可测@轻
Q1: |/ 7 1'/ 6/ - 0/ 1/ | 7 1/' (5/ 5) 0/. 5// | 5/ 4/ 4/ 3/ 4/. 1'// - | 2// 3/ 2// - - 0/ (3// 4//) |
C: 轻呼吸@告诉自己@@黑暗中别怕孤独寂@寞@流
Q2: |/ 4 - - - | 5 5/ 3/ - - | 0 1 6$ - | 2 - - - |
C: 轻诉自己@啊呜呜
Q3: |/ 4 - - - | 5 5/ (5/ 5/ 3/) - | 5/ 2/ 4/ 3/ 4 - | 5 - - - |
C: 轻诉自己@@暗中别怕孤呜
Q1: |/ (5 5/.) 5// 6$./ (4// 4/) 3/ | 3 - - 0/ (3// 4//) | (5 5/) 1'/ 5 5/ 6$/ | 5 - - 0/ 1/ |
C: 星@在星空@划过@点@燃@我心中执着用
Q2: |/ 3'// 3/.' 3'// 3/.' 2' 1' | 3' - - 0 | 0/ (1// 2//) 3 2 3 | 3 - - 0/ 1/ |
C: 哒啦哒啦@@@@@点@燃新中着@用
Q3: |/ 3'// 3/.' 3'// 3/.' 4' 1' | 5' - - 0 | 0 1 - 1' | 7 - - - |
C:哒啦哒啦@@@@@燃中着
[fenye]
Q1: |/ 7 1'/ 6/ - 0/ 1/ | 7 1'/ 5/ - 0/ 3// 3// | 4/. (4// 4/) (4// 5//) 6$./ (1//' 1'/) 1/' | 2' - - - | 0 0 0 2'// 3'// 2'// 5// |
C: 尽全力@绝不退缩@只为兑现@曾@经的@承诺@@@抬头仰望
Q2: |/ 4 4/ 1/ 0 0/ 1/ | 5 2/ (2/ 3) 0/ 3// 3// | 4./ (2// 2/) (2// 3//) 4./ (6//$ 6/) 2'/ | 1' - - - | 0 0 0 0 |
C: 尽全力@@绝不退缩@@只为兑现@曾@经的@承诺
Q3: |/ 0 1' 4' - | 3' 0/ 3'/ 1#' 0 | 0 0/ 2//' 3//' 4' - | 5' - - - | 0 0 0 0 |
C: @啊@@@退缩@@@只为啊啊
Q1: |/ 2'// 3/.' 2'// 3/'. 2'// 3'./ 2'// 3'// 2'// 5// | 2'// 3/.' 2'// 3/'. 2'// 1'./ 2'// 3'// 2'// 1'// | 1'/ 6' 6'/^ 5'/ 3'// (1'// 1'./) 5// | 6/ 1'// (1'// 1'/) (3'// 4'//) (3'// 2/.') 2'// 3'// 2'// 5// |
C: 漫天璀璨星河在迷途中点亮盏盏灯火穿越茫茫夜色再也不怕@大海无边@辽@阔@无论走过
Q2: |/ 5// 1/.' 5// 1/'. 5// 1'./ 3// 3// 3// 3// | 6// 1/.' 6// 1/'. 3// 1'./ 0 | 4/ 4 4/^ 5/ 5// (3// 3./) 1// | 2/ 1// 2// - 4 0 |
C: 漫天璀璨星河在迷途中点亮盏盏灯火@夜色再也不怕@大海无边辽
Q3: |/ 0./ 5'// - - 0 | 0/./ 5'// 5' - 0 | 1'/ 6' 6'/^ 5'/ 3'// (1'// 1'./) 5// | 6/ 1'// (1'// 1'/) (3'// 4'//) (3'// 2/.') 0 |
C: @啊@@灯火@夜色再也不怕@大海无边@辽@阔
Q1: |/ 2'// 3/.' 2'// 3/'. 2'// 3'./ 2'// 3'// 2'// 5// | 2'// 3/.' 2'// 3/'. 2'// 1'./ 2'// 3'// 2'// 1'// | 1'/ 6' 6'/^ 5'/ 3'// (1'// 1'/) 5// 5// | 4'/. (3//' 2) - 3'/ 3'/ |
C: 多少潮起潮落分分秒秒孤独向前穿梭千难万险它也不能阻挡@与你相见@那一
Q2: |/ 1'// 1'/. 1'// 1'/. 1'// 1'./ 2'// 3'// 2'// 5// | 5// 1'./ 5// 1'./ 5// 1'./ 2'// 3'// 2'// 1'// | 1'/ 1' 1'/^ 3'/ 1'// (5// 5/) 5// (5// | 5/) (5/ 6/. 5//) 6$ 5/ 5/ |
C: 多少潮起潮落分分秒秒孤独向前穿梭千难万险它也不能阻挡@与你@相@@见
Q3: |/ 0/ 5'// 5'// 0/ 5'// 5'// 0/ 5'// 5'// 0 | 0/ 5'// 5'// 0/ 5'// 5'// 0 0 | 1'/ 4' 4/'^ 3'/ 1'// (5// 5/) 5// 5// | 4'/. (3//' 2) - 3'/ 3'/ |
C: @多少@潮起@潮落@@孤独@向前@@它也不能阻挡@与你相见@那一
Q1: |/ 1' - - - |
C: 刻
Q2: |/ 3 - - - |
C: 刻
Q3: |/ 5 - - - |
C: 刻

RT

一打开窗，一股毛骨悚然的阳光照入他的眼睛，穿过了他的晶状体、玻璃体，在他的视网膜上聚焦。阳光过于强烈，点燃了他的视网膜————他，瞎了。
这是一个可怜的人的故事，他在仅仅7岁就瞎了，他要靠这一双像个装饰品一样的眼睛度过他的余生了。
今天是他的第一天，他在起床时就遇到了困难，他找不到自己的衣物了，幸好这是他的爸爸妈妈还在，便帮他解决了这个棘手的问题。经过一番连滚带爬、屁滚尿流地艰苦摸索后，他来到了厕所，奇怪的是，他没有坐在马桶上————取而代之的是水槽，大便拉在了水槽里，这真是糟糕透了，随后他又一路摸索来到了马桶边，舀起水开始刷牙，这真是糟糕透顶了，一不小心，他终于摸到了马桶那个带把手的部位，他意识到不对，吐了，又连滚带爬搞得全身都是呕吐物，行尸走肉，血流成河，他恨不得结束这一切。
中午，由于眼睛的问题，可怜的他连猪都不会杀了，他努力的摸索着猪身上带有牙齿和眼睛的部位，直到他摸到了，他的手指被猪一口咬下，鲜血哗哗流下，他即嗷叫了一声，轰然倒下。
父母也回来了，发现儿子已经休克，满脸泪水，立即拨打120，所幸救活了，顺便治好了手指和瞎眼，他看着血淋淋的自己，又看看高昂的费用单，下定决心，终身对父母表示感谢。
回到家后，他再次打开了窗户，不过带上了墨镜，静静观察着氦闪前的太阳......

六年级时，我加入了立达合唱团。
这是一个悲壮的社团，也是立达唯一的社团。学校里，不管是领导还是老师，都不支持合唱团。
六年级时，我热爱合唱，技术可佳，在预备合唱团里迅速占据了最高地位，那时的我并不知道某些事，觉得合唱团是一个美好的团体，直到有一天：合唱团要去瑞士！我很早就知道了这个事。通知详细信息的时候，年级领导没有叫我。我不知道怎么回事，闯了出去，经过长达一个小时的谈判，也不知道他们想干嘛，只是觉得这领导有问题。
我们顺利完成了一些节目，例如繁星。这是我们最经典的曲目，所有人现在都还会唱。
初一时，排练照常，我们搬到了大同音乐教室里，和当时的初二取得了非常大的成就。当时我们的卜老师才告诉我：预备的活动她强烈要求领导通知我，但是领导没有这么做。这让曾经的卜老师感受到了学校的黑暗，同时现在的我也感受到了。合唱团这片学校唯一的净土，正在被侵蚀！
我内心一片怒火，特别是当卜老师被多个班主任大骂的时候。
到了初一下，我们要参加艺术节表演。突然，在接近表演的那一刻，校领导强行干掉了初当时的初二，表演危在旦夕，我们只有4天了。卜老师甚至还准备再加一首歌。学校不给钱，我帮卜老师打谱，扒谱，为表演增加了"星鱼"这首歌。接下来几天排练，我们合唱队以牺牲之态度，搞定了表演。表演非常成功。
这途中，卜老师对我说了一句话，大概意思就是如果不是她，我不能继续留在合唱团。这句话让我非常感动。是的，我是疯子，她也是，只有疯子才可以运用好疯子，而那些所谓的校领导，只会排斥一切特殊的、纯净的、童真的。
这之后，我便臣服于卜老师，在合唱团至此对她完全支持。她常常说起社会各种不好，让我懂得了更多、更多、更多。合唱团这个社团，也成为了我的骄傲，一次表演前，我对大队部领导喊出：合唱是我的使命，为合唱而牺牲。

纯虚构。请勿当真
国网之旅
在最近，有许多企业进行了对外开放的展览会，例如去年的支付宝非洲建设讲座和海尔智能生活展览。就在今年的2月5日，春节刚过，上海国家电网分公司也举行了这样一场环保主题的展览。
这种展览听起来离我们很遥远，那我是怎样发现这样一场展览的呢？其实它就隐藏在生活中。早在几周前，我偶然翻我家的邮箱 ，看到电费单上有这场展览的介绍和二维码，我毕竟多次参与这种活动，有点兴趣，就填表参加了。
这次展览主要有三个部分，先是通过一场讲座，介绍了国家电网进行的可持续化发展。随后是开放式展会，通过微缩楼房和其它展品介绍了国家电网是怎么从没有电到家家有电的。第三个是问答环节，有十几位专业人士排成方阵，可以自由提问。
大家都知道风电是可持续发展的清洁能源 ，但是也不乏一些问题。讲座里，他们提出了用电池或飞轮存储风电的电量来在一定程度上解决了风电时有时无的问题，介绍完了这个，他们又介绍了他们在上海周边的风电布局，包括滴水湖、宝山、北岸三个大型风电区，这些风电设施为在上一年中上海贡献了大约23%的电量，看起来也是十分可观的。
在开放式展会里，我穿梭其中，让人感到无论是在灯光、模型还是设计布局方面都十分震撼，这里介绍了国家电网自主创新研发了多种大型煤发电机才最终让电走进了千家万户，还有一面展墙风格独特，主要展示了国家电网的愿望:这些煤发电机不是终点，它们过度排放二氧化碳，对全球温室效应问题有很大的加剧，要在将来实现80%以上的清洁能源使用。
最后，在问答环节，我向国家电网的工作人员提出问题:发一度电要多少煤？320g。就相当于发一度电会产生1.173kg的二氧化碳，这是一个相当大的数目，很令人惊异，让我更加深刻地体会到了使用清洁能源的必要性。
这次的展会令人记忆深刻，国家电网在环保方面也默默做了很多。希望在用电量不断增加的未来，国家电网更能够做好清洁能源的使用，我们也可以为此献出一份力。

 《佩奇家的电 3》
钱辰飞
   乔治入狱的那天晚上，佩奇在梦中听到老鼠说话。并不是吱吱叫，而是清晰的句子："电路是血管，我们是血液，不能没有我们。"
    佩奇惊醒，发现床头插座里钻出一只眼睛发蓝的老鼠。它没有逃，而是静静地看着佩奇，似乎在等待指令。猪妈妈自从上次事件后就变得沉默，整天盯着电视里的土豆革命新闻发呆。电视信号时好时坏，画面里的土豆先生们占领了市政厅，却在演讲中途突然变成薯条促销广告。
    监狱传来消息，乔治用老鼠控制了整个监狱的电路，囚犯们把他奉为"电力酋长"。白猫警长不敢轻举妄动，因为乔治手握着一只发烫发红的老鼠——任何强行逮捕都可能让整个监狱爆炸。
    佩奇决定去找乔治。她带着一袋从旧电线上收集的老鼠，来到监狱。白猫警长拦在门口："请出示探访许可。""我有这个。"佩奇掏出一只发光的老鼠。 警长身体发抖，万般畏惧，退后一步："你...你也..."
监狱大门自动打开，乔治站在走廊尽头，手中握着一根缠绕着老鼠的电线，囚犯们安静地跟在后面。 "姐姐，你来了。"乔治说，"老鼠告诉我，真正的电路不在房子里，也不在监狱里，而在天上。"
    当晚，全城停电。不是往常的局部停电，而是彻底、完整的黑暗。连应急灯都熄灭了。只有佩奇家的阁楼发出蓝光——那些老鼠聚集在那里，组成一个奇怪的图案，像一根八分之五波长天线的电场图。
    猪爸爸爬上阁楼，吓得差点摔下去：成千上万只发蓝光的老鼠组成一个巨大的圆盘，缓缓旋转。佩奇和乔治站在中间，手拉着手。 "我们在发送信号。"佩奇说，"到整个城市。"
    一些土豆先生们组成了"土豆解放阵线"，占领了发电厂。但他们发现，电厂早已空无一人，控制室里坐着一只巨大的、由无数小老鼠组成的老鼠形智能体。它说："你们自由了，因为我们已经接管了一切。"
棕熊医生在急诊室里忙得一塌糊涂。病人不是触电或被老鼠咬伤，而是出现奇怪的症状：身体僵硬，动作一顿一顿，像木偶。最可怕的是，他们开始无意识地说出电流参数："电压220伏...频率50赫兹...佩奇…总指挥…乔治"
    猪妈妈终于开口了："我们不该换掉那些老鼠。它们不是在破坏电路，它们就是电路本身。"
    全城陷入混乱：汽车随机启动，红绿灯同时亮起三种颜色，家用电器自发运行。冰箱门开合，像在说话，洗衣机疯狂旋转，像在跳舞。
    佩奇和乔治站在监狱屋顶，看着这座失控的城市。 "老鼠说，它们累了。"乔治轻声道，"它们想休息。" "那谁来维持一切运转？"佩奇问。 乔治没有回答，只是举起手中的老鼠。它已经不再发光，身体冰冷僵硬。
    次日，老鼠全部消失，电器也无法打开。"电路定律全部失效了。"佩奇说。

企鹅社2024年9月3日九时立达三楼电 立达一学生不遵守校纪校规，偷偷于学校建造小型科学窝点，与另外三名立达学生研究三日，用立达的破水管造出了战术核显卡，取名RTX690，用于纪念美国著名军事家冉挞希，后被学校于九月三日六时赶出立达。由于处置及时，立达的名誉没有受损，一小时后，此学生又在大同建设了科研窝点，进行下一步研究。半小时后，美军突然爆出了一整个航母战斗群被击沉的消息，经过单方面调查，发现是由一艘中国渔船进行打击的。我方积极配合调查，最终确认是由步阳337型渔船搭载战术核显卡的改进型号对美国海军进行了"毁灭性的打击"，据了解，此船是由上述所提到的立达学生在大同境内进行改造的，只要一发就能摧毁一整个航母战斗群。面对如此严峻的情况，立达对该名学生进行了严厉的处罚，后开除学籍。
此事过后，全国都震惊立达学生能够有如此强大的能力，本报记者连夜赶写出这篇文章，以便通过报纸更加广泛的传播这一消息。

我以前写的，没剩几个了，发完就没了@捡垃圾的管理员 #1

与时间战斗——回眸、驻足与前行：光阴里的蚂蚁
这是一个混乱的世界，战火纷飞，连绵不断。世界之黑暗，从来无人打破，而此时，世界诞生了一只蚂蚁。这在平常可能只是平平无奇的事罢了，而现在，这只蚂蚁将会改变这个世界！
小蚂蚁睁开了眼睛，它还没有明白它的存在将会对世界造成多大的影响，也没有明白打仗的意义，只是觉得好玩...是的，正如你们所想，这只蚂蚁天天爬出去，用它那平庸————哦不是微不足道、毫不起眼的宝贝“光阴树叶”去跟那些比它大十倍、上百倍乃至几百万倍的动物抗争，天天受轻伤，五天一重伤，搞得我旁白都十分心疼。
日复一日，年复一年，日子过得飞快，小蚂蚁的寿命已经过半，但是它似乎还是没有什么起色，不过只是让蚂蚁洞里最好的光阴树叶给了它，又当了个蚂蚁王罢了，丝毫看不出这是只将来要拯救世界的蚂蚁。与以前不同的是，小蚂蚁经常躲到自己的窝里，不知道在干什么。看！小蚂蚁又进房间了，这次让我们把旁白视角切进去。
小蚂蚁认真地摆弄这什么。？？！是光阴树叶！但是上面显示着过去和未来的空间，就像我的旁白软件那样，我想。我正寻思着我的旁白软件可以调整时间，突然，小蚂蚁从床上穿到了床下，时间倒流了，小蚂蚁每次那么久才出来，原来只是时间在跳变。
小蚂蚁虽说掌握了科技，但还是三天两头重伤，每天练四个小时的武术，能力却毫不见长，要不是它的皇冠，在蚂蚁群中根本找不到它。小蚂蚁也这样觉得，不停的回拨光阴树叶，在同一天练了八百个小时，回眸过去，看起来毫无长进，我开始不再相信它能改变世界。它决定继续前行，对时间放行了，日子又开始一天天地过去了。
小蚂蚁快走到生命的尽头了，现在的它已经老态龙钟，世界还是那样，而小蚂蚁已经不可能做出什么出格的事情了。
一天，它糊涂的拿出了光阴树叶...！它在干啥？？它在干啥？？它稀里糊涂地把时间调到了宇宙的尽头。。。
一片死寂，没有空间也没有时间。呀，大爆炸开始了，新的世界没有战火，没有硝烟，一片生机。然而这一切只是巧合，平庸的巧合，一只平庸的蚂蚁拯救了世界。

To 10
唉，乱七八糟。几个月的时光岁月，开学初的的东西历历在目，我再一次翻看胡言乱语。它依旧让我感动，这说明我的初心还在。我不得不感叹，一个是这么久了，这玩意我还能想看就看，一个是怎么这么快就过去这么久了。时间，走了就不会再回来，也走的越来越快，我感觉一晃就到期中了，我一事无成。没有大项目，只有聊天。一看胡言乱语的日期，20250226...我震惊了。我甚至不相信那时我在上学，我真是个没有时间感的人，转眼间过去了这么多时间，一番折腾后我和你的关系已大不如前，而我却还沉浸在开学，感觉胡言乱语就是几天前的事情，但，一算就不对了，三个月了，你已经变了，再也写不出这种东西了。每一篇文章都成为了绝版，每一天的你都不同于于往日，感觉我浪费了好多时间，好多不一样的你。虽然我一直自认为我没变，自认为我不会变，不过，现在，我也不是特别相信了，我怀疑，我已经在时间的作用下，默默的无声的变了。时间的作用很强大，改变一切，改变同学，改变你，都是无声无息，只有静心好好想想，才会发现这些，发现我对你，对世间的理解，都不在当下。铭记胡言乱语，它是我的一段美好，是一段历史存在的写照，一段最美好快乐的历史。
Reply from 10
时间，是个神奇的东西

修复了大量bug，加入了历史记录功能，但是移除了现在之前的存储以升级。

不用这么自嘲哟@abellee

当然不是官方的@大帅哥 #1

已开源github。大家多多部署。
https://github.com/QianCF/linux.sb-snapshot

删帖找回、免积分的全局搜索

LinuxSB-Snapshot/1.0的UA是这个项目使用的

体验：https://www.altzin.com/linuxsb

快没了。是我的output集。@Yan #1

用词只是因为省算力@altzin #10

问题是一些bert模型是以字符分token的

P.S.未来某一天，我可能会把它刻在电路板上，用嘉立创送过去。但怕她不喜欢。

你好，陈欣恬，我是钱辰飞。很快就又到你的生日了，这一年来，你从未回我一句话。上次你生日，那个球可真好玩，可是我估计一辈子也不会再做出那个球了，因为我已经忘了怎么做了，这有点可惜。初二下对我是很有意义的，这是在小组死后我拥抱个人的降级选择，我和你发生了许多有趣的事情，这些事情历历在目，不可再来，但我也对你做了很多错事，例如硬要送你钱，即使你不要，或者乱说爱你，还有在11上把你弄摔倒。这些事情是个大问题，因为我竟然不考虑你的感受，这可能也是你离开的原因吧。我现在好抱歉，我一直对你做错事，让你在学期末时其实很讨厌我了，而且我在小组群里一直发乱七八糟的东西，偏离了小组的宗旨，让我被其他人也讨厌。桃源兴城苑我是不敢再进去了，我也不应该进去，虽然经常路过，但也就只能远远看看，我也不知道你到底还在不在里面，只是暗中相信你还在。那里真的挺美，地下天窗好好看，好有趣，你和我在那里向下看真实有趣又神经。未来还能不能见到你，我对这个问题的答案是偏向于否定的，我其实不觉得你会想要见到我，反而见到米豪的概率大一点，我可能会带米豪去浙江。
再见，来自小组：钱辰飞。

为什么有这么多伪装官方的…我好奇一下…这是什么文化吗？@捡垃圾的管理员 #3

可能…就是用来躲避某些平台的审核吧…毕竟机器看不到模糊的文字，人也看不到模糊的文字，但是又能明显知道这里有文字需要用这个工具还原@奥特之王 #3

为什么作文帖这么多人看 技术帖没人看