---
# System prepended metadata

title: C++ 基礎語法練習題：Unit-6 多維陣列、多重迴圈
tags: [演算法, C++, APCS, Python]

---

# C++ 基礎語法練習題：Unit-6 多維陣列、多重迴圈

講義不是我寫的，原文連結為 [Yui Huang 演算法學習筆記：C++ 基礎語法](https://yuihuang.com/syntax/)
我只是將自己寫的練習題程式碼記錄下來。
最後更新日期：2024年11月12日


## [ZeroJudge: a015. 矩陣的翻轉](https://zerojudge.tw/ShowProblem?problemid=a015)

### Python 程式碼

執行時間最久約為 17 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
import sys

for line in sys.stdin:
    m, n = map(int, line.split())
    mat = [list(map(int, input().split())) for _ in range(m)]
    for i in range(n):
        for j in range(m):
            print(mat[j][i], end="\n" if j == m-1 else " ")
```

### C++ 程式碼

執行時間最久約為 2 ms，使用記憶體最多約為 308 kB，通過測試。
```cpp=
#include <iostream>
using namespace std;

int main() {
    int m, n;
    while(cin >> m >> n) {
        int mat[m][n];
        for(int i=0; i<m; i++)
            for(int j=0; j<n; j++)
                cin >> mat[i][j];
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                cout << mat[j][i] << " \n"[j == m-1];
    }
    return 0;
}
```


## [ZeroJudge: c085. 00350 - Pseudo-Random Numbers](https://zerojudge.tw/ShowProblem?problemid=c085)

### Python 程式碼

使用 collections.defaultdict 記錄每個數字出現的序號，當同一個數字出現第二次時，印出兩次序號的差即為答案，再中止迴圈。執行時間最久約為 38 ms，使用記憶體最多約為 6 MB，通過測試。
```python=
from collections import defaultdict

ca = 0
while True:
    ca += 1
    Z, I, M, L = map(int, input().split())
    if Z == 0 and I == 0 and M == 0 and L == 0: break
    cnt = defaultdict(list)
    cnt[L].append(0)
    idx = 0
    while True:
        idx += 1
        L = (Z*L + I) % M
        cnt[L].append(idx)
        if len(cnt[L]) == 2:
            print(f"Case {ca:d}: {cnt[L][1] - cnt[L][0]:d}")
            break
```

### C++ 程式碼

執行時間最久約為 5 ms，使用記憶體最多約為 1.1 MB，通過測試。
```cpp=
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int ca = 0, Z, I, M, L, idx;
    while(true) {
        ca++;
        cin >> Z >> I >> M >> L;
        if (Z == 0 && I == 0 && M == 0 && L == 0) break;
        unordered_map<int, vector<int>> cnt;
        cnt[L].push_back(0);
        idx = 0;
        while(true) {
            idx++;
            L = (Z*L + I) % M;
            cnt[L].push_back(idx);
            if (cnt[L].size() == 2) {
                cout << "Case " << ca << ": " << cnt[L][1] - cnt[L][0] << "\n";
                break;
            }
        }
    }
    return 0;
}
```


## [ZeroJudge: d097. 10038 - Jolly Jumpers](https://zerojudge.tw/ShowProblem?problemid=d097)

因為 Jolly Jumpers 的定義是長度為 n 的數列，其相鄰兩個數字差的絕對值為 1 ~ n-1，所以 1 ~ n-1 每個值都要各有一個，只要有重複的值或是不在 1 ~ n-1 之間，就不是 Jolly Jumpers。

### Python 程式碼

執行時間最久約為 30 ms，使用記憶體最多約為 4 MB，通過測試。
```python=
import sys

for line in sys.stdin:
    data = list(map(int, line.split()))
    n = data[0]
    arr = data[1:]
    found = [False]*n   # 差值 0 ~ n-1 是否有被找到，其中 0 是用不到的資料
    flag = True  # 是否為 Jolly Jumpers
    for i in range(n-1):  # 依序産生 0 ~ n-2
        diff = abs(arr[i+1] - arr[i])  # 計算相鄰兩數的差絕對值
        if diff < 1 or diff >= n or found[diff]:  # 如果差值不在 1 ~ n-1 之間或是已被找到過
            flag = False  # 不是 Jolly Jumpers
            break  # 中止迴圈
        else: found[diff] = True  # 設定 diff 狀態為已找到
    print("Jolly" if flag else "Not jolly")
```

### C++ 程式碼

執行時間最久約為 5 ms，使用記憶體最多約為 352 kB，通過測試。
```cpp=
#include <iostream>
#include <cmath>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n;
    while(cin >> n) {
        int arr[n], found[n] = {0};  // found 差值 0 ~ n-1 是否有被找到，其中 0 是用不到的資料
        for(int i=0; i<n; i++) cin >> arr[i];
        bool flag = true;  // 是否為 Jolly Jumpers
        for(int i=0; i<n-1; i++) {  // 依序産生 0 ~ n-2
            int diff = abs(arr[i+1] - arr[i]);  // 計算相鄰兩數的差絕對值
            if (diff < 1 || diff >= n || found[diff]) {  // 如果差值不在 1 ~ n-1 之間或是已被找到過
                flag = false;  // 不是 Jolly Jumpers
                break;  // 中止迴圈
            } else found[diff]++;  // 設定 diff 狀態為已找到
        }
        cout << (flag ? "Jolly" : "Not jolly") << "\n";
    }
    return 0;
}
```


## [ZeroJudge: d123. 11063 - B2-Sequence](https://zerojudge.tw/ShowProblem?problemid=d123)

因為條件為 $b_i + b_j$ 皆不相等而且 $i \leq j$，要檢測 $i = j$ 的狀況。

### Python 程式碼

使用 set，執行時間最久約為 29 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
import sys

ca = 0  # 第幾個測試的 case
for line in sys.stdin:
    ca += 1  # ca 加 1
    n = int(line)
    arr = list(map(int, input().split()))
    found = set()   # 已被找到過的任意兩數加總
    flag = True  # 是否為 B2-Sequence
    for i in range(n):  # 依序産生 0 ~ n-1
        if not flag: break  # 如果已經確定不是 B2-Sequence，中止迴圈
        for j in range(i, n):  # 依序産生 i ~ n-1
            isum = arr[i] + arr[j]  # 計算任意兩數的加總
            if isum in found:  # 如果加總已被找到過
                flag = False  # 不是 B2-Sequence
                break  # 中止迴圈
            else: found.add(isum)  # isum 加入 found
    print(f"Case #{ca:d}: It is ", end="")
    print("a B2-Sequence.\n" if flag else "not a B2-Sequence.\n")
```

使用 collections.defaultdict，執行時間最久約為 33 ms，使用記憶體最多約為 3.7 MB，通過測試。
```python=
import sys
from collections import defaultdict

ca = 0  # 第幾個測試的 case
for line in sys.stdin:
    ca += 1  # ca 加 1
    n = int(line)
    arr = list(map(int, input().split()))
    found = defaultdict(bool)   # 任意兩數加總是否有被找到過
    flag = True  # 是否為 B2-Sequence
    for i in range(n):  # 依序産生 0 ~ n-1
        if not flag: break  # 如果已經確定不是 B2-Sequence，中止迴圈
        for j in range(i, n):  # 依序産生 i ~ n-1
            isum = arr[i] + arr[j]  # 計算任意兩數的加總
            if found[isum]:  # 如果加總已被找到過
                flag = False  # 不是 B2-Sequence
                break  # 中止迴圈
            else: found[isum] = True  # 設定 isum 狀態為已找到
    print(f"Case #{ca:d}: It is ", end="")
    print("a B2-Sequence.\n" if flag else "not a B2-Sequence.\n")
```

### C++ 程式碼

使用 set，執行時間最久約為 4 ms，使用記憶體最多約為 324 kB，通過測試。
```cpp=
#include <iostream>
#include <set>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n, ca = 0;  // # 第幾個測試的 case
    while(cin >> n) {
        ca++;  // ca 加 1
        int arr[n];
        for(int i=0; i<n; i++) cin >> arr[i];
        set<int> found;   // 已被找到過的任意兩數加總
        bool flag = true;  // 是否為 B2-Sequence
        for(int i=0; i<n; i++) {  // 依序産生 0 ~ n-1
            if (!flag) break;  // 如果已經確定不是 B2-Sequence，中止迴圈
            for(int j=i; j<n; j++) {  // 依序産生 i ~ n-1
                int isum = arr[i] + arr[j];  // 計算任意兩數的加總
                if (found.count(isum) == 1) {  // 如果加總已被找到過
                    flag = false;  // 不是 B2-Sequence
                    break;  // 中止迴圈
                } else found.insert(isum);  // isum 加入 found
            }
        }
        cout << "Case #" << ca << ": It is ";
        cout << (flag ? "a" : "not a") << " B2-Sequence.\n\n";
    }
    return 0;
}
```

使用 unordered_map，執行時間最久約為 4 ms，使用記憶體最多約為 364 kB，通過測試。
```cpp=
#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n, ca = 0;  // # 第幾個測試的 case
    while(cin >> n) {
        ca++;  // ca 加 1
        int arr[n];
        for(int i=0; i<n; i++) cin >> arr[i];
        unordered_map<int, bool> found;   // 已被找到過的任意兩數加總
        bool flag = true;  // 是否為 B2-Sequence
        for(int i=0; i<n; i++) {  // 依序産生 0 ~ n-1
            if (!flag) break;  // 如果已經確定不是 B2-Sequence，中止迴圈
            for(int j=i; j<n; j++) {  // 依序産生 i ~ n-1
                int isum = arr[i] + arr[j];  // 計算任意兩數的加總
                if (found[isum]) {  // 如果加總已被找到過
                    flag = false;  // 不是 B2-Sequence
                    break;  // 中止迴圈
                } else found[isum] = true;  // found[isum] 設定為 true
            }
        }
        cout << "Case #" << ca << ": It is ";
        cout << (flag ? "a" : "not a") << " B2-Sequence.\n\n";
    }
    return 0;
}
```


## [ZeroJudge: b130. NOIP2006 1.明明的随机数](https://zerojudge.tw/ShowProblem?problemid=b130)

### Python 程式碼

執行時間最久約為 18 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
n = int(input())
ans = sorted(list(set(map(int, input().split()))))
print(len(ans))
print(*ans)
```

### C++ 程式碼

使用 set，因為 C++ 的 set 資料會由小到大排序，可以直接印出資料。執行時間最久約為 2 ms，使用記憶體最多約為 348 kB，通過測試。
```cpp=
#include <iostream>
#include <set>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n, m; cin >> n;
    set<int> arr;
    for(int i=0; i<n; i++) {
        cin >> m;
        arr.insert(m);
    }
    cout << arr.size() << "\n";
    size_t idx = 0;
    for(auto a : arr) {
        cout << a << " \n"[idx == arr.size()-1];
        idx++;
    }
    return 0;
}
```


## [ZeroJudge: d673. 11608 - No Problem](https://zerojudge.tw/ShowProblem?problemid=d673)

### Python 程式碼

執行時間最久約為 17 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
ca = 0  # 第幾個測試資料
while True:
    n = int(input())  # 目前有的題目數量
    if n == -1: break  # 如果讀到 -1 中止迴圈
    ca += 1  # 編號加 1
    print(f"Case {ca:d}:")  # 印出 Case X:
    stocks = list(map(int, input().split()))  # 每個月産生的題目數量
    used = list(map(int, input().split()))  # 每個月用掉的題目數量
    for i in range(12):  # 依序檢查 12 個月
        if n >= used[i]:  # 如果目前的題目數量夠多
            print("No problem! :D")
            n = n - used[i] + stocks[i]  # 更新題目數量，減去用掉的題數、加上産生的題目
        else:  # 如果目前的題目數量不夠多
            print("No problem. :(")
            n += stocks[i]  # 更新題目數量，加上産生的題目
```

### C++ 程式碼

執行時間最久約為 2 ms，使用記憶體最多約為 344 kB，通過測試。
```cpp=
#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int ca = 0;  // 第幾個測試資料
    while(true) {
        int n; cin >> n;  // 目前有的題目數量
        if (n == -1) break;  // 如果讀到 -1 中止迴圈
        ca++;  // 編號加 1
        cout << "Case " << ca << ":\n";  // 印出 Case X:
        int stocks[12], used[12];  // stocks 每個月産生的題目數量，used 每個月用掉的題目數量
        for(int i=0; i<12; i++) cin >> stocks[i];
        for(int i=0; i<12; i++) cin >> used[i];
        for(int i=0; i<12; i++) {  // 依序檢查 12 個月
            if (n >= used[i]) {  // 如果目前的題目數量夠多
                cout << "No problem! :D\n";
                n = n - used[i] + stocks[i];  // 更新題目數量，減去用掉的題數、加上産生的題目
            } else {  // 如果目前的題目數量不夠多
                cout << "No problem. :(\n";
                n += stocks[i];  // 更新題目數量，加上産生的題目
            }
        }
    }
    return 0;
}
```


## [ZeroJudge: c135. 00706 - LC-Display](https://zerojudge.tw/ShowProblem?problemid=c135)

### Python 程式碼

想法比較單純的寫法，將每個數字要印出的資料都寫在自訂函式中，先産生所有要印出的資料最後再印出。執行時間最久約為 20 ms，使用記憶體最多約為 3.7 MB，通過測試。
```python=
def myfunc(num, s):
    if num == 0: return zero(s)
    elif num == 1: return one(s)
    elif num == 2: return two(s)
    elif num == 3: return three(s)
    elif num == 4: return four(s)
    elif num == 5: return five(s)
    elif num == 6: return six(s)
    elif num == 7: return seven(s)
    elif num == 8: return eight(s)
    elif num == 9: return nine(s)
    
def zero(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" "*(s+2))
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    return dis

def one(s):
    dis = [" "*(s+2)]
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" "*(s+2))
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" "*(s+2))
    return dis

def two(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append("|" + " "*(s+1))
    dis.append(" " + "-"*s + " ")
    return dis

def three(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" " + "-"*s + " ")
    return dis

def four(s):
    dis = [" "*(s+2)]
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" "*(s+2))
    return dis

def five(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append("|" + " "*(s+1))
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" " + "-"*s + " ")
    return dis

def six(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append("|" + " "*(s+1))
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    return dis

def seven(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" "*(s+2))
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" "*(s+2))
    return dis

def eight(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    return dis

def nine(s):
    dis = [" " + "-"*s + " "]
    for _ in range(s): dis.append("|" + " "*s + "|")
    dis.append(" " + "-"*s + " ")
    for _ in range(s): dis.append(" "*(s+1) + "|")
    dis.append(" " + "-"*s + " ")
    return dis

while True:
    s, n = input().split()
    if s == "0" and n == "0": break
    s = int(s); m = len(n)
    output = []
    for c in n: output.append(myfunc(int(c), s))
    for i in range(2*s+3):
        for j in range(m):
            print(output[j][i], end="\n" if j == m-1 else " ")
    print()
```

只有5種不同的輸出筆畫，將對應的筆畫寫在自訂函式中。分成5個區段輸出，依序讀取要印出的數字，根據數字選擇對應的筆畫。執行時間最久約為 18 ms，使用記憶體最多約為 3.5 MB，通過測試。
```python=
def bar(s):
    print(" " + "-"*s + " ", end="")

def left(s):
    print("|" + " "*(s+1), end="")

def right(s):
    print(" "*(s+1) + "|", end="")

def space(s):
    print(" "*(s+2), end="")

def both(s):
    print("|" + " "*s + "|", end="")

while True:
    s, n = input().split()
    if s == "0" and n == "0": break
    s = int(s)
    m = len(n)
    for i in range(m):
        if n[i] in "14": space(s)
        else: bar(s)
        print(end="\n" if i == m-1 else " ")
    for i in range(s):
        for j in range(m):
            if n[j] in "0489": both(s)
            elif n[j] in "56": left(s)
            else: right(s)
            print(end="\n" if j == m-1 else " ")
    for i in range(m):
        if n[i] in "017": space(s)
        else: bar(s)
        print(end="\n" if i == m-1 else " ")
    for i in range(s):
        for j in range(m):
            if n[j] in "068": both(s)
            elif n[j] in "2": left(s)
            else: right(s)
            print(end="\n" if j == m-1 else " ")
    for i in range(m):
        if n[i] in "147": space(s)
        else: bar(s)
        print(end="\n" if i == m-1 else " ")
```

### C++ 程式碼

依照 Python 程式碼寫法2改寫而成，執行時間最久約為 2 ms，使用記憶體最多約為 316 kB，通過測試。
```cpp=
#include <iostream>
#include <string>
using namespace std;

void bar(int s) {
    cout << " ";
    for(int i=0; i<s; i++) cout << "-";
    cout << " ";
}

void left(int s) {
    cout << "|";
    for(int i=0; i<s+1; i++) cout << " ";
}

void right(int s) {
    for(int i=0; i<s+1; i++) cout << " ";
    cout << "|";
}

void space(int s) {
    for(int i=0; i<s+2; i++) cout << " ";
}

void both(int s) {
    cout << "|";
    for(int i=0; i<s; i++) cout << " ";
    cout << "|";
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    while(true) {
        string w, n; cin >> w >> n;
        if (w == "0" && n == "0") break;
        int s = stoi(w), m = (int)n.size();
        for(int i=0; i<m; i++) {
            char c = n[i];
            if (c == '1' || c == '4') space(s);
            else bar(s);
            cout << " \n"[i == m-1];
        }
        for(int i=0; i<s; i++) {
            for(int j=0; j<m; j++) {
                char c = n[j];
                if (c == '0' || c == '4' || c == '8' || c == '9') both(s);
                else if (c == '5' || c == '6') left(s);
                else right(s);
                cout << " \n"[j == m-1];
            }
        }
        for(int i=0; i<m; i++) {
            char c = n[i];
            if (c == '0' || c == '1' || c == '7') space(s);
            else bar(s);
            cout << " \n"[i == m-1];
        }
        for(int i=0; i<s; i++) {
            for(int j=0; j<m; j++) {
                char c = n[j];
                if (c == '0' || c == '6' || c == '8') both(s);
                else if (c == '2') left(s);
                else right(s);
                cout << " \n"[j == m-1];
            }
        }
        for(int i=0; i<m; i++) {
            char c = n[i];
            if (c == '1' || c == '4' || c == '7') space(s);
            else bar(s);
            cout << " \n"[i == m-1];
        }
    }
    return 0;
}
```


## [ZeroJudge: b367. 翻轉世界](https://zerojudge.tw/ShowProblem?problemid=b367)

### Python 程式碼

用二維串列，執行時間最久約為 18 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
T = int(input())
for _ in range(T):
    N, M = map(int, input().split())
    mat = [list(map(int, input().split())) for _ in range(N)]
    flag = True
    for i in range(N//2):  # 依序檢查第 i 及 -(i+1) 項
        if mat[i] != mat[-(i+1)][::-1]:  # 使用 [::-1] 將串列反序
            flag = False
            break
    if flag and N%2 == 1:  # 如果 flag 為 True 且 N 為奇數
        if mat[N//2] != mat[N//2][::-1]:  # 檢查正中央的串列反序後是否不同
            flag = False
    print("go forward" if flag else "keep defending")
```

將資料頭尾相接存成一維串列，依序檢查第i項及第-(i+1)項，只要這兩項不相等就中止迴圈，印出 keep defending；如果檢查到中央時仍然相等，印出 go forward。執行時間最久約為 18 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
T = int(input())
for _ in range(T):
    N, M = map(int, input().split())
    mat = []
    for _ in range(N): mat += list(map(int, input().split()))  # 接成一維串列
    flag = True
    for i in range(N*M//2):  # 依序檢查第 i 及 -(i+1) 項
        if mat[i] != mat[-(i+1)]:
            flag = False
            break
    print("go forward" if flag else "keep defending")
```

### C++ 程式碼

使用二維 vector，因為一維 vector 才能整個拿來比較是否相等，一維 array 不行。執行時間最久約為 2 ms，使用記憶體最多約為 344 kB，通過測試。
```cpp=
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    for(int i=0; i<T; i++) {
        int N, M; cin >> N >> M;
        vector<vector<int>> mat (N, vector<int> (M));
        for(int i=0; i<N; i++)
            for(int j=0; j<M; j++)
                cin >> mat[i][j];
        bool flag = true;
        for(int i=0; i<N/2; i++) {  // 依序檢查第 i 及 N-i-1 項
            vector<int> tmp (mat[N-i-1].begin(), mat[N-i-1].end());  // 複製資料
            reverse(tmp.begin(), tmp.end());  // 反序
            if (mat[i] != tmp) {  // 如果不相等
                flag = false;
                break;
            }
        }
        if (flag && N%2 == 1) {  // 如果 flag 為 true 且 N 為奇數
            vector<int> tmp (mat[N/2].begin(), mat[N/2].end());  // 複製資料
            reverse(tmp.begin(), tmp.end());  // 反序
            if (mat[N/2] != tmp) flag = false;  // 檢查正中央的串列反序後是否不同
        }
        cout << (flag ? "go forward\n" : "keep defending\n");
    }
    return 0;
}
```

寫法2，執行時間最久約為 2 ms，使用記憶體最多約為 360 kB，通過測試。
```cpp=
#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    for(int i=0; i<T; i++) {
        int N, M; cin >> N >> M;
        int mat[N*M];
        for(int i=0; i<N; i++)
            for(int j=0; j<M; j++)
                cin >> mat[i*M+j];
        bool flag = true;
        for(int i=0; i<N*M/2; i++) {  // 依序檢查第 i 及 N*M-i-1 項
            if (mat[i] != mat[N*M-i-1]) {
                flag = false;
                break;
            }
        }
        cout << (flag ? "go forward\n" : "keep defending\n");
    }
    return 0;
}
```

## [ZeroJudge: c013. 00488 - Triangle Wave](https://zerojudge.tw/ShowProblem?problemid=c013)

### Python 程式碼

執行時間最久約為 19 ms，使用記憶體最多約為 3.3 MB，通過測試。
```python=
import sys

for line in sys.stdin:
    n = int(line)
    _ = input()
    for _ in range(n):
        A = int(input())
        F = int(input())
        for _ in range(F):
            for i in range(1, A+1): print(str(i)*i)
            for i in range(A-1, 0, -1): print(str(i)*i)
            print()
```

### C++ 程式碼

執行時間最久約為 2 ms，使用記憶體最多約為 320 kB，通過測試。
```cpp=
#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n;
    while(cin >> n) {
        for(int i=0; i<n; i++) {
            int A, F; cin >> A >> F;
            for(int j=0; j<F; j++) {
                for(int k=1; k<=A; k++)
                    for(int m=0; m<k; m++)
                        cout << k << (m == k-1 ? "\n" : "");
                for(int k=A-1; k>=1; k--)
                    for(int m=0; m<k; m++)
                        cout << k << (m == k-1 ? "\n" : "");
                cout << "\n";
            }
        }
    }
    return 0;
}
```


## [ZeroJudge: a040. 阿姆斯壯數](https://zerojudge.tw/ShowProblem?problemid=a040)

### Python 程式碼

執行時間最久約為 0.4 s，使用記憶體最多約為 3.3 MB，通過測試。
```python=
from math import log10

n, m = map(int, input().split())
ans = []
for i in range(n, m+1):
    p = int(log10(i)) + 1  # 計算 i 的位數
    tot = 0  # 加總
    num = i  # 儲存目前要檢測的值
    while num > 0:  # 如果 num 大於 0 繼續執行
        d = num%10  # 取目前的最後一位
        tot += d**p  # 計算 d**p 
        num //= 10  # 刪除最後一位
    if tot == i: ans.append(i)  # 如果 tot 等於 i，i 加入 ans

if len(ans) == 0: print("none")  # 如果 ans 沒有資料，印出 none
else: print(*ans)  # 否則印出 ans 的內容
```

### C++ 程式碼

執行時間最久約為 31 ms，使用記憶體最多約為 356 kB，通過測試。
```cpp=
#include <iostream>
#include <cmath>
#include <vector>
using namespace std;

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int n, m; cin >> n >> m;
    vector<int> ans;
    for(int i=n; i<=m; i++) {
        int p = int(log10(i)) + 1;  // 計算 i 的位數
        int tot = 0, num = i;  // tot 加總，num 儲存目前要檢測的值
        while(num > 0) {  // 如果 num 大於 0 繼續執行
            int d = num%10;  // 取目前的最後一位
            tot += int(pow(d, p));  // 計算 d**p 
            num /= 10;  // 刪除最後一位
        }
        if (tot == i) ans.push_back(i);  // 如果 tot 等於 i，i 加入 ans
    }
    if (ans.empty()) cout << "none\n";  // 如果 ans 沒有資料，印出 none
    else  // 否則印出 ans 的內容
        for(int i=0; i<(int)ans.size(); i++)
            cout << ans[i] << " \n"[i == (int)ans.size()-1];
    return 0;
}
```


## [ZeroJudge: a693. 吞食天地](https://zerojudge.tw/ShowProblem?problemid=a693)

### Python 程式碼

執行時間最久約為 1.2 s，使用記憶體最多約為 11.7 MB，通過測試。
```python=
import sys

for line in sys.stdin:
    n, m = map(int, line.split())
    psum = [0] + list(map(int, input().split()))
    for i in range(1, n+1): psum[i] += psum[i-1]
    for _ in range(m):
        le, ri = map(int, input().split())
        print(psum[ri] - psum[le-1])
```

### C++ 程式碼

執行時間最久約為 0.6 s，使用記憶體最多約為 552 kB，通過測試。
```cpp=
#include <iostream>
using namespace std;

int main() {
    int n, m;
    while(cin >> n >> m) {
        int psum[n+1] = {0};
        for(int i=1; i<=n; i++) {
            cin >> psum[i];
            psum[i] += psum[i-1];
        }
        for(int i=0; i<m; i++) {
            int le, ri; cin >> le >> ri;
            cout << psum[ri] - psum[le-1] << "\n";
        }
    }
    return 0;
}
```


---

###### tags:`演算法`、`APCS`、`Python`、`C++`