第一步：先化簡再接線。整條式子是 \(\lnot(X \lor Y \lor Z)\) 的形式，其中 \[X = \lnot A \lor B,\qquad Y = \lnot(A \land \lnot C),\qquad Z = \lnot(A \lor \lnot A).\]

觀察 \(Z\)：\(A \lor \lnot A = 1\)（互補律——恆真）， 所以 \(Z = \lnot 1 = 0\)。\(Z\) 對 OR 沒有貢獻（同一律），整式變成 \(\lnot(X \lor Y)\)。

套用 De Morgan： \[\lnot(X \lor Y) = \lnot X \land \lnot Y = \lnot(\lnot A \lor B)\;\land\;(A \land \lnot C) = (A \land \lnot B)\;\land\;(A \land \lnot C).\] 用冪等律去掉重複的 \(A\)： \[\boxed{\;\text{Out} = A \land \lnot B \land \lnot C\;}\]

電路（2 個 NOT、2 個 AND）：

真值表驗證（8 列全檢查）：Out 只在 \(A{=}1, B{=}0, C{=}0\) 時為 1。代回原式： \(X = \lnot 1 \lor 0 = 0\)、\(Y = \lnot(1 \land 1) = 0\)、\(Z = 0\)， \(\lnot(0\lor 0\lor 0) = 1\) ✓。 再抽查一列，例如 \(A{=}1,B{=}0,C{=}1\)： \(Y = \lnot(1 \land 0) = 1 \Rightarrow\) Out \(= \lnot(\cdots\lor 1) = 0\) ✓。

關鍵觀察：Out 與 \(A\) 無關！把 \(A{=}0\) 的前 8 列與 \(A{=}1\) 的後 8 列並排比較：兩組對 \((B,C,D)\) 的輸出 完全相同（\(1,0,1,0,1,1,0,0\)）。 於是這其實是三變數問題 \(f(B,C,D)\)。

三變數卡諾圖（列＝\(B\)，行＝\(CD\) 格雷碼順序）：

• 綠色群：\(B{=}0\) 列上 \(D{=}0\) 的兩格 （\(CD{=}00\) 與 \(10\)，左右迴繞相鄰）\(\Rightarrow \lnot B \land \lnot D\)；

• 橘色群：\(B{=}1\) 列上 \(C{=}0\) 的兩格 （\(CD{=}00\) 與 \(01\)）\(\Rightarrow B \land \lnot C\)。

\[\text{Out} = (\lnot B \land \lnot D) \lor (B \land \lnot C)\]

只用 4 個閘的實作（NOR 把「兩個 NOT＋一個 AND」壓成一顆—— 題目允許任何 2 輸入閘）： \[\lnot B \land \lnot D = \lnot(B \lor D) = B \downarrow D \quad(\text{De Morgan})\]

閘數：NOR＋NOT＋AND＋OR \(= 4 \le 6\) ✓。 （如果只想用 AND／OR／NOT：\(\lnot B\)、\(\lnot D\)、\(\lnot C\)、 兩個 AND、一個 OR，正好 6 個，也在限制內。）

驗證（抽查全部 8 種 \((B,C,D)\)）： \(000{\to}1\)✓、\(001{\to}0\)✓、\(010{\to}1\)✓、\(011{\to}0\)✓、 \(100{\to}1\)✓、\(101{\to}1\)✓、\(110{\to}0\)✓、\(111{\to}0\)✓。 \(A\) 腳位留空不接即可（skeleton 已有的輸入腳位不需要全部用上）。

整體結構：\(8\) 個字 \(\Rightarrow\) 位址 \(3\) 位元 （\(2^3 = 8\)）；字長 16 位元 \(\Rightarrow\) 每個字用一顆 16 位元暫存器。RAM＝「暫存器陣列＋寫入選路＋讀取選路」， 這正是第 3 週「從暫存器到 RAM」的標準構造：

• 寫入路徑（DEMUX）：in（16 位元） 同時接到全部 8 顆暫存器的 D 輸入； load 訊號經過一個 1-to-8 解多工器， 由 address 選擇送往哪一顆暫存器的 enable（load）腳。 這樣每個時脈緣最多只有被選中的那顆暫存器會吃進新值。

• 讀取路徑（MUX）：8 顆暫存器的輸出接到一個 8-to-1 多工器（select＝address），輸出即 out。 多工器是純組合邏輯，所以位址一變、 out 立即跟著變——正好滿足「不等時脈就更新」的要求 ✓。

• 下降緣觸發：兩種作法擇一—— (1) 在 Logisim 中把每顆暫存器的 Trigger 屬性改成 Falling Edge；或 (2) 保持上升緣觸發，但把時脈先過一個 NOT 閘再接進暫存器 （時脈反相後，原本的下降緣變成上升緣）。 兩者行為等價，元件都在允許清單內。

Logisim 實作細節：

• 暫存器 Data Bits 設 16；DEMUX／MUX 的 Select Bits 設 3（Logisim 內建的多工器可以直接設定， 不必自己用 2-to-1 疊出 8-to-1——但用 7 顆 2-to-1 疊成樹也可以）。

• 暫存器的 enable 腳（Logisim 暫存器上的 en） 接 DEMUX 的對應輸出；DEMUX 沒被選中的輸出為 0， 所以其他暫存器保持原值。

• 為什麼讀取不受時脈影響？讀取路徑上完全沒有 時序元件——暫存器的 Q 端隨時可讀，MUX 又是組合邏輯， 所以 address 改變後經過閘延遲 out 就更新。 「更新儲存值」才需要等下降緣。

解讀規格。這是一個週期性的「高 \(n\) 拍、低 1 拍」 脈寬產生器（\(n\)＝開始輸出時取樣到的 in）：

• 進入「高相位」時把 in 拍照存起來（記作 \(N\)）—— 之後比較用的是這張快照；

• 高相位維持 \(N\) 個完整週期後，轉入「低相位」正好 1 個週期， 然後重新取樣 in、開始下一輪；

• 中止規則：高相位期間若目前的 in \(\ne N\)， 下一個上升緣立即轉入低相位（也是 1 個完整週期）， 再照常重新開始；

• \(N = 0\) 的邊界情況：「高 0 拍」＝根本不拉高， out 持續為低，每拍重新取樣直到 in \(\ne 0\)。

資料路徑＋狀態機設計（全部元件可用， 所以放心用 Logisim 內建的 Register、Counter、Comparator）：

每個上升緣的轉移規則（\(P\)＝相位正反器，\(P=1\) 表示高相位， out 直接輸出 \(P\)，是 Moore 式輸出）：

為什麼計數要「進高相位時設 \(C{=}1\)、\(C{=}N\) 時離開」？ 進入高相位的那個上升緣本身就開始了第 1 個高電位週期， 所以 \(C\) 記「目前正在進行第幾拍」；當 \(C = N\) 的那拍結束 （下一個上升緣）正好滿 \(N\) 個完整週期，此時轉低 ✓。 低相位不需要計數器——它固定只有 1 拍，下一個上升緣一定離開 （除非 \(in=0\) 持續為低）。

元件層面：\(in \ne N\) 用兩顆 XOR（逐位元比較）＋OR； \(C = N\) 用兩顆 XNOR＋AND；\(P\) 用一顆 D 正反器， \(D\) 端接上表的組合邏輯；\(C\) 用 2 位元計數器 （load＝進高相位、值 01；enable＝\(P \land\) 未離開）。 由於「全部元件皆可」，也可以直接用 Logisim 的 Counter 與 Comparator 元件，接線更少。

逐欄理由：

• \(A \land B\)（AND）：兩者皆 1 才是 1——只有最後一列。

• \(\lnot(A \lor B)\)（NOR）：OR 只有 \(00\) 時為 0，取反後 只有 \(00\) 列是 1。

• \(A \oplus B\)（XOR）：「恰好一個為 1」——\(01\)、\(10\) 兩列。

• \(A \to B\)（蘊涵）：唯一為 0 的情況是「前提真、結論假」 （\(A{=}1, B{=}0\)）；\(A{=}0\) 時整條蘊涵空虛地為真 （vacuously true）——這是最常寫錯的一欄。

先記住兩個基本事實：\(\mathrm{NAND}(x,x) = \lnot x\)（NAND 當反相器）， 以及 De Morgan：\(\lnot(\lnot A \land \lnot B) = A \lor B\)。

b) 的補充推導：\((A \lor \lnot B) \land (\lnot A \lor B)\) 恰好是「\(A\) 與 \(B\) 相等」（XNOR）——代 \(A{=}B\) 得 1、 \(A{\ne}B\) 得 0；最外層 NAND 再取反，得到 XOR ✓。 也可以直接列真值表：\(A{=}0,B{=}1\) 時 內層兩個 NAND 輸出 \((0 \Rightarrow) 1 \cdot \lnot(0\land 1){=}1\)…… 最後輸出 1；\(A{=}B\) 時輸出 0。

記憶法（第 1 週核心）：NAND 是功能完備的—— \(\lnot x = \mathrm{NAND}(x,x)\)（1 閘）、 AND＝NAND＋反相（2 閘）、OR＝兩個反相＋NAND（3 閘）、 NOR＝OR＋反相（4 閘）、XOR＝4–5 閘。 看閘數就能先猜個大概，再驗證。

關鍵恆等式（二補數）：對 16 位元字 \(a\)， 逐位元取反等於 \(\lnot a = -a - 1\) （因為 \(a + \lnot a = 1111\ldots1_2 = -1\)）。 把它機械地代入即可：

• \(\lnot y = -y-1 \Rightarrow x + \lnot y = x - y - 1\)； 再取反：\(\lnot(x-y-1) = -(x-y-1)-1 = \boxed{\,y - x\,}\)。 （這正是 ALU 表中 \(y-x\) 那一列的實作原理！）

• \(\lnot 0 = -0-1 = -1\)，所以 \(\lnot 0 + 0 = \boxed{\,-1\,}\)（常數 \(-1\)， 即 0xFFFF）。

• \(\lnot 0 = -1 \Rightarrow x + \lnot 0 = x - 1\)； 取反：\(\lnot(x-1) = -(x-1)-1 = \boxed{\,-x\,}\) （取負，ALU 表中的 \(-x\)）。

背景：Hack ALU 只有一個加法器與 AND， 所有「減法、取負、常數 \(\pm 1\)」都是用 「先取反、再加、再取反」這類恆等式拼出來的； 考卷附的 reference sheet 有 ALU 行為表， 這題測驗你是否理解表格背後的代數而不只是背表。

先列出所有為 1 的格子（記作 \((A,B,C)\)）： \(C{=}0\) 片：\((0,1,0)\)、\((1,0,0)\)、\((1,1,0)\)； \(C{=}1\) 片：\((0,1,1)\)、\((1,1,1)\)。

觀察分群：

• \(B{=}1\) 的四格全部為 1 （兩張表的 \(B{=}1\) 整欄）\(\Rightarrow\) 蘊涵項 \(B\)；

• 剩下唯一的 1 是 \((1,0,0)\)，由 \(A \land \lnot C\) 覆蓋 （它同時覆蓋 \((1,1,0)\)，無妨——重疊不影響 OR）。

\[f = B \lor (A \land \lnot C) \quad\Rightarrow\quad \boxed{\text{答案：d)}}\]

逐一排除其他選項（找一格反例即可）：

只有 d) 正確，所以 e)「不止一個」也不成立。

方法提示：多張卡諾圖切片＝一個三變數函數。 選擇題不必自己化簡到最簡式——「把每個選項對 8 格逐一驗證、 找反例排除」通常更快也更保險； 特別注意 c) 與 d) 只差在 \((0,1,1)\) 這一格。

把波形整理成事件表。\(En\) 是週期 2 的方波： 上升緣在 \(t = 0, 2, 4, 6, 8\)；下降緣在 \(t = 1, 3, 5, 7, 9\)。 \(D\) 的變化（從圖上讀出）：起始為 1， 在 \(t \approx 0.9\) 落下、\(3.5\) 升起、\(4.8\) 落下、\(5.5\) 升起、 \(7.1\) 落下、\(8.1\) 升起後保持到底。

在每個時脈緣取樣 \(D\)（正反器的 \(Q\)＝最近一次觸發緣取到的 \(D\)；圖上 \(D\) 的變化都刻意錯開時脈緣，唯一要小心的是 \(t{=}7\)：\(D\) 在 7 之後一點點才落下，所以下降緣 7 取到的是 1）：

四個時間點的比較（\(Q\)＝「最近一個觸發緣」的取樣值）：

\[\boxed{a = \text{different},\quad b = \text{different},\quad c = \text{same},\quad d = \text{different}}\]

關鍵路徑＝輸入到輸出「最慢」的一條路。 逐一把每條路徑的延遲加總：

\[\boxed{\text{答案：電路 2)（關鍵路徑 } 5+10+5 = 20\text{ ps）}}\]

直覺：OR 是最貴的閘（15 ps）—— 電路 2 是唯一完全不用 OR 的選項， 它的三層閘全是便宜的 NOT／AND，總和反而比別人「兩層」還短。 關鍵路徑比的是深度加權延遲，不是閘的數量或層數。

a) 逐位計算（base 16 直式）： \[\mathtt{E} + \mathtt{5} = 14 + 5 = 19 = 16 + 3 \;\Rightarrow\; \text{寫 } \mathtt{3} \text{、進 } 1;\qquad \mathtt{9} + \mathtt{3} + 1 = 13 = \mathtt{D}.\] \[\boxed{\mathtt{0x9E} + \mathtt{0x35} = \mathtt{0xD3}}\] 驗算（十進位）：\(158 + 53 = 211 = 13 \times 16 + 3\) ✓， 未超過 8 位元範圍（\(\le 255\)），無溢位。

b) 逐位計算： \[\mathtt{D} + \mathtt{1} = 13 + 1 = 14 = \mathtt{E};\qquad \mathtt{D} + \mathtt{B} = 13 + 11 = 24 = 16 + 8 \;\Rightarrow\; \text{寫 } \mathtt{8} \text{、進 } 1.\] 總和是 \(\mathtt{0x18E}\)（\(221 + 177 = 398 > 255\)，溢位） ——依題意捨棄進位，保留低 2 位： \[\boxed{\mathtt{0xDD} + \mathtt{0xB1} = \mathtt{0x8E}}\]

CMOS 判讀口訣（第 4 週）： p 型在閘極 \(=0\) 時導通、拉高（連 \(V_{dd}\)）； n 型在閘極 \(=1\) 時導通、拉低（連 GND）。 串聯＝AND（兩顆都導通才通）、並聯＝OR。

讀上拉網路（何時 \(F=1\)）： \(V_{dd} \to F\) 的通路＝「\(A\) 的 p」串聯 「\(B\) 的 p 並聯 \(C\) 的 p」。 p 型在 0 導通，所以通路導通條件： \[(A = 0) \land \bigl((B = 0) \lor (C = 0)\bigr) \quad\Longrightarrow\quad F = \lnot A \land (\lnot B \lor \lnot C).\]

用下拉網路交叉驗證（何時 \(F=0\)）： 「\(A\) 的 n」並聯「\(B\)、\(C\) 的 n 串聯」， n 型在 1 導通：\(A \lor (B \land C)\)。 取反：\(\lnot(A \lor (B \land C)) = \lnot A \land (\lnot B \lor \lnot C)\) ——與上拉一致（互補網路）✓。 \[\boxed{F = \lnot A \land (\lnot B \lor \lnot C)\quad\text{（第一個選項）}}\] 這其實就是 OR-AND-INVERT：\(F = \lnot\bigl(A \lor (B \land C)\bigr)\)。

第一步：把 \(355/64\) 寫成二進位。 \[355 = 256 + 64 + 32 + 2 + 1 = 101100011_2, \qquad 64 = 2^6,\] 所以 \(355/64 = 101100011_2 / 2^6 = 101.100011_2\) （把小數點左移 6 位）。

第二步：正規化（調整成 \(1.xxx \times 2^E\)）： \[101.100011_2 = 1.01100011_2 \times 2^{2}.\]

第三步：填三個欄位。

• sign：數字是負的 \(\Rightarrow\) \(\boxed{1}\)。

• exponent：實際指數 \(2\) 加偏移 \(7\)： \(2 + 7 = 9 = \boxed{1001_2}\)（4 位元）。

• mantissa：正規化後小數點後的位元 \(01100011\)，右邊補 0 湊滿 11 位： \(\boxed{01100011000}\)。 （前導的 1 是隱含位元，不儲存。）

\[\text{sign} = 1,\qquad \text{exponent} = 1001,\qquad \text{mantissa} = 01100011000\]

驗算：\(1.01100011_2 = 1 + \tfrac14 + \tfrac18 + \tfrac{1}{128} + \tfrac{1}{256} = \tfrac{355}{256}\)； 乘 \(2^2\) 得 \(\tfrac{355}{64} = 5.546875\)，加上負號 ✓。

正確答案：第 5 個（左下角的 5 狀態 Moore 圖）。

這個系統需要記住兩件事：上一個輸入是什麼（0 或 1）， 以及目前的連續長度是否已達 2。最自然的 Moore 解需要 5 個狀態：

• \(S_0\)：初始（還沒讀任何東西），輸出 0；

• \(S_1\)／\(S_2\)：剛看到一個 0／一個 1，輸出 0；

• \(S_3\)／\(S_4\)：連續 \(\ge 2\) 個 0／\(\ge 2\) 個 1，輸出 1， 同值輸入時自迴圈留在原地；

• 換值時（\(S_3 \xrightarrow{1} S_2\)、\(S_4 \xrightarrow{0} S_1\)） 回到「連續 1 個」的對應狀態——不是回 \(S_0\)！ 新的輸入本身就是新連續串的第一個。

其餘五個選項錯在哪（都用測試序列快速擊倒）：

由於只有第 5 個正確，「以上不止一個」也不成立。 \[\boxed{\text{答案：第 5 個狀態圖（5 狀態、換值走 } S_3 \to S_2,\; S_4 \to S_1\text{ 的 Moore 機）}}\]

這是一道安全閥題：讓考生在自動閱卷的環境下 有機會記錄「我對某題的另一種合理解讀」， 閱卷者可據此人工調整。策略建議： 只有在真的存在歧義時才寫（並具體指出題號、 兩種解讀、你採用哪種與理由）；不要拿來寫求情或碎念—— 不影響分數，但清晰的歧義說明在爭議時可能救回分數。

\[\boxed{\text{ARM}}\] ARM 是授權式的 RISC 架構：Apple（A 系列、M 系列）、 Qualcomm Snapdragon、Samsung Exynos 等行動晶片都是 ARM 指令集的 實作。x64（x86-64）主宰桌機／伺服器；MIPS 已边缘化（嵌入式）； IA-64（Itanium）已停產；「Blast processing」是 90 年代 Sega 的行銷用語——干擾項。 考點：ISA（指令集）與微架構（實作）分離—— 同一 ARM ISA 有無數不同廠商的微架構實作。

C 指令的位元布局（16 位元，由高到低）： \[\underbrace{1\,1\,1}_{\text{bits }15\text{--}13}\; \underbrace{a}_{\text{bit }12}\; \underbrace{c_1 c_2 c_3 c_4 c_5 c_6}_{\text{comp}}\; \underbrace{d_1 d_2 d_3}_{\text{dest}}\; \underbrace{j_1 j_2 j_3}_{\text{jump}}\] 第 4 個最高有效位元就是 bit 12——\(a\) 位元。 \(a\) 決定 ALU 的 \(y\) 輸入來源：\(a{=}0\) 用暫存器 A、 \(a{=}1\) 用 M（即 RAM[A]）。 驗證：0xEA87 \(= 1110\,1010\,1000\,0111_2\)， bit 12 從 0 變 1 後為 0xFA87 ✓。

\[\boxed{\text{它會把運算中所有的 A 換成 M。}}\]

其他選項為何錯：\(a\) 位元的意義不依賴其他位元 （凡 comp 欄用到 \(y\) 輸入者一律改抓 M）； 「把結果存到 M」是 dest 欄 \(d_3\)（bit 3）的事； 「減 1」「清零輸入」是 comp 欄的事。

\[\boxed{\text{把字串轉換成一串 token（詞元）的過程。}}\] 編譯器管線（第 8 週）： lexing（字元流 \(\to\) token 流）\(\to\) parsing（token 流 \(\to\) 語法樹 CST， 即第一個干擾選項描述的「分析 token 序列的語法」）\(\to\) 語意分析（建符號表——第三個干擾選項）\(\to\) 產碼。 「把一種語言的檔案轉成另一種語言」是整個 編譯／翻譯的定義，不是 lexing 單一階段。

\[\boxed{\text{c) 讓編譯器跑得更快。}}\] 逐項對照第 9 週「VM 的種類與用途」： a) VM 自省（introspection）／安全研究 ✓ 是真實用途； b) 跨架構模擬（如 Rosetta、QEMU）✓； d) Hack VM 本身就是「用 VM 定義 IR」的例子 ✓； e) 沙箱（sandboxing）✓。 c) 恰恰相反——多一層 VM 的目標碼執行通常更慢， 且 VM 與「編譯器本身的執行速度」無關； 以 VM 為目標可能讓編譯器更容易寫（可移植性）， 但不是「跑得更快」。

逐行追蹤（堆疊由左到右＝由底到頂）：

最後一步是本題的核心：or 是位元運算—— \[2 = 00010_2,\qquad 29 = 11101_2,\qquad 00010 \lor 11101 = 11111_2 = 31.\] \[\boxed{\text{堆疊頂端} = 31}\]

兩個經典陷阱： (1) sub 的運算元順序是「第二個彈出的減第一個彈出的」 （\(x - y\)），寫成 \(7-5=2\) 就錯了； (2) or／and 在 Hack VM 是逐位元運算 （true 用 0xFFFF 表示才讓位元運算兼作邏輯運算）， \(2 \lor 29\) 絕不是「非零就取 1」。

\[\boxed{\text{b)（predication 可去除分支）為真。}}\] Predication 把「if 條件成立才做」改成「兩邊都算、 用條件遮罩選結果」（例如 cmov 條件搬移）， 消除跳躍、避免分支預測失誤——正確 ✓。

其餘為何錯： a) 管線化發生在單一 CPU 內部（取指／解碼／執行重疊）， 與 CPU 數量無關。 c) 恰相反——記憶體牆（memory wall）是現代效能的主要瓶頸， 快取層級就是為此存在。 d) 「唯一」錯：迴圈展開也減少迴圈自身的負擔 （計數、比較、跳回），並創造指令級平行與更多排程空間。 e) 「過早最佳化是萬惡之源」——先量測、有問題再最佳化； 預先手動展開讓程式難讀且常常沒效果。

先解碼固定位址（Hack VM 記憶體映射）： RAM[0]＝SP（堆疊指標，指向堆疊頂上方一格）、 RAM[3]＝THIS（this 段基底）、 RAM[4]＝THAT（that 段基底）。 初始：SP \(=290\)、THIS \(=3000\)、THAT \(=3005\)。

逐行執行（push：寫 RAM[SP] 再 SP++； pop：SP– 再讀 RAM[SP]）：

最終答案： \[\boxed{\begin{aligned} \texttt{RAM[0]} &= 293 & \texttt{RAM[3]} &= 3002 & \texttt{RAM[290]} &= 3003 \\ \texttt{RAM[291]} &= 3008 & \texttt{RAM[292]} &= 2999 && \end{aligned}}\]

考點三連發： (1) pointer 0/1 就是 RAM[3]／RAM[4] ——pop pointer 會重定基底， 影響之後所有 this／that 存取； (2) pop 之後格子裡的舊值不清除， 但隨後的 push 會覆蓋； (3) SP 最後停在 293（兩彈兩推抵銷後淨推 3 格）。

先讀懂記號：\(\{x\}\)＝重複 0 次以上；\([x]\)＝出現 0 或 1 次； \(|\)＝擇一。整個 catnoise＝「若干個 relaxed，最後必以一個 spicy（OUCH!）收尾」。 relaxed 的開頭只有兩種：mew（後面接任意多個 prrrr），或恰好 prrrr miaow。

逐項檢查：

\[\boxed{\text{答案：e) prrrr prrrr OUCH!}}\] （因此「不止一個」與「皆非」都不成立。）

回憶嘗試 2 的資料結構（第 10 週）：

• 每個段的前一個字（base\(-1\)）存 可用大小；alloc 回傳可用區基底 base （跳過放大小的那格）；

• 空閒段串成單向連結串列： RAM[base] 存下一個空閒段的 base； RAM[0x800] 是串列開頭指標，0xFFFF 表示串列結尾；

• alloc(size)：沿串列 first-fit 找第一個 大小 \(\ge\) size 的段，移出串列、必要時在尾端切割， 回傳其 base。

沿著串列走（head＝RAM[0x800]＝0x804）：

first-fit 在 0x80E（大小 5）停下：把它移出串列、 把大小改成 4、在尾端切出剩餘部分，然後回傳可用區基底： \[\boxed{\texttt{0x080E}}\]

整段記憶體的完整圖像（驗證讀法正確—— 各段首尾相接、不重疊）：

段內其餘的值（如 RAM[0x805]\(=\)0x000F、 RAM[0x80A]\(=\)0x0900）是先前使用留下的 殘值（垃圾）——不在串列走訪路徑上就沒有意義， 這是本題最主要的干擾設計。 另外「一堆相鄰的小空閒段沒被合併」正是嘗試 2 「無 coalescence」的特徵，也提示你用對了演算法版本。

同 Test 1：只在真正存在歧義時，具體寫出題號、兩種解讀與 你採用的詮釋即可。

思路：算 \(D = \texttt{RAM[7]} - 2\) 一次， 用兩個條件跳躍把三個分支分開（\(D=0\)、\(D<0\)、其餘）。 乘 4 沒有乘法指令——用兩次自加（\(x{+}x{+}x{+}x = ((x{\cdot}2){\cdot}2)\)）； Hack ALU 沒有 D+D，所以借 RAM[3] 當工作格， 用 M=D+M 完成翻倍。

// Q1.asm  -- RAM[3] = f(RAM[7])
    @7
    D=M         // D = RAM[7]
    @2
    D=D-A       // D = RAM[7] - 2
    @EQCASE
    D;JEQ       // RAM[7] == 2
    @LTCASE
    D;JLT       // RAM[7] <  2
// --- 否則：RAM[3] = RAM[7] * 4 ---
    @7
    D=M         // D = x
    @3
    M=D         // RAM[3] = x
    M=D+M       // RAM[3] = 2x   (D=x, M=x)
    D=M         // D = 2x
    M=D+M       // RAM[3] = 4x   (D=2x, M=2x)
    @END
    0;JMP
(EQCASE)        // RAM[3] = 5
    @5
    D=A
    @3
    M=D
    @END
    0;JMP
(LTCASE)        // RAM[3] = RAM[7] + 25
    @7
    D=M
    @25
    D=D+A
    @3
    M=D
(END)
    @END
    0;JMP       // 慣例：無窮迴圈結束程式

測試三個官方案例： \(x{=}2\)：走 EQCASE \(\to 5\) ✓； \(x{=}-5\)：\(-5-2 = -7 < 0\) 走 LTCASE \(\to -5+25 = 20\) ✓； \(x{=}42\)：\(42-2=40>0\) 走乘 4 \(\to 168\) ✓。

螢幕記憶體複習（第 5 週）： 螢幕從 SCREEN（16384）開始，每列 \(512\) 像素 \(= 32\) 個 16 位元字；第 \(r\) 列第一個字在 \(\texttt{SCREEN} + 32r\)。一個字的最低位元（LSB）是 最左邊的像素，位元值 1＝黑。

核心觀察：第 \(r\) 列（0 起算）要塗 \(r+1\) 個像素 \(=\) full 個全黑字（\(\texttt{0xFFFF} = -1\)）加一個 「低 \(k\) 位為 1」的部分字（遮罩）。逐列走時： \[\text{遮罩 } m \;\to\; 2m + 1 \quad(\text{多塗一個像素}),\] 當 \(m\) 湊滿 16 位元（\(m = -1\)）時：該列的「部分字」本身就是 全黑字；下一列起 full 加 1、\(m\) 重設為 1。 這樣完全不需要乘除法或位址計算技巧。

// Q2.asm -- 對角三角形：第 r 列塗 r+1 個像素
    @SCREEN
    D=A
    @addr       // addr = 目前列的起始位址
    M=D
    @full       // full = 本列全黑字數
    M=0
    @mask       // mask = 本列部分字（低 k 位為 1）
    M=1
    @row
    M=0
(ROWLOOP)
    @addr
    D=M
    @a          // a = 本列游標
    M=D
    @full
    D=M
    @count      // count = 還要寫幾個全黑字
    M=D
(FULLLOOP)      // 寫 full 個 0xFFFF
    @count
    D=M
    @PARTIAL
    D;JEQ
    @a
    A=M
    M=-1        // 全黑字
    @a
    M=M+1
    @count
    M=M-1
    @FULLLOOP
    0;JMP
(PARTIAL)       // 寫部分字（遮罩）
    @mask
    D=M
    @a
    A=M
    M=D
    @32         // addr += 32（下一列）
    D=A
    @addr
    M=D+M
    @mask       // mask 湊滿 16 位了嗎？（mask == -1）
    D=M
    D=D+1
    @INCFULL
    D;JEQ
    @mask       // mask = mask*2 + 1（多一個像素）
    D=M
    M=D+M
    M=M+1
    @NEXTROW
    0;JMP
(INCFULL)       // 進位：多一個全黑字、遮罩重設
    @full
    M=M+1
    @mask
    M=1
(NEXTROW)
    @row
    MD=M+1
    @256
    D=D-A
    @ROWLOOP
    D;JLT       // row < 256 繼續
(END)
    @END
    0;JMP

行數：約 60 行 \(\ll 200\) ✓。

正確性抽查： 第 0 列：full\(=0\)、mask\(=1\) \(\to\) 1 個像素 ✓； 第 14 列：mask\(=\mathtt{0x7FFF}\)（15 個）✓； 第 15 列：mask\(=\mathtt{0xFFFF}\)（16 個＝整字）✓， 寫完觸發 INCFULL； 第 16 列：full\(=1\)、mask\(=1\) \(\to 17\) 個 ✓； 第 255 列：full\(=15\)、mask\(=\mathtt{0xFFFF}\) \(\to 256\) 個 ✓。

語意回顧（第 10 週）：

• function f k：宣告函式進入點， 並把 \(k\) 個區域變數初始化為 0。 呼叫方的 call 已把 LCL 設為目前 SP， 所以「配置並清零 local」＝把 0 推上堆疊 \(k\) 次；

• push temp 0：temp 段固定在 R5–R12，temp 0 就是 RAM[5]；

• pop local 2：彈出堆疊頂，寫入 RAM[LCL+2]——恰好是剛清零的第 3 個區域變數。

// Q3.asm -- function Hello.world 4 / push temp 0 / pop local 2
(call$Hello.world)
// ---- function Hello.world 4：推 4 個 0（清零 local 0..3）----
    @SP
    A=M
    M=0
    @SP
    M=M+1
    @SP
    A=M
    M=0
    @SP
    M=M+1
    @SP
    A=M
    M=0
    @SP
    M=M+1
    @SP
    A=M
    M=0
    @SP
    M=M+1
// ---- push temp 0：temp 0 = RAM[5] ----
    @5
    D=M
    @SP
    A=M
    M=D
    @SP
    M=M+1
// ---- pop local 2：RAM[LCL+2] = 彈出值 ----
    @LCL        // 先算目的位址存到 R13
    D=M
    @2
    D=D+A
    @R13
    M=D
    @SP
    AM=M-1      // SP-- 且 A=新 SP
    D=M         // D = 彈出的值（= RAM[5] 的內容）
    @R13
    A=M
    M=D
(END)
    @END
    0;JMP

淨效果（只看 RAM 最終狀態，正是評分方式）： 設進入時 SP \(= s\)、LCL \(= s\)（call 的約定）： RAM[\(s\)]–RAM[\(s{+}3\)] 清為 0， 接著 RAM[\(s{+}2\)]（＝local 2）被覆寫為 RAM[5] 的值； push／pop 抵銷後 SP \(= s + 4\)。

分析。三個子問題：

1. 按鍵邊緣偵測：KBD（RAM[24576]） 反映「目前按著的鍵」，按 500 週期會被讀到上千次—— 必須記住上一次的值 prev， 只在 KBD \(\ne\) prev 時處理（狀態變化）， 且值為 0（放開）時只更新 prev 不動作。

2. 字元 \(\to\) 數位：Hack 鍵盤碼： ‘0’–‘9’ \(= 48\)–\(57\)、‘A’–‘F’ \(= 65\)–\(70\)、newLine \(= 128\)。 數字：\(d = k - 48\)；字母：\(d = k - 55\)（‘A’\(=65 \to 10\)）。 判斷用 \(k < 58\) 分流即可（合法輸入下唯一的分界）。

3. 累積：每收到一個數位，\(v \leftarrow 16v + d\) （十六進位的「往左推一位」）。\(\times 16\)＝翻倍 4 次， 用 M=D+M 模式實現。

// Q4.asm -- 鍵盤十六進位讀入 RAM[500..]
    @500
    D=A
    @ptr        // ptr = 下一個結果的存放位址
    M=D
    @val        // val = 累積中的數值
    M=0
    @prev       // prev = 上次看到的 KBD 值
    M=0
(LOOP)
    @KBD
    D=M
    @prev
    D=D-M       // KBD 變了嗎？
    @LOOP
    D;JEQ       // 沒變：繼續輪詢
    @KBD
    D=M
    @prev
    M=D         // prev = 新值（D 仍為 k）
    @LOOP
    D;JEQ       // k == 0：只是放開按鍵
    @128
    D=D-A
    @STORE
    D;JEQ       // k == 128：Enter
// ---- 字元轉數位 ----
    @prev
    D=M
    @58
    D=D-A       // k - 58 >= 0 ？
    @LETTER
    D;JGE
    @prev       // 數字：d = k - 48
    D=M
    @48
    D=D-A
    @ACC
    0;JMP
(LETTER)        // 字母：d = k - 55
    @prev
    D=M
    @55
    D=D-A
(ACC)           // val = val*16 + d
    @dig
    M=D
    @val
    D=M
    M=D+M       // val = 2v
    D=M
    M=D+M       // 4v
    D=M
    M=D+M       // 8v
    D=M
    M=D+M       // 16v
    @dig
    D=M
    @val
    M=D+M       // 16v + d
    @LOOP
    0;JMP
(STORE)         // Enter：存檔、歸零、前進
    @val
    D=M
    @ptr
    A=M
    M=D         // RAM[ptr] = val
    @ptr
    M=M+1
    @val
    M=0
    @LOOP
    0;JMP

用官方例子驗證： ‘4’（52）\(\to d{=}4, v{=}4\)；‘A’（65）\(\to d{=}10, v = 64+10 = 74 = \mathtt{0x4A}\)；‘7’ \(\to v = 1184+7 = \mathtt{0x4A7}\)；Enter \(\to\) RAM[500] \(= \mathtt{0x4A7}\) ✓。 ‘9’ Enter \(\to\) RAM[501] \(= 9\) ✓； 緊接的 Enter（中間無數位）\(\to\) RAM[502] \(= 0\) ✓； ‘5ACE’ Enter \(\to\) RAM[503] \(= \mathtt{0x5ACE}\) ✓。