// 演算法 / Algorithm:
// 由左到右掃描一次。用 sign(+1/-1) 記下一個數字正負，res 累積當前層總和。
// 遇到 '(' 把外層 res 與 sign 推入堆疊並重置；遇到 ')' 先結算待加數字，
// 再彈出折回外層。只有加減與括號，無需運算子優先級。
// Single left-to-right pass; stack saves the outer (res, sign) at '(' and
// restores/folds them at ')'. No precedence needed (only + - and parens).

#include <stdlib.h>   // 提供 malloc / free（手動配置堆疊記憶體）/ for malloc & free

int calculate(char* s) {
    int n = 0;                      // 算字串長度 / measure length of s
    while (s[n] != '\0') n++;       // 逐字元直到結尾 '\0' / scan until null terminator

    // 堆疊：最壞情況每個字元都是 '('，每次 push 兩個 int（res 與 sign）。
    // The stack: worst case every char is '(', each push stores 2 ints (res, sign).
    int* stack = (int*)malloc(sizeof(int) * (size_t)(2 * n + 2));
    int top = 0;                    // 堆疊頂端索引，指向下一個空位 / next free slot

    int res = 0;                    // 當前層累積結果 / running total of current level
    int sign = 1;                   // 下一個數字的正負，+1 或 -1 / sign of next number
    int num = 0;                    // 正在拼接的多位數字 / the multi-digit number being built

    for (int i = 0; i < n; i++) {   // 逐字元處理 / process each character
        char c = s[i];

        if (c >= '0' && c <= '9') {            // 是數字字元嗎 / is it a digit?
            num = num * 10 + (c - '0');        // 一位一位拼成整數，'c-0' 把字元轉成數值 / build number; (c-'0') char→int
        } else if (c == '+') {                 // 加號 / plus
            res += sign * num;                 // 先把前一個數字結算進 res / settle previous number
            num = 0;                           // 清空以拼下一個數字 / reset for next number
            sign = 1;                          // 下一個數字為正 / next number is positive
        } else if (c == '-') {                 // 減號或一元負號 / minus (binary or unary)
            res += sign * num;                 // 結算前一個數字 / settle previous number
            num = 0;                           // 重置 / reset
            sign = -1;                         // 下一個數字為負 / next number is negative
        } else if (c == '(') {                 // 左括號：進入新子運算式 / open: enter sub-expression
            stack[top++] = res;                // 保存外層累積 / save outer running total
            stack[top++] = sign;               // 保存括號整體的正負 / save sign in front of '('
            res = 0;                           // 在「白紙」上重新算 / fresh slate for inner
            sign = 1;                          // 內層第一個數字預設為正 / inner starts positive
        } else if (c == ')') {                 // 右括號：結束子運算式 / close: finish sub-expression
            res += sign * num;                 // 先結算括號內最後一個數字 / settle last inner number
            num = 0;                           // 重置 / reset
            int savedSign = stack[--top];      // 彈出括號整體正負（後進先出）/ pop the group's sign (LIFO)
            int savedRes  = stack[--top];      // 彈出外層累積 / pop outer total
            res = savedRes + savedSign * res;  // 把括號結果折回外層 / fold inner result back
        }
        // 空白字元落到這裡，什麼都不做、直接略過 / spaces fall through and are skipped
    }

    res += sign * num;   // 迴圈結束後結算最後一個未加入的數字 / settle the final pending number
    free(stack);         // 釋放手動配置的記憶體，避免洩漏 / free heap memory to avoid leak
    return res;          // 回傳答案 / return result
}