---
# System prepended metadata

title: 計算機韌體實驗

---

# 計算機韌體實驗

### c039
先找輸入i, j的最大值，接者執行 i~j 次尋找每一個介於 i~j 的 cycle length。
```cpp=
#include<iostream>
#include<algorithm>
using namespace std;

int main() {
    int i, j, n = 0;
    while (cin >> i >> j) {
        int m = min(i, j);
        int M = max(i, j);
        int cycle = 0;
        for (int k = m; k <= M; k++) {
            int n = k;
            int t = 0;
            while (1) {
                t++;
                if (n == 1) break;
                if (n % 2) n = 3 * n + 1;
                else n = n / 2;
            }
            cycle = max(cycle, t);
        }
        cout << i << " " << j << " " << cycle << endl;
    }
}
```

### c007
使用 `getline(cin , s)` 來一行一行讀取
接著使用 `for(auto c : s)` 以 char 的型態從頭讀取 s(字串)，前面有 **auto** 代表可以直接修改 s(字串) 裡面的值。
利用 ? 條件判斷式 `(flag ? "flag 為 true 執行這裡" : "flag 為 flase 執行這裡")`。
```cpp=
#include<iostream>
#include<string>
using namespace std;
int main() {
    string s;
    bool flag = true;
    while(getline(cin , s)){
        for(auto c : s){
            if(c == '"'){
                cout << (flag ? "``" : "''");
                flag = !flag;
            } else cout << c;
        }
        cout << "\n";
    }
}
```

### c054
`string s` 為鍵盤上從左到右的字母數字，透過讀取一筆一筆資料`cin.get(c)`，再判斷該 `c` 的的字母位於s[i] 的哪一個位置，如果有找到的話則往左位移1個單位。
```cpp=
#include<iostream>
using namespace std;

int main() {
	string s;
	char c;
	int i;
	s = "`1234567890-=QWERTYUIOP[]\\ASDFGHJKL;'ZXCVBNM,./";
	while (cin.get(c)) {
		for (i = 0; i < s.length() && c != s[i]; i++);

		if (i < s.length()) {
			cout << s[i - 1];
		}
		else cout << c;
	}
}
```


### c543
迴文 -> `ABCDEDCBA`
鏡像 -> 從 `mt` 對照該字如果說reverse結果都一樣則該為鏡像

```cpp=
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
#define ALL(x) x.begin(), x.end()

string nt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
string mt = "A   3  HIL JM O   2TUVWXY51SE Z  8 ";
bool isP(string s);
bool isM(string s);
int main() {
	string s;
	while (cin >> s) {
		bool p = isP(s);
		bool m = isM(s);
		cout << s << " -- is ";
		if (p && m) cout << "a mirrored palindrome.";
		else if (p) cout << "a regular palindrome.";
		else if (m) cout << "a mirrored string.";
		else		cout << "not a palindrome.";
		cout << "\n\n";
	}
}

bool isP(string s) {
	string rs = s;
	reverse(ALL(rs));
	return rs == s;
}

bool isM(string s) {
	string rs = s;
	reverse(ALL(rs));
	for (int i = 0; i < rs.size(); i++) {
		int pos = nt.find(rs[i]);
		rs[i] = mt[pos];
	}
	return rs == s;
}
```


### d132
首先要先判斷如果輸入為 n 個 0 的話代表整個輸入結束，接著從 1~9 查看答案和輸入分別有幾個的值是一樣的，舉例來說 答案 `1 2 3 4`、輸入 `0 5 3 2`，我們可以知道 `2 3` 在答案裡有出現，所以 B 就 = 2，接著我們要減去完全正確的選項則 `B = B-A`。
```cpp=
#include<bits/stdc++.h>
using namespace std;
int main(){
    int n, game = 0;
    while(cin >> n && n != 0){
        vector<int> s(n), g(n);
        printf("Game %d:\n", ++game);
        for(int i = 0; i<n; i++) cin >> s[i];
        while(1){
            int A = 0, B = 0, z = 0;
            for(int i = 0; i<n; i++){
                cin >> g[i];
                if(s[i] == g[i]) A++;
                if(g[i] == 0)    z++;
            }
            if(n == z) break;
            for(int i = 1; i<=9; i++){
                int sc = 0, gc = 0;
                for(int j = 0; j<n; j++){
                    if(i == s[j]) sc++; 
                    if(i == g[j]) gc++; 
                }
                B += min(sc, gc);       // B = 1, 
            }
            B -= A;
            printf("\t(%d,%d)\n", A, B);
        }
    }
}
```

### e558
```cpp=
#include<bits/stdc++.h>
using namespace std;

int t[100001]= {0};

int main(){
    // 建立查詢表
    for(int n = 1; n <= 100001; n++){
        int y = n, x = n;
        while(x > 0){
            y = y + x % 10;
            x = x / 10; 
        }
        if(y > 100001) continue;
        if(t[y] == 0) t[y] = n;
    }
    // 開始解題
    int T, m;
    cin >> T;
    while(T--){
        cin >> m;
        cout << t[m] << "\n";
    }
}
```

### b123
先使矩形變為 0 1 1 1 -> 0 1 2 3

0 0 1 1 0      0 0 1 2 0
0 1 1 1 1  ->  0 1 2 3 4
0 1 1 1 1      0 1 2 3 4 
0 0 1 0 0      0 0 1 0 0


```cpp=
#include<bits/stdc++.h>
using namespace std;
int main(){
    int M, N;
    while(cin >> M >> N){
        int arr[201][201];
        for(int i = 0; i<M; i++){
            for(int j = 0; j<N; j++){
                cin >> arr[i][j];
                // 使矩形變為 0 1 1 1 -> 0 1 2 3
                if(arr[i][j] && j>0) arr[i][j] = arr[i][j-1] + 1;
            }
        }
        // 儲存最大矩形
        int A = 0;
        for(int i = 0; i<M; i++){ // 長
            for(int j = 0; j<N; j++){ // 寬
                int w = 201; // 題目最高的寬為200，超過200則為此題的最大值
                for(int h = 0; h<=i && arr[i-h][j]; h++){ // i = 2 , j = 4
                    w = min(w, arr[i-h][j]); // 4
                    A = max(A, w*(h+1)); // 
                }
            }
        }
        cout << A << "\n";
    }
    
}
```


### j121
```cpp=
#include<bits/stdc++.h>
using namespace std; 
#define ALL(x) x.begin(), x.end()

int main(){
    string s1, s2;
    while(cin >> s1 >> s2){
        vector<int> v1(26, 0), v2(26, 0);

        for(auto c : s1) v1[c - 'A']++; // JWPUDJSTVP
                                       // 10,23,16,21,4,10,19,20,22,16
                                       // v1[10] = 1, v1[23] = 1 ...
        for(auto c : s2) v2[c - 'A']++; // VICTORIOUS
                                       // 22,9,3,20,15,18,9,15,21,19
                                       // v2[22] = 1, v2[9] = 1 ...
        sort(ALL(v1));
        sort(ALL(v2));
        cout << (v1 == v2 ? "YES" : "NO") << "\n";
    }
}
```

### e541
首先要先讀取大理石並排序，接著利用 lower_bound 直接升冪排列找要搜尋的數字
```cpp=
#include<bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(), x.end()
int main(){
    int Case = 0;
    int N, Q;
    while(cin >> N >> Q && N != 0){
        printf("CASE# %d:\n", ++Case);
        // 讀取大理石並且排序
        vector<int> v(N);
        for(int i = 0; i<N;i++) cin >> v[i];
        sort(ALL(v));
        // 回答 Q 的問題
        while(Q--){
            int f;
            cin >> f;
            // lower_bound 找出 vector 中大於等於 f 的位置
            // lower_bound 輸出為指標，減去 v.begin() 的位置轉為數值
            int p = lower_bound(ALL(v), f) - v.begin();
            if(p < N && v[p] == f) printf("%d found at %d\n", f, p+1);
            else printf("%d not found\n", f);
        }
    }
}
```

### c073
- move 2 onto 1 : 將 1 以上的資料歸還給原本的值(ex: 1: 1 4 7 將 1 4 8 歸還到原本的位置) 再將 2 丟到 1 -> (1 : 1 2)

```cpp=
#include<bits/stdc++.h>
using namespace std;

int n; // 木塊數量
vector<int> v[25];

void find_block(int b, int &p, int &h); // 找木塊位置
void clear_above(int p, int h);         // 指定木塊的位置
void pile_over(int p1, int h, int p2);  // 移動木塊
void show();

int main(){
    string s1, s2;
    int a, b, pa, pb, ha, hb;
    while(cin >> n){
        // 木塊位置初始化
        for(int i = 0; i<n; i++){
            v[i].clear();
            v[i].push_back(i);
        }
        // 執行搬運命令
        while(cin >> s1 && s1 != "quit"){
            cin >> a >> s2 >> b;
            find_block(a, pa, ha);
            find_block(b, pb, hb);  
            if(pa != pb){
                if(s1 == "move") clear_above(pa, ha);
                if(s2 == "onto") clear_above(pb, hb);
                pile_over(pa, ha, pb);
            }
        }
        show(); // 顯示結果
    }
    return 0;
}

// 找木塊位置
void find_block(int b, int &p, int &h){
    for(p = 0; p<n; p++){
        for(h = 0; h<v[p].size(); h++){
            if(v[p][h] == b) return;
        }
    }
}

void clear_above(int p, int h){
    for(int i = v[p].size()-1; i>h; i--){
        int b = v[p][i];
        v[b].push_back(b); // 木塊歸位
        v[p].pop_back();
    }
}

// 移動含木塊及其以上所有木塊
void pile_over(int p1, int h, int p2){
    v[p2].insert(v[p2].end(), v[p1].begin() + h, v[p1].end());
    v[p1].erase(v[p1].begin() + h, v[p1].end());
    return;
}

//  顯示所有木塊
void show(){
    for(int i = 0; i<n; i++){
        cout << i << ":";
        for(int j = 0; j<v[i].size(); j++){
            cout << " " << v[i][j];
        }
        cout << "\n";
    }
}
```


### e155
        1 2 3 4 5 6 7
        3 4 5 6 7 2 丟掉 1
        5 6 7 2 4   丟掉 3
        7 2 4 6     丟掉 5
        4 6 2       丟掉 7
        2 6         丟掉 4
        6           丟掉 2

```cpp=
#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;
    while(cin >> n && n){
        queue<int> q;
        for(int i = 1; i<=n; i++) q.push(i);
        bool first = true;
        cout << "Discarded cards: ";
        while(q.size() > 1){
            // 丟卡
            if(first) first = false;
            else cout << ", ";
            cout << q.front(); q.pop();
            // 把下一張卡放到最後
            q.push(q.front()); q.pop();
        }
        cout << "\n";
        cout << "Remaining card: " << q.front() << "\n";
    }
}

```

### f166 
    input:
    5 3 1 2
    0 2 4 3 1
    
S = {0,2,4,3,1}
起始點為 s[0]= 0 ，首先先判斷向左(會出界)，再來判斷向右(走到s[2])，接著傳送至 s[s[2]] = s[4] 的位置，因為不會連續傳送所以在 s[4] = 1 的位置選擇向左或向右，向右會出界，所以向左(走到s[3] = 3的位置)，故可知 P = 3(終點等於3) 計算花費步數該題結束。
```cpp=
#include<bits/stdc++.h>
using namespace std;

int S[1000000]; // 最大可站立次數
int dis[1000000]; // 顯示第 x 步 站立的格子

int main(){
    // n:場地格數; P:目的地;  L & R: 往左/右移動的格數
    int n, P, L, R;
    // s: 角色當前所在格子編號; sL & sR 角色往左/右移動後的格子編號
    int s, sL, sR;
    // q: 紀錄未走過格子的佇列變數;
    queue<int> q;
    // 輸入 n P L R 以及每個格子傳送到的格子編號
    cin >> n >> P >> L >> R;
    for(int i = 0; i<n; i++) cin >> S[i];
    q.push(0);
    while(1){
        // 結束迴圈條件1 : 無法到達終點 P
        if(q.empty()){
            cout << -1;
            break;
        }
        // 結束迴圈條件2 : 到達終點 P
        s = q.front(); q.pop(); // 取得當下位置
        if(s == P){
            cout << dis[s];
            break;
        }
        // 往左
        sL = s - L;
        if(sL >= 0){
            sL = S[sL]; // 處理傳送
            // 傳送後的位置 是否出界 且 該格子是否還沒到達過
            if(0 <= sL && sL < n && dis[sL] == 0){
                dis[sL] = dis[s] + 1;
                q.push(sL);
            }
        }
        // 往右
        sR = s + R;
        if(sR <= n){
            sR = S[sR]; // 處理傳送
            // 傳送後的位置 是否出界 且 該格子是否還沒到達過
            if(0 <= sR && sR < n && dis[sR] == 0){
                dis[sR] = dis[s] + 1;
                q.push(sR);
            }
        }
    }


}
```

### b838
```cpp=
#include<bits/stdc++.h>
using namespace std;
int main(){
    int t;
    cin >> t;
    while(t--){
        // 讀取括號 & 準備前置變數
        string s;
        cin >> s;
        stack<char> up; // 紀錄上括號出現的次數
        bool vaild = true; // 檢驗括號組是否正確
        int ans = 0; // 有效括號組的數量
        // 處理括號問題
        for(auto c : s){
            if(c == '(') up.push('(');
            else { 
                // 檢查上括號up 變數是否還有上括號
                if(!up.empty() && up.top() == '('){
                    ans++;
                    up.pop();
                } // ) 太多的情況
                else { // up 變數用完的情況，代表下括號太多
                    vaild = false;
                    break;
                }
            }
        } 
        if(!up.empty()) vaild = false;
        cout << (vaild ? ans : 0) << "\n";
    }
    
}
```

### h028
    input: 
    6 140
    10 30 50 70 100 125
    30 15 55 10 55 25
    
    output:
    4
    30
    
解題思路: 先將林場左右兩端放置無限高的"假樹"，判斷樹往左往右砍的情況，判斷完之後回到 `stack s` 沒有被砍的樹是否可以被往左往右砍 `s.top().first + s.top().second` 未砍倒的樹的座標加上樹高。
```cpp=
#include<iostream>
#include<algorithm>
#include<climits>
#include<stack>
using namespace std;

// 最大樹的數量 first 存樹的座標, second 存樹的高度
pair<int, int> T[100002];
// 樹坐大只有100000，左右邊界各加1
int main(){
    int N, L;
    int total = 0, height = 0; // total 砍倒樹的數量, 砍倒樹最高的高度
    stack<pair<int, int>> s; // 紀錄最左側砍倒的樹木
    cin >> N >> L;
    // 繪製林場
    T[0].first = 0; // 最左邊的邊界
    T[0].second = INT_MAX; // int 的最大值
    for(int i = 1; i<=N; i++) cin >> T[i].first; // 讀樹的座標
    for(int i = 1; i<=N; i++) cin >> T[i].second; // 讀樹的高度
    T[N+1].first = L;

    s.push(T[0]); // 
    for(int i = 1; i<=N; i++){
        // 檢查樹木往左砍的狀況、往右砍的情況
        if(T[i].first-T[i].second >= s.top().first || T[i].first+T[i].second <= T[i+1].first){
            total++;
            height = max(height, T[i].second);
            // 檢查左側未砍倒樹木是否可以砍倒
            while(s.top().first + s.top().second <= T[i+1].first){
                total++;
                height = max(height, s.top().second);
                s.pop();
            }
        }
        else {
            s.push(T[i]); // 加上未能砍倒的樹木
        }
    }
    cout << total << "\n" << height;
}
```

### d217
運用容器 `<set>` 裡面的函式 `aa.count(x)` 來判斷是否前面以猜過相同的字元
解題步驟: 輸入 -> for遍歷答案的每個字元 -> if判斷是否猜過此字元 -> 判斷有無猜到題目字元 -> 是否達成結束條件(勝利或敗北)
```cpp=
#include<iostream>
#include<string>
#include<set>
#define ALL(x) x.begin(), x.end()

using namespace std;
int main(){
    int round;
    while(cin >> round && round != -1){
        // 讀題目與猜測和是這前置變數
        string q, a;
        int lc = 7; // 失敗條件
        cin >> q >> a;
        // 前處理
        printf("Round %d\n", round);
        set<char> uc(ALL(q)); // 刪除題目重複的英文字元
        set<char> aa;         // 儲存以猜過的字元
        for(int i = 0; i<a.size(); i++){
            // 確認玩家猜測字元是否已經猜過了
            if(aa.count(a[i])) continue; // 猜過: 跳過本次迴圈
            aa.insert(a[i]);             // 未猜過: 加入猜過自原變數

            // 判斷有無猜到題目字元
            if(uc.count(a[i])) uc.erase(a[i]);
            else lc--;

            // 是否達成結束條件(勝利或敗北)
            if(uc.empty() || !lc) break;
        }
        if(uc.empty()) cout << "You win.\n";
        else if(lc == 0) cout << "You lose.\n";
        else cout << "You chickened out.\n";
    }

    return 0;
}
```

### f698
    1 2 3 * +
當遇到 `*` 的時候 3x2，接著遇到 `+` 的時候 6 + 1，答案為7。
```cpp=
#include<iostream>
#include<string>
#include<stack>
using namespace std;

int main(){
    string ops = "+-*/"; // 運算符號
    stack<int> num;
    string s;
    while(cin >> s){ // 1 2 3 * +
        int op = ops.find(s); // 從 ops 找 s 字串
        if(op == -1) // 讀取值為數字
            num.push(stoi(s)); // string 轉成int儲存
        else {
            int n2 = num.top(); num.pop(); 
            int n1 = num.top(); num.pop();
            switch (op)
            {
            case 0:
                num.push(n1 + n2); break;
            case 1:
                num.push(n1 - n2); break;
            case 2:
                num.push(n1 * n2); break;
            default:
                num.push(n1 / n2);
            }
        }
    }
    cout << num.top();

    return 0;
}
```

### d244 
```cpp=
#include<iostream>
#include<map>
using namespace std;
int main(){
    // 前置宣告
    // st.first: 石頭編號; st.second: 對應編號個數
    map<int, int> st;
    int n;
    // 9 8 6 9 8 2 3 5 2 1 6 8 1 5 1 2 3 3 5 9
    // 1 : 3
    // 2 : 3
    // 3 : 3
    // 4 : 3
    // 5 : 3
    // 6 : 2
    // 7 : 3
    // 8 : 3
    // 9 : 3
    while(cin >> n) st[n]++;
    // 找尋不足3顆石頭編號
    for(auto p : st){
        if(p.second % 3){
            cout << p.first;
            break;
        }
    }
    return 0;
}
```

### e564
團隊編號先將被刪除的團隊開始依序刪除
> 例如 101 102 103、201 202 203 團隊
> 若 ENQUEUE 101 、 ENQUEUE 201 則 會先將 `10 團隊` 裡面的所有值印出
> 故輸出為:  101 102 103 201 202 203 

> 利用 map 建表 team[x] 為團隊編號，當輸入 ENQUEUE 檢查該成員是否為團隊編號首位進入佇列的成員，如果是就要先放到**輸出佇列**(要先把輸出佇列裡面的資料印出)


```cpp=
#include<iostream>
#include<queue>
#include<map>
using namespace std;
int main(){
    // 前置宣告
    int t, n, x; // t: 團隊數量; n: 團隊成員數; x: 成員編號
    int t0;      // 處理當下成員的團隊數量
    int kase = 0; // 印出結果 Scenario # 的編號
    // 開始處理團體佇列
    while(cin >> t && t){
        // team.first 團隊成員; team.second 成員所屬團隊編號
        map<int, int> team;
        // 給予所有成員所屬的團隊編號
        for(int i = 0; i<t; i++){
            cin >> n;
            while(n--){
                cin >> x; 
                team[x] = i;  
            }
        }
        // ENQUEUE & DEQUEUE 處理
        queue<int> tqueue;      // 正在佇列中的團隊編號 
        queue<int> equeue[1000]; // 正在佇列中的成員
        printf("Scenario #%d\n", ++kase); // 印出 Scenario #
        string cmd; 
        while(cin >> cmd && cmd != "STOP"){
            if(cmd == "ENQUEUE"){
                cin >> x;
                t0 = team[x]; // 取得成員 x 的所屬團隊編號
                if(equeue[t0].empty()) // 檢查該成員是否為團隊編號首位進入佇列的成員
                    tqueue.push(t0); // 團隊編號加入佇列
                equeue[t0].push(x); // 成員加入佇列
            }
            else { // cmd == "DEQUEUE"
                t0 = tqueue.front(); // 取得離開成員所屬的團隊編號
                cout << equeue[t0].front() << "\n"; // 印出要離開佇列的成員
                equeue[t0].pop(); // 將成員刪除
                if(equeue[t0].empty()){ // 如果該團隊都被輸出出來後，則該團隊離開 輸出佇列
                    tqueue.pop();
                }
            }
        }
        cout << "\n";
    }
}
```

### e548 I Can Guess the Data Structure!
```cpp=
#include<iostream>
#include<stack>
#include<queue>
using namespace std;
int main() {
    //讀取命令數
    int n;
    while (cin >> n) {
        //準備前置變數
        //ans[0]: 堆疊; ans[1]: 佇列; ans[2]: 優先佇列
        bool ans[] = { true, true, true };
        stack<int> s;
        queue<int> q;
        priority_queue<int> pq;
        //開始檢查資料結構的型態
        while (n--) {
            int cmd, x;
            cin >> cmd >> x;
            if (cmd == 1) {
                s.push(x);
                q.push(x);
                pq.push(x);
            }
            else {    //cmd == 2
                if (ans[0]) {    //堆疊結構檢查
                    if (!s.empty() && x == s.top()) s.pop();
                    else   ans[0] = false;
                }
                if (ans[1]) {    //佇列結構檢查
                    if (!q.empty() && x == q.front()) q.pop();
                    else   ans[1] = false;
                }
                if (ans[2]) {    //優先佇列檢查
                    if (!pq.empty() && x == pq.top()) pq.pop();
                    else   ans[2] = false;
                }
            }
        }
        //根據 ans 變數輸出結果
        if (ans[0] && !ans[1] && !ans[2])    cout << "stack";
        else if (!ans[0] && ans[1] && !ans[2])    cout << "queue";
        else if (!ans[0] && !ans[1] && ans[2])    cout << "priority queue";
        else if (!ans[0] && !ans[1] && !ans[2])    cout << "impossible";
        else                                    cout << "not sure";
        cout << "\n";
    }
}
```

### d221
    input:
    3
    1 2 3
    4
    1 2 3 4
    0
使用 prioritty_queue 的降冪排列改成升冪排列這樣的話放進去的資料會從最小的資料為 `pq.top()` 若從最小的資料開始算，則 cost 會是最小
```cpp=
#include<iostream>
#include<queue>
using namespace std;
int main(){
    int N;
    while(cin >> N && N){
        priority_queue<int, vector<int>, greater<int>> pq;
        for(int i = 0; i<N; i++){
            int x;
            cin >> x;
            pq.push(x);
        }
        long long sum, cost = 0;
        while(pq.size() != 1){
            sum = pq.top();       pq.pop();
            sum = sum + pq.top(); pq.pop();
            pq.push(sum);
            cost = cost + sum;
        }
        cout << cost << "\n";
    }
}
```

### h083
先把籤的字串分成[A][B][C], 且要使 [A] == [C], 則找出 [B] 字串，接著利用 binary_search 找[B]字串等於其他籤的字串。 
```cpp=
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
#define ALL(x) x.begin(), x.end()

int main(){
    // 製作籤筒並且將籤放入
    vector<string> v;
    int m;
    cin >> m;
    while(m--){
        string s;
        cin >> s;
        v.push_back(s); // 把籤放入籤筒
    }
    sort(ALL(v));
    int ans = 0; // 紀錄聖筊數量
    for(auto s : v){
        // 規則1: 把籤的字串分成[A][B][C], [A] == [C]
        int len = s.size(); // 當前籤的長度
        for(int i = 1; i<=len/2; i++){
            string sa = s.substr(0, i);          // [A] 字串 
            string sc = s.substr((len - i), i);  // [C] 字串
            if(sa == sc){
                string sb = s.substr(i, len - 2 * i); // [B] 字串
                // 規則2: [B]字串等於其他籤的字串
                if(binary_search(ALL(v), sb)){
                    ans++;
                }
            }
        }
    }
    // Sample :
    // 5
    // abyyyab
    // y
    // yy
    // yyy
    // yyyy
    // 組合一: abyyyab、yyy
    // 組合二: yyy、y
    // 組合三: yyyy、yy
    cout << ans;
    return 0;
}
```

### h640
```cpp=
#include<bits/stdc++.h>  
using namespace std;
int func(void);
int main(void){
    cout << func() << "\n";
    return 0;
}

int func(void){
    string token;
    int x, y, z; // 讀取 token
    cin >> token;
    // token == "f"
    if(token == "f"){
        x = func();
        return 2*x - 3;
    }
    // token == "g"
    if(token == "g"){
        x = func();
        y = func();
        return 2*x + y - 7;
    }
    if(token == "h"){
        x = func();
        y = func();
        z = func();
        return 3*x - 2*y + z;
    }
    return(stoi(token));
}
```

### f637
```cpp=
#include<iostream>
#include<string>
using namespace std;

int decode(int n); // 計算弧形的邊長
string s; // 讀取編碼的邊數
int p = -1; // 編碼的指標 index 

int main(){
    int n; // 圖像邊長
    cin >> s >> n; // 讀取編碼
    cout << decode(n) << "\n";
    return 0;
} // input: 2200101020110

int decode(int n){
    int black = 0; // 黑色像素的數量
    p++;
    if(s[p] == '0') // 0: 白色像素
        black = 0;
    else if(s[p] == '1') // 1: 黑色像素
        black += n*n;
    else { // 把影像分四等份
        for(int i=0; i<4; i++){
            black = black + decode(n/2);
        }
    }
    return black;
}
```

### k733
```cpp=
#include<iostream>
#include<string>
using namespace std;

long long loop(int& head, int& tail); // 遞迴副程式
string s0; // 磁軌的指令
int tape = 0; // 磁軌命令的指標

int main(){
    int h, t;       // h: head & t = tail
    long long walk = 0; // 紀錄總移動單位
    cin >> s0;
    walk = loop(h, t); // 移動距離單位
    walk += abs(h-10); // 扣除 Txx 最小值從10開始
    cout << walk;
    return 0;
} // input: T10L2T15T22L2T15ET23ET44

long long loop(int& head, int& tail){
    // 副程式的資料初始化
    // walk: 移動距離, subwalk: 迴圈內的移動距離 
    long long walk = 0, subwalk; 
    int num, h, t; // num: 讀取 x 數字的變數
    head  = tail = -1; // 給予 head & tail 初始值 -1

    while(1){
        // 結束點1: 整個磁軌命令執行完
        if(tape == s0.size()) return walk;
        // 命令整理
        if(s0[tape] == 'T'){ // 讀取命令 T
            num = stoi(s0.substr(tape+1, 2)); // 取得位置
            tape = tape + 3; // 移動磁軌命的指標 Txx 跳3格
            if(tail == -1) // 初次讀取命令的判定
                head = num;
            else 
                walk = walk + abs(num-tail);
            tail = num;
        }
        else if(s0[tape] == 'L'){ // 讀取命令 L
            num = stoi(s0.substr(tape+1, 1));
            tape = tape + 2;
            subwalk = loop(h, t); // 透過遞迴處理 Lx...E 的迴圈
            if(tail == -1)
                head = h; // 把位置給 head
            else 
                walk = walk + abs(h-tail);
            tail = t;
            walk = walk + subwalk * num + abs(h-t) * (num - 1);
        }
        else { // 讀取命令 E
            tape++; // 移動磁軌命令的指標
            return walk; // 結束點2: 回傳回圈內移動距離
        }
    } 
}
```