# 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++`
Sign in with Wallet
Connect another wallet