109 年 國立政治大學數位內容碩士學位學程資訊技術組《計算機概論與程式設計》

核心觀念

本題考查電腦中不同儲存元件的功能。判斷重點是：只要元件能夠在某段時間內保存資訊，就具有儲存資料的功能；保存時間長短不影響其「儲存」的本質。

• ROM：非揮發性記憶體，可保存韌體或固定程式。
• Register：CPU 內部的暫存器，用於保存運算中的資料、位址或控制資訊。
• SSD：非揮發性儲存裝置，可長期保存檔案與程式。
• Cache：高速快取記憶體，用於暫時保存常用資料與指令。

解題方法

逐一判斷各元件是否具有「保存資料或資訊」的功能。即使某元件只能短暫保存資料，只要資料在處理期間被保留，仍屬於資料儲存。

選項分析

(A) ROM

ROM 是 Read-Only Memory 的縮寫，屬於非揮發性記憶體。即使電源關閉，通常仍能保留其中的資料，常用來存放開機韌體。因此 ROM 是用來儲存資料的元件，選項錯誤。

(B) Register

本題要求將不同進制表示的數字轉換為十進制，並比較大小，找出大於 76 的數字。

首先，我們將各選項轉換為十進制：

• (A) 10110100 in 2's complement:
  這是一個 8 位元的二補數表示。最高位是 1，表示為負數。
  計算方法：

  1. 先取反碼：01001011
  2. 加 1：01001100
  3. 將此二進制數轉換為十進制：$0 \times 2^7 + 1 \times 2^6 + 0 \times 2^5 + 0 \times 2^4 + 1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 0 \times 2^0 = 64 + 8 + 4 = 76$
  4. 由於原數為負數，所以此數為 -76。
     -76 不大於 76。

• (B) 1000100 in binary:
  這是一個純二進制數。

本題需要根據給定的邏輯值 A=True, B=False, C=False，逐一計算各個邏輯表達式的結果，找出結果為 True 的選項。我們將 True 視為 1，False 視為 0。

給定：A = True (1), B = False (0), C = False (0)

• (A) (A AND B) OR C:
  (1 AND 0) OR 0
  0 OR 0
  0 (False)

• (B) (A NAND B) XOR C:
  A NAND B = NOT (A AND B) = NOT (1 AND 0) = NOT (0) = 1 (True)
  (A NAND B) XOR C = 1 XOR 0 = 1 (True)

本題考查排序演算法的「最壞情況時間複雜度」（Worst-case time complexity）。我們需要知道各個常見排序演算法的最壞情況時間複雜度。

• (A) Merge sort (合併排序):
  合併排序的時間複雜度，無論是最好、平均還是最壞情況，都是 $O(n \log n)$。

• (B) Quick sort (快速排序):
  快速排序的平均時間複雜度是 $O(n \log n)$，但其最壞情況時間複雜度是 $O(n^2)$。最壞情況發生在每次分割（pivot selection）都選到極端值（最小值或最大值），導致分割不均。

• (C) Bubble sort (氣泡排序):
  氣泡排序的最壞情況時間複雜度是 $O(n^2)$。

核心觀念

本題考查各種排序法的「最壞情況額外空間複雜度（worst-case auxiliary space complexity）」。

令輸入資料筆數為 $n$：

• 額外空間複雜度：排序過程除原始輸入資料外，額外使用的陣列、佇列、遞迴堆疊等記憶體。
• Big-O 用來表示輸入規模增加時，空間需求的成長上限。

常見排序法的最壞額外空間如下：

排序法	最壞額外空間複雜度
Merge sort	$O(n)$
Quick sort	$O(n)$
Bubble sort	$O(1)$
Radix sort	$O(n+k)$
Heap sort	$O(1)$

其中，Radix sort 的 $k$ 通常代表數字的基底、鍵值範圍或桶子的數量。

---

解題方法

比較各選項的最壞空間複雜度即可。

Radix sort 通常需要：

1. 儲存輸入資料的暫存結構，空間為 $O(n)$；
2. 儲存計數陣列或桶子，空間為 $O(k)$。

因此總空間為：

$$O(n)+O(k)=O(n+k)$$

由於題目未指定 $k$ 為固定常數，應保留 $k$ 這個變數。因此 $O(n+k)$ 的一般形式比單純的 $O(n)$ 更大，故選擇 Radix sort。

---

選項分析

(A) Merge sort

Merge sort 使用分割合併策略。合併兩個已排序序列時，通常需要額外的暫存陣列：

$$O(n)$$

遞迴呼叫堆疊通常為 $O(\log n)$，但主要空間由合併用的暫存陣列決定，因此總額外空間為：

$$O(n)$$

不是本題最大者，故錯誤。

(B) Quick sort

Quick sort 的最壞情況可能每次都選到最差的 pivot，使分割成為：

$$(n-1)+0$$

此時遞迴深度為 $O(n)$，所以遞迴堆疊的最壞空間為：

$$O(n)$$

本題考查物件導向程式設計中，類別繼承與存取權限（access specifiers）的關係，特別是 private、protected 和 public 的概念。

給定條件：A, B, C 是三個類別，B 是從 A 繼承而來（B derived from A）。

我們逐一分析各選項：

• (A) A accesses a private variable in B.

  • private 成員只能在宣告它們的類別內部被存取。
  • 類別 A 無法直接存取類別 B 的 private 成員，因為 B 是 A 的子類別，而不是 A 的內部。這與繼承方向相反。
  • 因此，此敘述是錯誤的。

• (B) B accesses a protected variable in C.

  • 題目只說明 B 繼承自 A，並沒有說明 B 與 C 的關係，也沒有說明 C 的繼承關係。
  • 即使 B 和 C 是相關的類別（例如 C 繼承自 B，或 C 繼承自 A），B 也只能存取 C 的 public 或 protected 成員，但不能直接存取 C 的 private 成員。
  • 由於 C 的關係不明，且此敘述可能涉及跨類別存取，需要更多資訊。但一般而言，若 C 與 B 無關，則 B 當然無法存取 C 的變數。即使 C 繼承自 B，B 也無法存取 C 的 private 成員。
  • 此敘述很可能是錯誤的。

• (C) A accesses a protected variable in B.

本題為經典的 C/C++ 程式語言綜合運算子考題，核心考核觀念包含：運算子優先順序與結合律（Operator Precedence & Associativity）、邏輯運算子的短路求值機制（Short-circuit Evaluation）、前綴遞增運算子的副作用（Side Effect of Pre-increment Operator ++）與序列點（Sequence Point），以及三元條件運算子（Ternary Operator ?:）的求值邏輯。

---

完整解題過程

已知初始變數狀態為：
$a=5$
$b=7$

待評估的表達式為：
c = a * 2 > pow(pow(a, 2) + pow(b, 2), 0.5) && !(a+ ++b < rand()%10 + 3)? pow(a, 2) % b: pow(b, 2)/ a;

步驟一：分析運算式的整體結構與優先順序

根據 C/C++ 運算子優先順序：

1. 算術與函數呼叫（如 pow、*、+）優先權最高。
2. 關係運算子（>、<）優先權次之。
3. 邏輯與（&&）優先權低於關係運算子。
4. 三元條件運算子（? :）優先權低於邏輯運算子。

因此，表達式可拆解為條件式與兩個分支：

• 條件判斷式（Condition）：[a * 2 > pow(pow(a, 2) + pow(b, 2), 0.5)] && [!(a+ ++b < rand()%10 + 3)]
• True 分支（expr1）：pow(a, 2) % b
• False 分支（expr2）：pow(b, 2)/ a

步驟二：評估條件判斷式之左式（LHS）

左式為：a * 2 > pow(pow(a, 2) + pow(b, 2), 0.5)

1. 計算左側算式：
   $a \times 2 = 5 \times 2 = 10$
2. 計算右側 pow 數學函數：
   $pow(a, 2) = 5^2 = 25$
   $pow(b, 2) = 7^2 = 49$
   $pow(a, 2) + pow(b, 2) = 25 + 49 = 74$
   $pow(74, 0.5) = \sqrt{74} \approx 8.6023$
3. 進行比較：
   $10 > 8.6023$
   此不等式成立，故 LHS 評估結果為真（True，數值為 $1$）。

步驟三：評估條件判斷式之右式（RHS）與短路求值機制

為什麼右式必須被執行？
在 C/C++ 中，邏輯與運算子 && 具備短路求值（Short-circuit Evaluation）特性。當且僅當 LHS 為假（$0$）時，程式才會跳過 RHS。由於本題 LHS 評估結果為真（$1$），程式必須繼續執行 RHS 以確定整體邏輯值。

右式為：!(a+ ++b < rand()%10 + 3)

1. 前綴遞增運算子 ++b 的副作用：
   前綴遞增會先將變數加 $1$ 後再回傳該值。

本題考查 C 語言的 do-while 迴圈、函式呼叫（傳值呼叫）、全域變數（或可被多處修改的變數）以及 break 語句。需要模擬程式的執行流程。

首先，我們看到 main 函式中定義了全域變數（或者說，它們在 main 函式之外被宣告，但在此處的上下文中，它們被當作是共享的，尤其是 k）。
int i = 3, j = 5, k = 0;

程式進入 main 函式。
void main() { ... }
有一個 do-while 迴圈，條件是 while (true)，這意味著迴圈會一直執行，直到遇到 break 語句。

第一次迴圈迭代：

1. i = i * j;
i 現在是 $3 \times 5 = 15$。

2. plus(i, j);
   呼叫 plus 函式，傳入 i 的值 15 和 j 的值 5。
   進入 plus 函式：
   void plus(int a, int b) { ... }
   這裡 a 的值是 15，b 的值是 5。
   a++; => a 變成 16。
   b++; => b 變成 6。
   k++; => k 的值從 0 變成 1。
   plus 函式結束。注意，a 和 b 是傳值呼叫，所以在 plus 函式內部的修改不會影響 main 函式中的 i 和 j。只有 k 的修改是影響全局的（或共享的）。
   函式結束後，i 仍然是 15，j 仍然是 5。k 是 1。

3. if (2000 < i)
2000 < 15 是 False。不執行 break。

4. k++;
k 的值從 1 變成 2。

迴圈條件 while (true) 繼續。

第二次迴圈迭代：

1. i = i * j;
i 現在是 $15 \times 5 = 75$。

2. plus(i, j);
   呼叫 plus 函式，傳入 i 的值 75 和 j 的值 5。
   進入 plus 函式：
   a 的值是 75，b 的值是 5。
   a++; => a 變成 76。
   b++; => b 變成 6。
   k++; => k 的值從 2 變成 3。
   plus 函式結束。i 仍然是 75，j 仍然是 5。k 是 3。

3. if (2000 < i)
2000 < 75 是 False。不執行 break。

4. k++;
k 的值從 3 變成 4。

迴圈條件 while (true) 繼續。

第三次迴圈迭代：

1. i = i * j;
i 現在是 $75 \times 5 = 375$。

2. plus(i, j);
   呼叫 plus 函式，傳入 i 的值 375 和 j 的值 5。
   進入 plus 函式：
   a 的值是 375，b 的值是 5。
   a++; => a 變成 376。
   b++; => b 變成 6。
   k++; => k 的值從 4 變成 5。
   plus 函式結束。i 仍然是 375，j 仍然是 5。k 是 5。

3. if (2000 < i)
2000 < 375 是 False。不執行 break。

4. k++;
k 的值從 5 變成 6。

迴圈條件 while (true) 繼續。

第四次迴圈迭代：

1. i = i * j;
i現在是 $375 \times 5 = 1875$。

2. plus(i, j);
   呼叫 plus 函式，傳入 i 的值 1875 和 j 的值 5。
   進入 plus 函式：
   a 的值是 1875，b 的值是 5。
   a++; => a 變成 1876。
   b++; => b 變成 6。
   k++; => k 的值從 6 變成 7。
   plus 函式結束。i 仍然是 1875，j 仍然是 5。k 是 7。

3. if (2000 < i)
2000 < 1875 是 False。不執行 break。

4. k++;
k 的值從 7 變成 8。

迴圈條件 while (true) 繼續。

第五次迴圈迭代：

1. i = i * j;
i現在是 $1875 \times 5 = 9375$。

2. plus(i, j);
   呼叫 plus 函式，傳入 i 的值 9375 和 j 的值 5。
   進入 plus 函式：
   a 的值是 9375，b 的值是 5。
   a++; => a 變成 9376。
   b++; => b 變成 6。
   k++; => k 的值從 8 變成 9。
   plus 函式結束。i 仍然是 9375，j 仍然是 5。k 是 9。

3. if (2000 < i)
2000 < 9375 是 True。執行 break;。
   迴圈終止。

程式執行結束。

題目問的是「which of the following choice is the correct answer of a?」。
這裡有兩個地方的 a：

1. plus 函式內部的局部變數 a。在最後一次呼叫 plus 時，它的值變成了 9376。
2. 主函式中沒有 a 這個變數。

本題考查氣泡排序（Bubble Sort）演算法中，元素交換（swap）的次數。氣泡排序通過重複地遍歷列表，比較相鄰的元素並交換它們，直到列表排序完成。

給定的陣列是：{43, 52, 38, 74, 12}。陣列大小 $n=5$。

氣泡排序的過程如下：
每一趟（pass）都會將當前未排序部分的最大元素「冒泡」到其正確的位置。

第一趟 (Pass 1):
比較並交換相鄰元素。

• {43, 52, 38, 74, 12}
• Compare 43 and 52: 43 < 52, no swap. Array: {43, 52, 38, 74, 12}.
• Compare 52 and 38: 52 > 38, swap. Array: {43, 38, 52, 74, 12}. Swap 1
• Compare 52 and 74: 52 < 74, no swap. Array: {43, 38, 52, 74, 12}.
• Compare 74 and 12: 74 > 12, swap. Array: {43, 38, 52, 12, 74}. Swap 2
  第一趟結束，最大的元素 74 已經移動到最後。陣列變為：{43, 38, 52, 12, 74}。
  共發生 2 次交換。

第二趟 (Pass 2):
考慮前 n-1 個元素。

• {43, 38, 52, 12, 74}
• Compare 43 and 38: 43 > 38, swap. Array: {38, 43, 52, 12, 74}. Swap 3
• Compare 43 and 52: 43 < 52, no swap. Array: {38, 43, 52, 12, 74}.
• Compare 52 and 12: 52 > 12, swap. Array: {38, 43, 12, 52, 74}. Swap 4
  第二趟結束，第二大的元素 52 移動到倒數第二個位置。陣列變為：{38, 43, 12, 52, 74}。
  共發生 2 次交換。

核心觀念

本題考查以下觀念：

• 巢狀 for 迴圈的執行順序。
• break 只會跳出目前所在的迴圈。
• continue 會跳過本次迴圈剩餘程式，直接執行迴圈更新式。
• 迴圈變數 i、j 可在迴圈本體內被修改。
• C 語言整數除法：a / 2 會捨去小數部分。
• a % 3 表示 $a$ 除以 $3$ 的餘數。

內層迴圈每次執行的順序為：

1. 判斷 i > 3。
2. 判斷 j > 3 && j < 5。
3. 判斷 j > 5。
4. 執行 i += a/2、j += a%3、a++。
5. 執行內層 for 的更新式 j++。

其中，若執行 break，本次迴圈後方的程式不會執行。

---

解題方法

依照程式實際執行順序追蹤 $i$、$j$ 與 $a$。

第一次外層迴圈：$i=0$

初始狀態：

$$a=0,\quad i=0,\quad j=0$$

執行前	判斷結果	本體內更新	for 更新後
$i=0,j=0,a=0$	不符合 break 或 continue	$i=0+0/2=0$，$j=0+0\%3=0$，$a=1$	$j=1$
$i=0,j=1,a=1$	不符合 break 或 continue	$i=0+1/2=0$，$j=1+1\%3=2$，$a=2$	$j=3$
$i=0,j=3,a=2$	不符合 break 或 continue	$i=0+2/2=1$，$j=3+2\%3=5$，$a=3$	$j=6$
$i=1,j=6,a=3$	j > 5，執行 break	不再執行後續更新	離開內層迴圈

此時：

$$a=3,\quad i=1$$

內層迴圈結束後，外層 for 的更新式執行 i++：

$$i=1+1=2$$

---

第二次外層迴圈：$i=2$

此時：

$$a=3,\quad i=2$$

執行前	判斷結果	本體內更新	for 更新後

這是一個關於物件導向程式設計（OOP）的觀念題，共包含四個部分：定義 OOP、OOP 的好處、建構子（constructor）的定義，以及撰寫一個類別的兩個建構子。

1. 什麼是物件導向程式設計 (OOP)？

物件導向程式設計（Object-Oriented Programming, OOP）是一種程式設計範式，它將程式的設計圍繞著「物件」（Objects）展開。物件是現實世界中事物的抽象，它包含了狀態（數據，即屬性或成員變數）和行為（方法或成員函數）。OOP 的核心思想是將數據和操作數據的方法封裝在一個單元中，即物件。

OOP 的四大基本原則是：

• 封裝 (Encapsulation): 將數據（屬性）和操作數據的方法（行為）捆綁在一起，形成一個獨立的單元（物件）。同時，透過存取權限（如 public, private, protected）來隱藏物件的內部實現細節，只暴露必要的介面。
• 繼承 (Inheritance): 允許一個類別（子類別或衍生類別）繼承另一個類別（父類別或基底類別）的屬性和方法。這有助於程式碼的重用，並建立類別之間的層次關係。
• 多型 (Polymorphism): 意為「多種形態」。允許物件以不同的方式響應相同的訊息。在 OOP 中，這通常透過方法重載（method overloading）和方法覆寫（method overriding）來實現，使得程式可以對不同類型的物件執行相同的操作，但產生不同的結果。
• 抽象 (Abstraction): 關注物件的本質特性，忽略不相關的細節。它允許我們在設計時定義一個高層次的介面，而將具體的實現留給子類別。

2. 物件導向程式設計 (OOP) 的好處：

• 程式碼重用 (Code Reusability): 透過繼承，子類別可以重用父類別的程式碼，減少重複編寫，提高開發效率。
• 模組化 (Modularity): OOP 將程式分解為獨立的物件，每個物件負責特定的功能。這使得程式更容易理解、維護和擴展。
• 易於維護 (Easier Maintenance): 當需要修改或更新程式時，由於程式碼的封裝性，通常只需要修改受影響的特定物件或類別，而不會對整個系統造成廣泛影響。
• 易於擴展 (Easier Extensibility): 新的功能可以透過創建新的類別或繼承現有類別來添加，而不會破壞現有的程式碼。
• 提高開發效率 (Increased Productivity): 基於已有的類別庫和物件，開發者可以更快地構建複雜的應用程式。
• 更好的問題解決能力 (Better Problem Solving): OOP 的設計思想與現實世界的模型更為貼近，有助於開發者更好地將現實問題映射到程式設計中。
• 提高程式的可讀性與可理解性 (Improved Readability and Understandability): 物件的概念使得程式結構更清晰，更容易理解。

3. 什麼是建構子 (Constructor)？

建構子（Constructor）是一種特殊的方法（或函式），它在創建一個類別的物件（實例）時被自動呼叫。建構子的主要目的是初始化物件的成員變數（屬性），為物件設定初始狀態。

建構子的幾個特點：

• 它的名稱必須與類別名稱完全相同。
• 它沒有返回類型（在某些語言中，如 Java，甚至沒有 void 關鍵字）。
• 它可以有參數，用於在創建物件時傳入初始值。
• 一個類別可以有多個建構子，只要它們的參數列表不同（建構子重載）。
• 如果程式設計師沒有為類別定義任何建構子，編譯器通常會自動生成一個預設的（無參數）建構子。

4. 撰寫兩個建構子的範例：

核心觀念

本題考核 C/C++ 程式設計中的三個核心觀念：

1. 二維陣列作為函式參數的宣告與傳遞（2D Array Parameter Passing）：
   在 C 語言中傳遞固定維度的二維陣列時，必須指定第二維（column）的大小，形式如 void sortRows(int arr[][N], int n)，或使用 C99 變長陣列（VLA, Variable-Length Array）語法 void sortRows(int n, int arr[n][n])。在 C++ 中亦可利用指標陣列、二維向量或標頭常數定義。
2. 列極值搜尋與關聯記錄（Finding Row Maximums）：
   遍歷二維陣列的每一列（row），找出各列的最大值（maximum element），並記錄下來作為排序的權重依據。
3. 根據特定鍵值（Key）對二維結構做整列交換排序（Row-wise Sorting）：
   依據各列求出的最大值做升冪排序（Ascending Order），排序時需整列元素（或指向該列的位址）同步交換（Swap）。

---

解題方法

題目範例展示了一組 $3 \times 3$ 二維陣列的排序過程：

• 原陣列：
  • 第 0 列：[5, 22, 84] $\to$ 最大值為 $84$
  • 第 1 列：[27, 14, 13]（範例中排版為 27 14 13） $\to$ 最大值為 $27$
  • 第 2 列：[3, 5, 33]（範例中排版為 3 5 33） $\to$ 最大值為 $33$
• 各列最大值依序為：列 0（84）、列 1（27）、列 2（33）。
• 依據最大值升冪排序（Ascending Order）：$27 < 33 < 84$。
• 排序後各列順序應為：列 1 $\to$ 列 2 $\to$ 列 0。
  • 新第 0 列：[27, 14, 1]（對應原列 1）
  • 第 1 列：[4, 3, 5] 或 [3, 5, 33]（對應原列 2）
  • 第 2 列：[22, 84, ...]（對應原列 0）
    (註：考卷原稿範例數字有局部排版換行折損，但語意完全明確，即「依每列的最大值由小到大重排各列」)。

演算法設計步驟：

1. 函式宣告與定義：定義無回傳值（void）之函式，傳入 $n \times n$ 二維陣列及其維度 $n$。
2. 提取各列最大值：建立大小為 $n$ 的輔助陣列 maxVal，雙層迴圈掃描每一列取得最大值。
3. 依最大值排序整列：使用簡易且直覺的排序法（如泡沫排序法 Bubble Sort 或選擇排序法 Selection Sort）。當比較發現前一列最大值大於後一列最大值時，除了交換 maxVal 中的代表值外，並以一個長度為 $n$ 的迴圈將原陣列中該兩列的所有元素逐一交換（Swap）。

---

程式碼實作

以下提供符合標準 C/C++ 規範且考場最易拿滿分的兩種標準寫法。

寫法一：標準 C99 / 現代 C++ 寫法（推薦）

#include <stdio.h>

/* 函式原型宣告 (Function Declaration) */
void sortRowsByMax(int n, int arr[n][n]);

/* 函式定義 (Function Definition) */
void sortRowsByMax(int n, int arr[n][n]) {
    int maxVal[n];

    // 步驟 1：找出每一列的最大值
    for (int i = 0; i < n; i++) {
        int currentMax = arr[i][0];
        for (int j = 1; j < n; j++) {
            if (arr[i][j] > currentMax) {
                currentMax = arr[i][j];
            }
        }
        maxVal[i] = currentMax;
    }

    // 步驟 2：依據 maxVal 進行升冪排序，並同步交換整列元素
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (maxVal[j] > maxVal[j + 1]) {
                // 交換最大值記錄
                int tempMax = maxVal[j];
                maxVal[j] = maxVal[j + 1];
                maxVal[j + 1] = tempMax;

                // 交換兩列的所有元素
                for (int k = 0; k < n; k++) {
                    int tempElem = arr[j][k];
                    arr[j][k] = arr[j + 1][k];
                    arr[j + 1][k] = tempElem;
                }
            }
        }
    }
}

寫法二：傳統 C89 語法（以巨集定義固定維度上限）

若考場要求相容傳統 C89（不支援 VLA）：

核心觀念

本題考查「Arduino 感測器整合、事件偵測、座標轉換與互動媒體系統設計」。

完整系統可分成四層：

1. 感測層：2D 感測器陣列偵測橡皮球撞擊位置。
2. 嵌入式處理層：Arduino 讀取感測器訊號、判斷是否真的發生撞擊，並計算位置。
3. 通訊層：Arduino 透過 USB Serial 將撞擊資料傳送給電腦。
4. 視覺呈現層：Unity 接收資料，在九宮格對應位置顯示紅點、動畫或分數。

橡皮球撞擊後，感測器會產生電壓、電阻或數位訊號變化。若感測器能提供連續座標，可用加權平均估算撞擊中心：

$$x=\frac{\sum_{i=1}^{n}s_i x_i}{\sum_{i=1}^{n}s_i}$$ $$y=\frac{\sum_{i=1}^{n}s_i y_i}{\sum_{i=1}^{n}s_i}$$

其中 $s_i$ 是第 $i$ 個感測器的反應強度，$(x_i,y_i)$ 是該感測器的位置。

若感測器陣列的實體範圍為寬 $W$、高 $H$，並切成 $N \times N$ 格，則九宮格中的欄、列可以由下式取得：

$$col=\left\lfloor \frac{x}{W/N} \right\rfloor$$ $$row=\left\lfloor \frac{y}{H/N} \right\rfloor$$

為避免邊界值超出範圍，需限制：

$$0\leq col<N,\qquad 0\leq row<N$$

---

Arduino 的優點

Arduino 是適合數位內容互動原型製作的開源微控制器平台，主要優點如下：

1. 成本低：開發板與常用感測器價格低，適合快速製作展示原型。
2. 容易學習：使用接近 C/C++ 的 Arduino 語法，並提供簡化的函式庫與開發環境。
3. 輸入輸出介面完整：支援數位輸入、類比輸入、PWM、Serial、I2C、SPI 等介面，可連接按鈕、壓力感測器、馬達、燈光與顯示器。
4. 開源且擴充性高：電路、軟體與函式庫資源豐富，能快速整合不同硬體。
5. 適合快速迭代：修改程式後即可重新燒錄，方便測試互動設計與調整感測器參數。
6. 容易與其他系統整合：可透過 USB Serial、藍牙、Wi-Fi 或網路模組與 Unity、Processing、網頁及手機應用程式溝通。

---

系統架構圖

以下假設感測器陣列能回傳橡皮球撞擊所造成的 $x,y$ 座標，並以 USB Serial 連接電腦：

橡皮球撞擊九宮格板
          │
          ▼
    2D 感測器陣列
          │
          │ 類比值／數位值
          ▼
       Arduino
          │
          ├─ 讀取感測器
          ├─ 濾除雜訊
          ├─ 判斷撞擊事件
          ├─ 計算 x、y 座標
          └─ 轉換成 row、col
          │
          │ USB Serial
          ▼
    Unity / 電腦程式
          │
          ├─ 解析撞擊資料
          ├─ 對應九宮格位置
          ├─ 顯示紅點動畫
          ├─ 播放音效
          └─ 計算分數
          │
          ▼
        螢幕畫面

---

解題方法

一、感測器配置

一種簡單實作方式是在板面下方配置 $3\times3$ 個感測器：

S00   S01   S02
S10   S11   S12
S20   S21   S22

每個感測器負責一個九宮格區域。橡皮球落在某一格時，該位置的感測器反應值會明顯升高。

此方法可以直接判斷九宮格位置：

$$row=\arg\max_i(s_i)$$ $$col=\arg\max_j(s_j)$$

為提升定位精度，可將相鄰感測器的反應值做加權平均，使紅點不只顯示在格子中心，也能顯示更接近實際撞擊位置的座標。

二、撞擊判斷

感測器受到環境震動、手部碰觸或電氣雜訊時，也可能產生短暫訊號。因此需要設定：

• 門檻值：訊號大於門檻才視為撞擊。
• 去彈跳時間：一次撞擊後的短時間內忽略重複訊號。
• 取樣與濾波：連續取樣數次，使用平均值或最大值降低雜訊。
• 事件封鎖：等待訊號低於門檻後，才允許下一次撞擊。

三、資料格式

Arduino 將資料以一行文字傳給 Unity：

HIT,1,2,734,421

欄位意義如下：

HIT, row, col, x, y

例如 HIT,1,2,734,421 表示撞擊九宮格第 2 列、第 3 欄，板面座標為 $(734,421)$。

---

Arduino 程式碼

以下程式以九個類比感測器為例。實際硬體可替換成壓力感測器、壓電片、紅外線遮斷器或其他 2D 感測器。