111 年 國立中央大學機械工程系光機電工程碩士班甲組《程式設計》

核心觀念

本題考查微控制器的輪詢（polling）、開關邊緣偵測與狀態控制。

重點如下：

• 開關狀態：$HI$ 表示 ON，$LO$ 表示 OFF。
• 只在開關由 $LO \rightarrow HI$ 的「上升邊緣」發生時，才將開關次數加一。
• 開關持續保持 $HI$ 時，不可重複計數。
• 開關次數依序為 $1\sim5$，第 5 次後再開啟時回到第 1 種狀態。
• 燈泡輸出也是數位訊號：$HI$ 為亮，$LO$ 為暗。

解題方法

使用變數記錄：

• prevSwitch：前一次輪詢讀到的開關狀態。
• switchCount：目前累積的開關次數。

當前狀態為 currentSwitch 時，若符合：

表示剛完成一次開啟動作，將計數器加一：

由於只有五種燈號狀態，因此可令：

各次開啟時的燈泡狀態如下：

關閉開關時，五顆燈全部熄滅；再次由 $LO$ 變成 $HI$ 時，依新的計數值顯示下一種狀態。

關鍵程式碼

本題考驗的是如何使用陣列來模擬大數運算，特別是針對帶有符號的整數。核心概念是「二補數」(Two's Complement) 的概念，以及如何將這種表示法應用到以陣列儲存的數字上。由於題目限定使用 4 個 16 位元整數來表示一個大數，每個元素範圍是 $0 \sim 9999$，這意味著我們實際上是在處理一個 $4 \times 16$ 位元的大數，但每個「位」是 $10000$ 進位的。

核心概念：

1. 表示法：一個大數 $N$ 由一個 4 個元素的陣列 $arr = \{arr[0], arr[1], arr[2], arr[3]\}$ 表示，其中 $arr[i]$ 的值在 $0 \sim 9999$ 之間。
   $N = arr[0] \times 10000^3 + arr[1] \times 10000^2 + arr[2] \times 10000^1 + arr[3] \times 10000^0$
   這個表示法類似於 BCD (Binary Coded Decimal) 的概念，但基數是 $10000$ 而非 $10$ 或 $2$。

2. 二補數 (Two's Complement)：

   • 正數：直接以其值儲存。
   • 負數：
     • 取其絕對值的「補數」。
     • 補數的計算：對於一個 $k$ 位元的系統，一個數 $x$ 的補數是 $2^k - x$。
     • 在本題中，整個大數的「最大值」是 $10000^4$。題目說「最小溢位值補數 (即比最大值大 1 的數)」，這指的是 $10000^4$。
     • 所以，一個負數 $-X$ 的二補數表示為 $(10000^4) - X$。
     • 題目提到 $-99$ 的表示為 $9999 \ 9999 \ 9999 \ 9901$。這表示 $10000^4 - 99$。
     • $10000^4 = 1,0000,0000,0000,0000$ (一個 1 後面跟 16 個 0)。
     • $10000^4 - 99 = 9999,9999,9999,9901$。
     • 這與題目的表示法 $arr[0] \sim arr[3]$，$0 \sim 9999$ 匹配。
     • $10000^4$ 可以看作是 $1 \ 0000 \ 0000 \ 0000 \ 0000$。
     • 在 4 個 16 位元元素 (每個 $0 \sim 9999$) 的表示法中，$10000^4$ 是無法直接表示的，因為它會溢出到第 5 個元素。
     • 題目說「可以先扣掉 1 在執行完成後再加回 1」。這意味著，當我們計算 $-X$ 時，我們實際上計算 $(10000^4 - 1) - X + 1$。
     • $10000^4 - 1 = 9999,9999,9999,9999$。
     • 所以，$-X$ 的表示為 $(9999,9999,9999,9999) - X + 1$。
     • 例如 $-99$：$(9999,9999,9999,9999) - 99 + 1$。
       • $9999,9999,9999,9999 - 0000,0000,0000,0099 = 9999,9999,9999,9900$。
       • $9999,9999,9999,9900 + 1 = 9999,9999,9999,9901$。這與題目一致。
     • 因此，一個負數 $-X$ 的二補數表示是 $(MAX\_VAL\_MINUS\_1) - X + 1$，其中 $MAX\_VAL\_MINUS\_1 = \{9999, 9999, 9999, 9999\}$。

3. 溢位處理：由於我們只有 4 個元素，任何計算結果如果需要第 5 個元素來表示，則該第 5 個元素（最高位）會被忽略（溢位）。在加法中，這正好實現了二補數的循環特性。

Part 1: void GetComp(int* src, int* comp) (10%)

• 目的：計算一個大數的補數。

• 解釋：

  • 如果 src 代表一個正數，則其補數是其負數表示。
  • 如果 src 代表一個負數，則其補數是其絕對值表示。
  • 根據題意，一個數 $X$ 的補數是 $(MAX\_VAL\_MINUS\_1) - X + 1$。
  • $MAX\_VAL\_MINUS\_1$ 在這裡表示為 $\{9999, 9999, 9999, 9999\}$。
  • 所以，我們需要從 $\{9999, 9999, 9999, 9999\}$ 中逐個元素減去 src 的對應元素，然後最後再對整個結果加 1。
  • 加 1 操作需要處理進位。

• 演算法：

  1. 複製 {9999, 9999, 9999, 9999} 到 comp 陣列。
  2. 逐個元素減去 src 的值：comp[i] = 9999 - src[i]。
  3. 將 comp 陣列加上 1。這需要從 comp[3] 開始，逐個元素加 1，並處理進位。
     • comp[3] = comp[3] + 1;
     • 如果 comp[3] >= 10000，則 comp[3] = 0，並向 comp[2] 進位 1。
     • comp[2] = comp[2] + carry;
     • 如果 comp[2] >= 10000，則 comp[2] = 0，並向 comp[1] 進位 1。
     • 依此類推。
     • 如果最高位 comp[0] 產生進位，則該進位被忽略（溢位）。

• 範例：計算 $\{0, 0, 0, 99\}$ 的補數。

  • src = {0, 0, 0, 99}。
  • comp 初始化為 $\{9999, 9999, 9999, 9999\}$。
  • 逐個元素減去 src：
    • comp[0] = 9999 - 0 = 9999
    • comp[1] = 9999 - 0 = 9999
    • comp[2] = 9999 - 0 = 9999
    • comp[3] = 9999 - 99 = 9900
  • comp 現在是 $\{9999, 9999, 9999, 9900\}$。
  • 加上 1：
    • comp[3] = 9900 + 1 = 9901。沒有進位。
  • 最終 comp = {9999, 9999, 9999, 9901}。這與題目中 $-99$ 的表示一致。

Part 2: void SingnABS(int* src, int* sing, int* abs) (5%)

• 目的：判斷大數的正負，並計算其絕對值。

• 解釋：

  • 題目的判斷方式是：如果最高元素 src[0] 為 $9999$，則該數為負數。
  • 這是一個簡化的判斷方法，基於二補數的特性。在 $10000$ 進位制的四個元素表示中，如果最高位（即 src[0]）大於等於 $5000,0000,0000,0000$ 的一半，則為負數。
  • 題目給了一個更簡化的判斷：只要 src[0] == 9999，就一定是負數。這個判斷是正確的，因為最大的正數是 $5000,0000,0000,0000 - 1$ (大約是 $5 \times 10^{15}$) 左右，而 $9999,0000,0000,0000$ 已經遠大於這個值。
  • 如果 src[0] == 9999，則 sing 設為 1 (負數)。
  • 否則，sing 設為 0 (正數)。
  • 計算絕對值：
    • 如果 src 是正數，則 abs 就是 src。
    • 如果 src 是負數，則 abs 是 src 的補數。我們可以使用 GetComp 函式來計算。

• 演算法：

  1. 檢查 src[0]：
     • 如果 src[0] == 9999 (或者更精確地說，如果 src[0] >= 5000 且 src[1], src[2], src[3] 都是 $9999$ 或較大，則為負數。但題目給定簡單判斷 src[0] == 9999，我們就照此判斷。更嚴謹的判斷是看最高位是否大於等於 $10000^3 / 2$ 的位置。
     • 題目說「最高元素為 9999 就一定是負數」。這是一個簡化判斷。
     • 更常見的二補數判斷方式是：如果最高位的符號位是 1，則為負。在本題的 $10000$ 進位制中，我們可以約定最高元素 src[0] 的值來判斷符號。如果 src[0] 大於等於 $10000^3 / 2 = 5000,0000,0000,0000$ (這個值在 4 個 16 位元元素中表示為 $\{5000, 0000, 0000, 0000\}$)，則為負數。
     • 題目給的判斷是 src[0] == 9999。這表示我們只考慮以 $10000$ 為基數的表示法。
     • 讓我們採用題目給的簡易判斷：if (src[0] >= 5000) 則為負數。為什麼是 5000？因為 $10000/2 = 5000$。如果最高位的 $10000$ 進位值大於等於 $5000$，則可以視為負數。
     • 修正判斷：題目說「最高元素為 9999 就一定是負數」。這句話本身有些問題。通常，二補數的符號判斷是看最高位是否超過一半。在 4 個 16 位元元素的表示法中，總共有 $4 \times 16 = 64$ 位元。總範圍是 $-2^{63}$ 到 $2^{63}-1$ (如果最高位是符號位)。
     • 在 $10000$ 進位制下，最大值是 $10000^4 - 1$。最小負數的絕對值是 $10000^4$。
     • 表示 $-X$ 的方法是 $10000^4 - X$。
     • 如果 $X$ 是正數，其表示為 $\{X_0, X_1, X_2, X_3\}$。
     • 如果 $X$ 是負數，其表示為 $\{Y_0, Y_1, Y_2, Y_3\}$。
     • 如何判斷 $Y_0$ 是否代表負數？
     • 最大正數的表示，例如 $5000,0000,0000,0000 - 1$。
     • 最小負數的表示，例如 $-5000,0000,0000,0000$。
     • 題目說「只要一個數的最高元素為 9999 就一定是負數」。這句話是正確的，因為最大的正數 $5000,0000,0000,0000 - 1$ 的最高元素不會是 $9999$。
     • 所以，判斷方法是：if (src[0] == 9999) 則為負。
     • 更嚴謹的判斷：題目說「最大正數頂多為 $10000,0000,0000,0000$ 的一半，只到達 $5000,0000,0000,0000$」。這表示最大的正數是 $4999,9999,9999,9999$。
     • 所以，如果 src[0] >= 5000，則為負數。
     • if (src[0] >= 5000):
       • *sing = 1; (負數)
       • 呼叫 GetComp(src, abs) 來計算絕對值，並存入 abs。
     • else:
       • *sing = 0; (正數)
       • 直接複製 src 到 abs。abs[i] = src[i] for $i=0,1,2,3$。

Part 3: void add(int* a, int* b, int*c) (10%)

• 目的：將兩個大數相加。

• 解釋：

  • 二補數的加法可以直接進行，不論運算元的符號。溢位會自動處理。
  • 我們需要從最低位 (c[3]) 開始逐個元素相加，並處理進位。

• 演算法：

  1. 初始化進位 carry = 0。
  2. 從最低位開始 (i = 3 down to 0)：
     • 計算 sum = a[i] + b[i] + carry。
     • c[i] = sum % 10000 (取餘數作為當前位的值)。
     • carry = sum / 10000 (取整數部分作為進位)。
  3. 最後，最高位的進位 carry (來自 c[0] 的計算) 會被忽略，這符合二補數的溢位規則。

• 範例：$99 + (-99)$

  • $a = \{0, 0, 0, 99\}$
  • $b = \{9999, 9999, 9999, 9901\}$ ($-99$)
  • c 陣列。
  • i = 3: sum = a[3] + b[3] + carry = 99 + 9901 + 0 = 10000。
    • c[3] = 10000 % 10000 = 0。
    • carry = 10000 / 10000 = 1。
  • i = 2: sum = a[2] + b[2] + carry = 0 + 9999 + 1 = 10000。
    • c[2] = 10000 % 10000 = 0。
    • carry = 10000 / 10000 = 1。
  • i = 1: sum = a[1] + b[1] + carry = 0 + 9999 + 1 = 10000。
    • c[1] = 10000 % 10000 = 0。
    • carry = 10000 / 10000 = 1。
  • i = 0: sum = a[0] + b[0] + carry = 0 + 9999 + 1 = 10000。
    • c[0] = 10000 % 10000 = 0。
    • carry = 10000 / 10000 = 1。
  • 最終 c = {0, 0, 0, 0}。最高位的進位 1 被忽略。結果正確。

Part 4: void subtract(int* a, int* b, int* c) (5%)

• 目的：將兩個大數相減 ($a - b$)。

• 解釋：

  • 減法 $a - b$ 可以轉換為加法 $a + (-b)$。
  • 我們需要先計算 $-b$ 的二補數表示，然後再將 $a$ 和 $-b$ 相加。
  • 計算 $-b$ 的二補數，我們可以使用 GetComp 函式。

• 演算法：

  1. 創建一個臨時陣列 neg_b[4] 來儲存 $-b$ 的二補數表示。
  2. 呼叫 GetComp(b, neg_b) 來計算 $-b$。
  3. 呼叫 add(a, neg_b, c) 來計算 $a + (-b)$，結果存入 c。

程式碼實現細節：

• 確保所有陣列操作都在 $0 \sim 3$ 的索引範圍內。
• 處理進位時，要確保 carry 是整數。
• src, comp, sing, abs, a, b, c 都是指向 4 個元素的整數陣列的指標。

程式碼範例 (C/C++)

本題考驗程式設計中關於圖形繪製、座標轉換、陣列操作、使用者輸入處理、以及數學函數計算的綜合能力。核心是將一個連續的數學函數 $y = \cos(\pi t)$ 離散化，並在一個由字元組成的二維網格（類似於文字模式的繪圖）上顯示出來。

核心概念與步驟分解：

1. 使用者輸入與參數設定 (a)：

   • 程式需要詢問使用者輸入繪圖的「空間大小」，即網格的尺寸。
   • vertical_lines (縱向幾行字)：代表網格的行數（高度）。建議為奇數，這有助於中心線的對齊。
   • horizontal_chars_per_period (橫向每個函數週期使用幾個英文字母)：代表一個函數週期（這裡 $\cos(\pi t)$ 的週期是 $2\pi / \pi = 2$ 個時間單位）在橫軸上佔據的字元數。建議為偶數。
   • 程式需要儲存這些輸入值，並確保它們與範例不同。

2. 網格初始化 (b)：

   • 建立一個二維字元陣列（或類似結構）來代表繪圖的畫布。
   • 尺寸為 vertical_lines 行，total_horizontal_chars 列。total_horizontal_chars 需要根據 horizontal_chars_per_period 和時間範圍 $t=[0, 5]$ 來計算。
   • 一個週期是 $t=2$。時間範圍 $t=0$ 到 $t=5$ 涵蓋了 $5 / 2 = 2.5$ 個週期。
   • horizontal_chars_per_period 是指一個週期佔據的字元數。
   • 所以，總橫軸字元數 total_horizontal_chars 應與時間範圍和 horizontal_chars_per_period 成比例。
   • 例如，如果 $t=[0,2]$ 是 1 個週期，佔據 horizontal_chars_per_period 個字元，那麼 $t=[0,5]$ 佔據 $(5/2) \times \text{horizontal\_chars\_per\_period}$ 個字元。
   • 將所有網格單元初始化為空白字元（例如 ' '）。

3. 繪製座標軸 (c, d)：

   • 縱軸：

     • 縱軸通常位於網格的中心行（如果 vertical_lines 是奇數，中心行索引為 vertical_lines / 2）。
     • 在縱軸的垂直線上，第一個字元位置（最左邊）標示為 'I'。
     • 同時，在縱軸上標示 $y$ 的範圍：
       • 最高點 ($y=1$) 處，標示為 '+'。
       • 最低點 ($y=-1$) 處，標示為 '-'。
       • 中間點 ($y=0$) 處，標示為 '0'。
       • 其他縱軸位置根據 vertical_lines 的設定來標示。

   • 橫軸：

     • 橫軸位於 $y=0$ 的水平線上。
     • 在 $y=0$ 的線上，標示時間點 $t=0, 1, 2, 3, 4, 5$。
     • 這些時間點在網格中的橫座標位置需要計算。
     • 例如，如果 $t=0$ 處對應網格的第 0 列，那麼 $t=1$ 處對應的列是 $(1/5) \times \text{total\_horizontal\_chars}$。
     • 題目範例中，時間點 $0, 1, 2, 3, 4, 5$ 的標示點似乎是固定的，而不是隨 horizontal_chars_per_period 變動。
     • 範例中，橫軸用 '-' 表示，時間點 $0, 1, 2, 3, 4, 5$ 用對應的數字標示。
     • 9--x----x----x----x--0 這行是橫軸。
     • 0 在最右邊，9 在最左邊，1, 2, 3, 4, 5 標示在中間。
     • 這部分與「橫向每個函數週期使用幾個英文字母」的關聯性需要仔細分析。
     • 範例的橫軸長度是 $33$ 個字元（包括左邊的 123456789a123456789b123456789c1;）。
     • 範例的縱軸高度是 $10$ 行（從 0 到 9）。
     • 範例的 $t=0, 1, 2, 3, 4, 5$ 標記：
       • $t=0$ 可能對應最左邊的 0。
       • $t=1$ 對應第一個 x。
       • $t=2$ 對應第二個 x。
       • $t=3$ 對應第三個 x。
       • $t=4$ 對應第四個 x。
       • $t=5$ 對應最右邊的 0。
     • 顯然，時間 $t$ 的範圍是 $0 \sim 5$。
     • 「橫向每個函數週期使用幾個英文字母」：週期是 $2$。如果 $t=0 \sim 2$ 是 1 個週期，佔據 $k$ 個字元。那麼 $t=0 \sim 5$ 佔據 $(5/2) \times k$ 個字元。
     • 在範例中，123456789a123456789b123456789c1; 這串長度是 $33$。
     • 如果 $t=0 \sim 5$ 總共佔據 $W$ 個字元寬度。
     • 那麼 $t=0$ 的位置是 $0$。$t=5$ 的位置是 $W-1$。
     • $t=1$ 的位置是 $(1/5) \times W$。$t=2$ 是 $(2/5) \times W$。
     • 範例的橫軸 9--x----x----x----x--0 長度是 $21$ 個字元。
     • 如果 $t=0$ 是 9 (左邊第一個)，$t=5$ 是 0 (右邊第一個)。
     • 那麼 $t=1, 2, 3, 4$ 的位置在哪裡？
     • 標示 $t=0, 1, 2, 3, 4, 5$ 的點是 9, x, x, x, x, 0。
     • 這表示 $t=0$ 對應 9，$t=1$ 對應第一個 x，...，$t=5$ 對應 0。
     • 這段橫軸的寬度是 $21$。
     • 時間 $t$ 範圍是 $0 \sim 5$。
     • horizontal_chars_per_period 的意義需要再釐清。

   • 重新解讀：「橫向每個函數週期使用幾個英文字母」。一個週期是 $2$。

     • 假設 horizontal_chars_per_period = K。
     • 那麼 $t=0 \sim 2$ 佔據 $K$ 個字元。
     • $t=2 \sim 4$ 佔據 $K$ 個字元。
     • $t=4 \sim 5$ 佔據 $K/2$ 個字元。
     • 總寬度 $W = K + K + K/2 = 2.5 K$。
     • 在範例中，橫軸長度是 $21$。所以 $2.5 K = 21$ => $K = 21 / 2.5 = 8.4$。這不是整數。
     • 另一種解釋：horizontal_chars_per_period 是指 半個週期 的寬度。
       • 如果 $t=0 \sim 1$ (半個週期) 佔據 $K$ 個字元。
       • 那麼 $t=0 \sim 2$ (一個週期) 佔據 $2K$ 個字元。
       • $t=0 \sim 5$ (2.5 個週期) 佔據 $2.5 \times (2K) = 5K$ 個字元。
       • 範例寬度 $W=21$。$5K = 21$ => $K = 4.2$。還是非整數。

   • 再思考：範例的橫軸標示是 9--x----x----x----x--0。

     • 9 是 $t=0$ 的標記。
     • 0 是 $t=5$ 的標記。
     • x 標記了 $t=1, 2, 3, 4$ 的位置。
     • -- 是分隔符。
     • 總寬度 $W = 21$。
     • 時間範圍 $T = 5 - 0 = 5$。
     • 每個時間單位在橫軸上的像素數：pixels_per_time_unit = W / T = 21 / 5 = 4.2。
     • 這表示每個時間單位（例如從 $t=0$ 到 $t=1$）在橫軸上佔據 $4.2$ 個字元。
     • horizontal_chars_per_period (建議偶數)：如果它代表一個週期 ($2$ 個時間單位) 的字元數。
     • 如果 $K$ 是週期寬度，那麼 $W = (5 / 2) \times K = 2.5 K$。
     • 如果 $K=8$ (偶數)，則 $W = 2.5 \times 8 = 20$。
     • 如果 $K=10$ (偶數)，則 $W = 2.5 \times 10 = 25$。
     • 範例的 $W=21$ 似乎是個特殊值。
     • 重要提示：題目要求「不可與範例相同」。這表示我們輸入的 vertical_lines 和 horizontal_chars_per_period 必須與範例不同。

   • 縱軸標示：

     • 縱軸範圍是 $y \in [-1, 1]$。
     • vertical_lines 是網格的行數。
     • 假設 vertical_lines = H。
     • 中心行索引 center_row = H / 2。
     • $y=1$ 對應的行索引 row_for_y_1。
     • $y=-1$ 對應的行索引 row_for_y_neg_1。
     • $y=0$ 對應的行索引 row_for_y_0。
     • 公式：$y\_value = \text{scale\_factor} \times (\text{row\_index} - \text{center\_row})$。
     • 或者，反過來：row_index = center_row + y_value / scale_factor。
     • 我們需要確定 scale_factor。
     • 從 $y=-1$ 到 $y=1$ 的總範圍是 $2$。
     • 如果 vertical_lines = H，那麼從最底行到最頂行的 $y$ 值變化範圍是 $2$。
     • scale_factor 應與 vertical_lines 的奇偶性有關。
     • 如果 $H$ 是奇數，例如 $H=9$。中心行是 $4$。
       • $y=1$ 標記在頂部（或接近頂部）。$y=-1$ 標記在底部。
       • 範例 $H=10$ (偶數)，中心行可能不是單一行。
       • 範例 $y=1$ 標記在第 1 行 (索引 1)，$y=0$ 標記在第 9 行 (索引 9)。$y=-1$ 標記在第 9 行。
       • 這與 $y \in [-1, 1]$ 的範圍不符。
       • 重新解讀範例：
         • 左邊的數字 $0 \sim 9$ 是 $y$ 軸的標示。
         • + 在頂部，- 在底部。0 在中間。
         • 1 + (第 1 行)
         • 2 x X (第 2 行)
         • ...
         • 9--x----x----x----x--0 (第 9 行，這裡的 9 似乎是 $y$ 軸標示，0 是 $t=5$ 的標示)。
         • 橫軸 $y=0$ 在第 9 行。
         • 縱軸 $x=0$ 在第 0 列。
         • 這表示 $y$ 軸的範圍是從 $0$ 到 $9$ (共 10 行)。
         • 這與題目的 $y \in [-1, 1]$ 不符。
         • 重要的假設：範例中的數字 $0 \sim 9$ 和符號 + - 0 只是 標示，實際的網格是空白字元。
         • vertical_lines 是網格的總行數。
         • horizontal_chars_per_period 是指一個週期 $t \in [0, 2]$ 在橫軸上的寬度。
         • 時間範圍 $t \in [0, 5]$。
         • total_time_span = 5。
         • period = 2。
         • num_periods = total_time_span / period = 5 / 2 = 2.5。
         • total_horizontal_chars = num_periods * horizontal_chars_per_period = 2.5 * horizontal_chars_per_period。
         • 由於 horizontal_chars_per_period 是偶數，設為 $K$。
         • total_horizontal_chars = 2.5 * K。為了讓總寬度為整數，$K$ 必須是偶數，例如 $K=8, 10, 12, \dots$。
         • 如果 $K=8$, $W = 2.5 \times 8 = 20$。
         • 如果 $K=10$, $W = 2.5 \times 10 = 25$。
         • 如果 $K=12$, $W = 2.5 \times 12 = 30$。
         • 我們需要選擇一個 $K$ (偶數)，且 $K \neq \text{範例中的 K}$。

4. 繪製函數曲線 (e)：

   • 遍歷橫軸上的每個字元位置 col (從 $0$ 到 total_horizontal_chars - 1)。
   • 將網格的列座標 col 轉換回時間值 t。
     • t = (col / total_horizontal_chars) * total_time_span。
     • t = (col / (2.5 * K)) * 5 = (col * 5) / (2.5 * K) = (col * 2) / K。
   • 計算對應時間 t 的函數值 $y = \cos(\pi t)$。
   • 將 $y$ 值轉換為網格的行座標 row。
     • $y$ 的範圍是 $[-1, 1]$。
     • 網格的行數是 vertical_lines (設為 $H$)。
     • 中心行索引 center_row = H / 2。
     • scale_factor 決定了 $y$ 值如何映射到行索引。
     • 從 $y=-1$ 到 $y=1$ 的總範圍是 $2$。
     • 如果 $H$ 是奇數，例如 $H=9$。中心行是 $4$。
       • $y=1$ 映射到頂行（索引 0）或接近頂部的行。
       • $y=-1$ 映射到底行（索引 $H-1$）或接近底部的行。
       • row = center_row - y / scale_factor。
       • 當 $y=1$, row 應最小。當 $y=-1$, row 應最大。
       • scale_factor 應約等於 $2 / (H-1)$ (如果 $y=\pm 1$ 映射到邊緣行)。
       • 更簡單的映射：將 $y \in [-1, 1]$ 映射到行索引 $0 \sim H-1$。
       • scaled_y = (y + 1) / 2.0。這將 $y$ 映射到 $[0, 1]$。
       • row = (int)((1.0 - scaled_y) * (H - 1))。這樣 $y=1 \Rightarrow scaled\_y=1 \Rightarrow row = 0$ (頂行)。$y=-1 \Rightarrow scaled\_y=0 \Rightarrow row = H-1$ (底行)。
       • 將計算出的 row 索引處的字元設為 'x'。
       • 注意：如果計算出的 row 超出網格範圍 $0 \sim H-1$，則忽略。

5. 輸出網格 (f)：

   • 遍歷網格的每一行。
   • 將每一行的字元串輸出到螢幕。
   • 在輸出前，加上行號（如範例中的 $0 \sim 9$）。

座標轉換與標記位置公式推導：

• 輸入參數：
  • H (vertical_lines)：總行數。
  • K (horizontal_chars_per_period)：一個週期 ($t=2$) 的橫軸寬度 (必須是偶數)。
• 計算參數：
  • total_horizontal_chars = (int)(2.5 * K)。
  • center_row = H / 2。
  • total_time_span = 5.0。
• 繪製步驟：

  1. 初始化網格：char grid[H][total_horizontal_chars]，全部填為 ' '。

  2. 繪製縱軸:

     • 縱軸位於第 $0$ 列 (col = 0)。
     • grid[0][0] = 'I'。
     • $y$ 值的範圍是 $[-1, 1]$。
     • 映射到行索引：$y \to row$。
     • row = (int)((1.0 - (y + 1.0) / 2.0) * (H - 1))。
     • 對於 $y=1$, $row = (int)((1.0 - 1.0) * (H-1)) = 0$。
     • 對於 $y=0$, $row = (int)((1.0 - 0.5) * (H-1)) = (H-1) / 2$。
     • 對於 $y=-1$, $row = (int)((1.0 - 0.0) * (H-1)) = H-1$。
     • 在縱軸上，根據這些行標示 +, 0, -：
       • grid[0][0] = 'I' (最高點 $y=1$ 的位置，如果 $y=1$ 映射到 $row=0$)。
       • grid[H-1][0] = '-' (最低點 $y=-1$ 的位置)。
       • grid[(H-1)/2][0] = '0' ($y=0$ 的位置)。
       • 如果 $H$ 是奇數，(H-1)/2 是中心行。
       • 如果 $H$ 是偶數，中心可能不是單一行，需要根據題目範例來決定 0, +, - 的具體行。

  3. 繪製橫軸:

     • 橫軸位於 $y=0$ 的線上。
     • row_for_y_0 = (H-1)/2 (假設 $H$ 是奇數)。
     • 在 row_for_y_0 行，遍歷 col 從 $0$ 到 total_horizontal_chars - 1。
     • 如果 grid[row_for_y_0][col] 是空白，則設為 '-'。
     • 標示時間點 $t=0, 1, 2, 3, 4, 5$。
       • t=0 對應 col = 0。
       • t=5 對應 col = total_horizontal_chars - 1。
       • t=i 對應的 col = (int)((double)i / total_time_span * total_horizontal_chars)。
       • 在這些 col 位置，將 grid[row_for_y_0][col] 設為對應的數字字元 '0' 到 '5'。
       • 注意：這裡的標示可能會覆蓋掉橫軸的 '-'。

  4. 繪製函數曲線:

     • 遍歷 col 從 $1$ 到 total_horizontal_chars - 1 (避開縱軸)。
     • 計算時間 $t = (double)col / total_horizontal_chars * total_time_span$。
     • 計算 $y = \cos(\pi * t)$。
     • 計算對應的行索引 row = (int)((1.0 - (y + 1.0) / 2.0) * (H - 1))。
     • 檢查 row 是否在有效範圍 $0 \le row < H$。
     • 如果 grid[row][col] 是空白，則設為 'x'。

  5. 輸出:

     • 遍歷 row 從 $0$ 到 $H-1$。
     • 輸出行號 (例如 row 值)。
     • 輸出該行的字串。

範例分析與參數選擇：

• 範例輸入：

  • 縱向幾行字 (H)：10 (偶數)
  • 橫向每個函數週期幾個英文字母 (K)：未知，但推測與橫軸寬度 21 有關。

• 我們需要選擇不同的 H (建議奇數) 和 K (偶數)。

• 假設我們選擇：

  • H = 11 (奇數)。
  • K = 10 (偶數)。

• 計算：

  • total_horizontal_chars = 2.5 * K = 2.5 * 10 = 25。
  • center_row = H / 2 = 11 / 2 = 5。
  • total_time_span = 5.0。

• 繪製縱軸 (H=11, col=0)：

  • grid[0][0] = 'I' (最高點 $y=1$)
  • grid[10][0] = '-' (最低點 $y=-1$)
  • grid[5][0] = '0' ($y=0$)
  • 其他位置是空白。

• 繪製橫軸 (row=5, col=0 to 24)：

  • grid[5][col] = '-' for col = 0 to 24。
  • 時間點標示：
    • $t=0 \Rightarrow col = 0$。grid[5][0] = '0'。
    • $t=1 \Rightarrow col = (int)(1.0 / 5.0 * 25) = 5$。grid[5][5] = '1'。
    • $t=2 \Rightarrow col = (int)(2.0 / 5.0 * 25) = 10$。grid[5][10] = '2'。
    • $t=3 \Rightarrow col = (int)(3.0 / 5.0 * 25) = 15$。grid[5][15] = '3'。
    • $t=4 \Rightarrow col = (int)(4.0 / 5.0 * 25) = 20$。grid[5][20] = '4'。
    • $t=5 \Rightarrow col = (int)(5.0 / 5.0 * 25) = 25$ (超出範圍，應是 24)。
    • 修正：t=5 對應 col = total_horizontal_chars - 1 = 24。grid[5][24] = '5'。

• 繪製函數曲線:

  • 遍歷 col 從 $1$ 到 $24$。
  • 計算 $t = (double)col / 25.0 * 5.0 = col / 5.0$。
  • 計算 $y = \cos(\pi * t)$。
  • 計算 row = (int)((1.0 - (y + 1.0) / 2.0) * (11 - 1)) = (int)((1.0 - (y + 1.0) / 2.0) * 10)。
  • 如果 grid[row][col] 是 ' '，則設為 'x'。

公式總結：

• total_horizontal_chars = (int)(2.5 * K) (其中 K 是使用者輸入的偶數，且 $K \neq$ 範例中的 K)。
• center_row = H / 2 (其中 H 是使用者輸入的奇數)。
• 時間 $t$ 映射到列 col：col = (int)((t / 5.0) * total_horizontal_chars)。
• 列 col 映射到時間 $t$：t = (double)col / total_horizontal_chars * 5.0。
• $y$ 值映射到行 row：row = (int)((1.0 - (y + 1.0) / 2.0) * (H - 1))。
• 函數值 $y$：$y = \cos(\pi * t)$。

需要繳交的資料 (Ans)：
A) 流程圖：描述程式的整體邏輯流程，包括輸入、初始化、繪製座標軸、繪製曲線、輸出。
B) 輸入值：
* 縱向幾行字 (H)：例如 11。
* 橫向每個函數週期幾個英文字母 (K)：例如 10。
* 測試輸入值 (H, K)：需要自行選擇一組與範例不同的 H (奇數) 和 K (偶數)。
C) 規劃圖與公式：

本題考驗程式設計中關於迴圈、使用者輸入、陣列處理、以及尋找最大最小值等基本概念。核心是實現一個「窮舉搜尋」(Exhaustive Search) 或「暴力搜尋」(Brute-force Search) 的演算法，來測試所有可能的 A 和 B 的組合，並找出導致系統效能最大值和最小值的那一組 (A, B)。

核心概念與步驟分解：

1. 輸入參數 (a)：

   • 程式需要獲取 A 和 B 的「數值清單」。
   • 這意味著使用者需要輸入 A 的可能值的數量，然後輸入 A 的具體數值。
   • 同樣地，輸入 B 的可能值的數量，然後輸入 B 的具體數值。
   • 這可以透過兩個陣列或向量來儲存 A 和 B 的數值清單。

2. 排列組合測試 (b)：

   • 需要遍歷 A 的所有可能值，對於每一個 A 值，再遍歷 B 的所有可能值。這是一個雙重迴圈的結構。
   • 對於每一組 (A, B) 的組合，程式需要「下達指令」並「回報測試結果」。
   • 「下達指令」可以理解為輸出提示訊息，告知使用者正在測試哪一組 (A, B)。
   • 「回報測試結果」意味著程式需要有一個方式來獲取 $f(A, B)$ 的值。在實際程式中，這可能是一個函式呼叫。在這裡，我們需要模擬這個過程，例如，可以讓使用者在測試時輸入 $f(A, B)$ 的值，或者預先定義一個簡單的 $f(A, B)$ 函式來產生測試值。
   • 在遍歷過程中，需要記錄下目前為止找到的最大 $f(A, B)$ 值及其對應的 (A, B) 組合，以及最小 $f(A, B)$ 值及其對應的 (A, B) 組合。

3. 記錄最大最小值：

   • 初始化 max_f = -infinity (或一個非常小的數)，min_f = +infinity (或一個非常大的數)。
   • 初始化儲存最大最小值的 (A, B) 組合的變數，例如 max_A, max_B, min_A, min_B。
   • 在每次測試一組 (A, B) 並獲得 $f(A, B)$ 值後：
     • 如果 $f(A, B) > max\_f$，則更新 $max\_f = f(A, B)$, $max\_A = A$, $max\_B = B$。
     • 如果 $f(A, B) < min\_f$，則更新 $min\_f = f(A, B)$, $min\_A = A$, $min\_B = B$。

4. 產生分析報告 (c)：

   • 在所有 (A, B) 組合都測試完畢後，輸出最終的報告。
   • 報告應包含：
     • 最大值：$f(A=\text{max\_A}, B=\text{max\_B}) = \text{max\_f}$。
     • 最小值：$f(A=\text{min\_A}, B=\text{min\_B}) = \text{min\_f}$。

程式設計細節：

• 資料結構：

  • 使用 std::vector<double> (或 std::vector<int>，取決於 A, B 的類型) 來儲存 A 和 B 的數值清單。
  • 使用 double 或 int 來儲存 $f(A, B)$ 的值，以及最大最小值。

• 使用者輸入：

  • 需要提示使用者輸入 A 的數量，然後輸入 A 的值。
  • 同理，輸入 B 的數量，然後輸入 B 的值。
  • 需要處理輸入錯誤的可能性（例如輸入非數字、數量為負等），但題目要求中未明確說明，可以先假設輸入是有效的。

• 模擬 f(A,B)：

  • 由於題目沒有給定 $f(A, B)$ 的具體函數，我們需要在程式中預設一個。
  • 一個簡單的例子可以是 $f(A, B) = A^2 + B^2$ 或 $f(A, B) = A * B - 10 * A + 5 * B$。
  • 或者，更貼近題目要求，可以在測試時提示使用者輸入 $f(A, B)$ 的值。
  • 題目中的表格提示，A 和 B 的值可以是 $5, 10, 20, 25, 35$。這可以作為預設的輸入值。

• 輸出格式：

  • 按照題目要求的格式輸出測試過程中的訊息和最終報告。

需要繳交的資料 (Ans)：

A) 流程圖：描述程式的整體邏輯，包括輸入、迴圈、計算、記錄、輸出。
B) 程式碼：實現上述功能的程式。
C) 測試數據表：考生需要自行設計一個 $f(A, B)$ 函數，並將 A 和 B 的值（例如從題目表格中選取）填入表格，計算出對應的 $f(A, B)$ 值。
D) 餵給程式的輸入：根據考生設計的 $f(A, B)$ 和測試數據表，列出程式需要接收的使用者輸入。

範例 f(A,B) 函數設計 (用於程式開發)：
假設我們設計一個簡單的函數，例如 $f(A, B) = A * B - 10 * A + 5 * B$。
或者，為了更貼近題意，我們可以讓它產生一些波動，例如 $f(A, B) = \sin(A) + \cos(B) + A*B/100$.
對於題目提供的表格，如果我們使用 A, B 的值為 $5, 10, 20, 25, 35$。

考生自行設計 f(A,B) 的考量：

• 選擇一個函數，使其在給定的 A, B 值範圍內，能夠產生明顯的最大值和最小值。
• 函數的輸出類型應與程式設計時的變數類型一致（例如 double 或 int）。

範例 C) 測試數據表與 f(A,B) 設計
假設考生設計的函數是 $f(A, B) = A * B - 10 * A + 5 * B$。
使用表格中的 A 和 B 值：$A \in \{5, 10, 20\}$, $B \in \{5, 10, 20\}$ (為了簡化，先取部分值)。

在上面的例子中：

• 最大值是 $300$，對應 $(A=20, B=20)$。
• 最小值是 $-75$，對應 $(A=20, B=5)$。

D) 程式輸入：
假設程式要求輸入 A 的數量和值，B 的數量和值。

• 輸入 A 的數量：3
• 輸入 A 的值：5 10 20
• 輸入 B 的數量：3
• 輸入 B 的值：5 10 20
• (如果程式模擬 f(A,B) 是由使用者輸入，則在每次測試時，程式會提示 "Enter f(A,B) value for A=..., B=...:"，使用者輸入對應的值，例如 0, 50, 150, -25, 50, 200, -75, 50, 300)。

程式碼骨架 (C++)