ZeroJudge 解題筆記：j537. 工廠派遣 (Factory)

作者：王一哲
日期：2025年4月17日



ZeroJudge 題目連結：j537. 工廠派遣 (Factory)

解題想法

這題將每間工廠的産值 a、需要的人數 p，綁在一起放入陣列，依照 v 由大到小排序會比較方便。

Python 程式碼

使用時間約為 21 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # n 間工廠
    # 讀取每間工廠的産值 a、需要的人數 p，組成 tuple、放入 list，依照 v 由大到小排序
    ap = sorted([tuple(map(int, input().split())) for _ in range(n)], reverse=True)
    h = int(input())  # 總人數
    cnt = 0  # 有分配到人的工廠數量
    idx = 0  # 從 ap 讀取資料的索引值
    while idx < n and h > 0:  # 如果 idx 還沒有出界而且還有人，繼續執行
        cnt += 1; h -= ap[idx][1]; idx += 1  # cnt 加 1，h 減去此工廠的人數，idx 加 1
    print(cnt)

ZeroJudge 解題筆記：j536. 不穩定的礦石 (Ore)

作者：王一哲
日期：2025年4月16日



ZeroJudge 題目連結：j536. 不穩定的礦石 (Ore)

解題想法

分成兩次檢查吸收能量的狀況比較好寫。

Python 程式碼

使用時間約為 19 ms，記憶體約為 3.4 MB，通過測試。

import sys

for line in sys.stdin:
    n, a = map(int, line.split())  # n 個礦石，吸收力 a
    stone = list(map(int, input().split()))  # 礦石原來的能量
    p = stone.index(max(stone))  # 最多能量的礦石位置
    isum = sum(stone)  # 總能量
    cnt, imax = 0, stone[p]  # 已吸收的數量，吸收後的能量
    le = p - 1  # 向左吸收的位置
    # 向左吸收，最多吸收到位置 0 或是 p-a//2 為止，cnt 一定小於 a
    while le >= 0 and le >= p-a//2:
        cnt += 1; imax += stone[le]; le -= 1
    ri = p + 1  # 向右吸收的位置
    # 向右吸收，最多吸收到位置 n-1 或是 p+a//2 為止，cnt 一定小於 a
    while ri < n and ri <= p+a//2:
        cnt += 1; imax += stone[ri]; ri += 1
    # 第二次向左吸收，最多吸收到 cnt 等於 a 或是位置 0 
    while cnt < a and le >= 0:
        cnt += 1; imax += stone[le]; le -= 1
    # 第二次向右吸收，最多吸收到 cnt 等於 a 或是位置 n-1
    while cnt < a and ri < n:
        cnt += 1; imax += stone[ri]; ri += 1
    print(imax, isum-imax)  # 印出答案

ZeroJudge 解題筆記：j354. 積木對接 (Blocks)

作者：王一哲
日期：2025年4月15日



ZeroJudge 題目連結：j354. 積木對接 (Blocks)

解題想法

這題將判斷兩個積木是否有解的函式另外寫會比較方便。

Python 程式碼

使用時間約為 94 ms，記憶體約為 3.4 MB，通過測試。

import sys

def solve(bot, top):  # 輸入兩個積木測試是否有解
    n, m = len(bot), len(top)
    if m > n:  # 特例，上方的積木較長，無解
        print("NO"); return
    d = n - m  # 長度差
    for i in range(d+1):  # 短積木的左側位置可能是 0 ~ d
        if all([t&b == 0 for t, b in zip(top, bot[i:i+m])]):
            print("YES"); return
    print("NO"); return

for line in sys.stdin:
    n = int(line)  # 長積木的卡榫數量
    bot = []  # 下方的長積木每格的高度，0 代表低，1 代表高
    h = 0  # 高度，長積木由 0 開始
    for b in map(int, input().split()):  # 依序設定長積木每格的高度
        for _ in range(b): bot.append(h)  # 放入 b 個 h
        h = 1 - h  # 0 變 1 或 1 變 0
    m = int(input())  # 短積木的卡榫數量
    top = []  # 上方的短積木每格的高度，0 代表低，1 代表高
    h = 1  # 高度，短積木由 1 開始
    for t in map(int, input().split()):  # 依序設定短積木每格的高度
        for _ in range(t): top.append(h)  # 放入 t 個 h
        h = 1 - h  # 0 變 1 或 1 變 0
    solve(bot, top)

ZeroJudge 解題筆記：j352. 開心農場 (Farm)

作者：王一哲
日期：2025年4月14日



ZeroJudge 題目連結：j352. 開心農場 (Farm)

解題想法

依序讀取資料並判斷是否能開花即可。

Python 程式碼

使用時間約為 18 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # 週數
    rain = list(map(int, input().split()))  # 雨量
    sun = list(map(int, input().split()))  # 日照
    R, S = map(int, input().split())  # 所需總雨量、日照
    tr, ts, state = 0, 0, False  # 累積的雨量、日照、是否開花
    for i, (r, s) in enumerate(zip(rain, sun), start=1):
        tr += r; ts += s  # 更新累積的雨量、日照
        if tr >= R and ts >= S:  # 達到開花條件，印出 i+1，中止迴圈
            print(i+1); state = True; break
    if not state: print(-1)  # 不能開花，印出 -1

ZeroJudge 解題筆記：j180. 戰備存糧 (Food)

作者：王一哲
日期：2025年4月13日



ZeroJudge 題目連結：j180. 戰備存糧 (Food)

解題想法

這題如果按照題目的敘述，先將每個倉庫的存糧減 1，再將後方倉庫的存糧往前塞，這樣會跑很慢，一定無法通過測試。既然題目要將存糧盡量往前塞，那就乾脆計算存糧的數量，如果能用更少的倉庫裝下存糧，那就減一個倉庫。

Python 程式碼

使用時間約為 0.2 s，記憶體約為 3.3 MB，通過測試。

while True:
    line = input().strip()
    if line == "-1": break
    n, e = map(int, line.split())
    tot = n*e  # 存糧總量
    day = 0  # 天數
    while tot > 0:  # 還有存糧
        day += 1  # 天數加 1
        tot -= n  # 存糧減 n
        while tot <= (n-1)*e:  # 如果剩下的存糧可以用 (n-1) 個倉庫裝下
            n -= 1  # 減 1 個倉庫
    print(day)

ZeroJudge 解題筆記：j179. 資料分類 (Classification)

作者：王一哲
日期：2025年4月12日



ZeroJudge 題目連結：j179. 資料分類 (Classification)

解題想法

注意：n 的位數在運算時不一定會遞減。

Python 程式碼

利用 int 將字串轉成整數，刪除前面的 0，再用 str 轉回字串。使用時間約為 19 ms，記憶體約為 3.3 MB，通過測試。

import sys

for n in sys.stdin:
    n = n.strip()
    while len(n) > 1:  # 如果 n 長度大於 1 繼續執行
        if len(n) == 4:  # 4 位數
            le, ri = n[:2], n[2:]  # 左、右半邊
            if int(le) >= 10:  # 轉成 int，如果大於等於 10 才要相乘
                le = str(int(le[0])*int(le[1]))  # 兩位轉成 int 相乘再轉回 str
            if int(ri) >= 10:  # 轉成 int，如果大於等於 10 才要相乘
                ri = str(int(ri[0])*int(ri[1]))  # 兩位轉成 int 相乘再轉回 str
            else: ri = str(int(ri))  # 去掉前面的 0
            n = str(int(le + ri))  # 先將 le + ri 轉成 int 再轉回 str，去掉前面的 0
        elif len(n) == 3:  # 3 位數
            le, ri = n[:2], n[1:]  # 左、右半邊
            le = str(int(le[0])*int(le[1]))  # 兩位轉成 int 相乘再轉回 str
            ri = str(int(ri[0])*int(ri[1]))  # 兩位轉成 int 相乘再轉回 str
            n = str(int(le + ri))  # 先將 le + ri 轉成 int 再轉回 str，去掉前面的 0
        elif len(n) == 2:  # 2 位數
            n = str(int(n[0])*int(n[1]))  # 兩位轉成 int 相乘再轉回 str
    print(n)

ZeroJudge 解題筆記：i378. 垂直對稱 (Symmetry)

作者：王一哲
日期：2025年4月11日



ZeroJudge 題目連結：i378. 垂直對稱 (Symmetry)

解題想法

相同的 x 座標上如果有奇數個點，則 y 座標正中央的點必須在水平對稱線上，而且只能有 1 個值。接著再檢查一次，相同的 x 座標上所有的點 y 座標和，必須等於水平對稱線的 y 座標乘以點的數量。

Python 程式碼

使用時間約為 32 ms，記憶體約為 3.4 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # n 個點
    ps = dict()  # x 座標: [y1, y2, ...]
    for _ in range(n):  # 讀取 n 個點
        x, y = map(int, input().split())
        if x not in ps: ps[x] = [y]
        else: ps[x].append(y)
    cand = 10000  # 水平對稱線可能的 y 座標，預設為超出題目範圍的值
    found = True  # 是否有解
    for _, ys in ps.items():  # 找相同的 x 座標中所有點的 y 座標
        ys.sort()  # 要排序
        if len(ys)%2 == 1:  # 如果有奇數個點的項目
            if cand == 10000: cand = ys[len(ys)//2]  # 如果 cand 是預設值，更新
            elif cand != ys[len(ys)//2]:  # 不相同
                found = False; break  # 無解
    if found:  # 如果只有一個 cand
        for _, ys in ps.items():  # 找相同的 x 座標中所有點的 y 座標
            if cand*len(ys) != sum(ys):  # 如果不相等，cand 不在這些點的正中央
                found = False; break  # 無解
    print("success" if found else "failure")

ZeroJudge 解題筆記：i377. 單字找找看 (Word)

作者：王一哲
日期：2025年4月10日



ZeroJudge 題目連結：i377. 單字找找看 (Word)

解題想法

這題寫起來很長，因為要找 8 個方向，依照題目對於答案的要求，搜尋的方向依序是左上、正上、右上、正左、正右、左下、正下、右下。

Python 程式碼

使用時間約為 22 ms，記憶體約為 3.5 MB，通過測試。

import sys

def solve(g, t):  # 輸入字串方格 g，找目標字串 t
    m, n = len(g) -1, len(g[0]) -1  # 列數減 1，每列長度減 1
    tl = len(t)  # t 的長度
    for r in range(m):  # 依序掃過每列
        for c in range(n):  # 依序掃過每欄
            found = True  # 是否找到答案，先找左上方
            for i in range(tl):
                if t[i] != grid[r-i][c-i]:  # 只要字元不相等就可以中止迴圈
                    found = False; break
            if found:  # 如果找到答案，印出起點、終點，記得加 1
                print(f"{r+1:d} {c+1:d}\n{r-tl+2:d} {c-tl+2:d}")
                return  # 中止函式
            found = True  # 是否找到答案，找正上方
            for i in range(tl):
                if t[i] != grid[r-i][c]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r-tl+2:d} {c+1:d}")
                return
            found = True  # 是否找到答案，找右上方
            for i in range(tl):
                if t[i] != grid[r-i][c+i]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r-tl+2:d} {c+tl:d}")
                return
            found = True  # 是否找到答案，找正左方
            for i in range(tl):
                if t[i] != grid[r][c-i]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r+1:d} {c-tl+2:d}")
                return
            found = True  # 是否找到答案，找正右方
            for i in range(tl):
                if t[i] != grid[r][c+i]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r+1:d} {c+tl:d}")
                return
            found = True  # 是否找到答案，找左下方
            for i in range(tl):
                if t[i] != grid[r+i][c-i]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r+tl:d} {c-tl+2:d}")
                return
            found = True  # 是否找到答案，找正下方
            for i in range(tl):
                if t[i] != grid[r+i][c]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r+tl:d} {c+1:d}")
                return
            found = True  # 是否找到答案，找右下方
            for i in range(tl):
                if t[i] != grid[r+i][c+i]:
                    found = False; break
            if found:
                print(f"{r+1:d} {c+1:d}\n{r+tl:d} {c+tl:d}")
                return
    print("NO"); return

for line in sys.stdin:
    m, n = map(int, line.split())  # 表格 m*n
    grid = [input().strip().lower()+"0" for _ in range(m)]  # 加 0 作為哨兵
    grid.append("0"*(n+1))
    solve(grid, input().strip().lower())

ZeroJudge 解題筆記：i376. 尋寶 (Treasure)

作者：王一哲
日期：2025年4月9日



ZeroJudge 題目連結：i376. 尋寶 (Treasure)

解題想法

我是先掃過每一列找出最高處，將這些位置的座標加入一個集合 cand 之中；再掃過每一欄，找每欄的最低點，如果此處的座標在 cand 之中，表示已經找到答案。

Python 程式碼

使用時間約為 27 ms，記憶體約為 3.7 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # 地圖 n*n
    grid = [list(map(int, input().split())) for _ in range(n)]  # 地圖資料
    cand = []  # 可能的地點
    for r in range(n):  # 先找每列最高處放入 cand，可能有多個最高處
        imax = max(grid[r])  # 第 r 列的最大值
        for c in range(n):  # 依序掃過每欄
            if grid[r][c] == imax:  # 如果此格等於 imax
                cand.append((r, c))  # (r, c) 加入 cand
    found = False  # 是否找到答案
    for c in range(n):  # 依序找每欄的最低處在第幾列
        imin = min([grid[i][c] for i in range(n)])  # 第 c 欄的最小值
        for r in range(n):  # 依序掃過每列
            if grid[r][c] == imin and (r, c) in cand:  # 如果此格等於 imin 而且在 cand 之中
                found = True  # 找到答案
                print(r, c)  # 印出 (r, c)
                break  # 中止迴圈
        if found: break  # 如果已經找到答案，中止迴圈    
    if not found: print("NO")  # 如果沒有找到答案印出 NO

ZeroJudge 解題筆記：i164. 比對卡片(進階版)

作者：王一哲
日期：2025年4月8日



ZeroJudge 題目連結：i164. 比對卡片(進階版)

解題想法

題目的敘述是：對老師的每張卡片，孩童需找到自己的卡片中和老師卡片數字相同且位置差距最小的卡片。看起來應該是孩童依照自己手上的卡片，依序找每張卡片的數字是否有在老師手上的卡片之中，如果有則要找距離最近的卡片並記錄位置差；但如果以題目中範例的圖示來看則是反過來，老師依照自己手上的卡片，依序找每張卡片的數字是否有在孩童手上的卡片之中，如果有則要找距離最近的卡片並記錄位置差。 這題的基礎版為〈i070. 比對卡片 (Match)〉，測資小很多，用基本的寫法就能通過，但是這題不行。要從左向右、從右向左各掃過一次，記錄 a[i] 前一次出現的位置，如果 a[i] 已經出現過就更新距離。

Python 程式碼

使用時間約為 0.4 s，記憶體約為 35.8 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # 牌的數量
    a = list(map(int, input().split()))  # 老師的牌
    b = list(map(int, input().split()))  # 孩童的牌
    pre = [-1]*1000000  # 每張牌前一次出現的位置，-1 代表還沒有出現過，題目牌面編號最大值為 100000
    ans = [n]*n  # 答案，預設為過大的值 n，因為位置差為 0 ~ n-1
    for i in range(n):  # 依序檢查每張牌
        pre[b[i]] = i  # b[i] 的數字前一次出現為位為 i
        if pre[a[i]] != -1:  # 如果 a[i] 的數字之前已經出現過
            ans[i] = min(ans[i], abs(i - pre[a[i]]))  # 更新位置差
    for i in range(n-1, -1, -1):  # 反過來檢查每張牌
        pre[b[i]] = i  # b[i] 的數字前一次出現為位為 i
        if pre[a[i]] != -1:  # 如果 a[i] 的數字之前已經出現過
            ans[i] = min(ans[i], abs(i - pre[a[i]]))  # 更新位置差
    ans = list(map(lambda x : -1 if x == n else x, ans))  # ans 之中的 n 取代為 -1
    print(*ans)

ZeroJudge 解題筆記：i071. 風景 (Landscape)

作者：王一哲
日期：2025年4月7日



ZeroJudge 題目連結：i071. 風景 (Landscape)

解題想法

從起點開始向左、向右線性搜尋各一次即可。

Python 程式碼

使用時間約為 19 ms，記憶體約為 3.4 MB，通過測試。

import sys

for line in sys.stdin:
    n, m = map(int, line.split())  # n 棟建築，人在第 m 棟，編號從 1 開始
    hs = list(map(int, input().split()))  # 所有建築物的高度
    tot = 0  # 能看到的建築物數量
    m -= 1  # 建築物編號改成從 0 開始
    pre = hs[m]  # 前一棟最高建築物的高度，預設為自己所在的建築物高度
    for i in range(m, 0, -1):  # 從 m 開始向左找
        if hs[i-1] > pre:  # 如果左邊的建築物高度大於 pre
            tot += 1  # tot 加 1
            pre = hs[i-1]  # 更新 pre
    pre = hs[m]  # 重設 pre
    for i in range(m, n-1):  # 從 m 開始向右找
        if hs[i+1] > pre:  # 如果右邊的建築物高度大於 pre
            tot += 1  # tot 加 1
            pre = hs[i+1]  # 更新 pre
    print(tot)  # 印出答案

ZeroJudge 解題筆記：i070. 比對卡片 (Match)

作者：王一哲
日期：2025年4月6日



ZeroJudge 題目連結：i070. 比對卡片 (Match)

解題想法

題目的敘述是：對老師的每張卡片，孩童需找到自己的卡片中和老師卡片數字相同且位置差距最小的卡片。看起來應該是孩童依照自己手上的卡片，依序找每張卡片的數字是否有在老師手上的卡片之中，如果有則要找距離最近的卡片並記錄位置差；但如果以題目中範例的圖示來看則是反過來，老師依照自己手上的卡片，依序找每張卡片的數字是否有在孩童手上的卡片之中，如果有則要找距離最近的卡片並記錄位置差。

另外有一題進階版〈i164. 比對卡片(進階版)〉，測資大很多。

Python 程式碼

寫法1，用串列切片及 index 找索引值。使用時間約為 21 ms，記憶體約為 3.5 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # 牌的數量
    a = list(map(int, input().split()))  # 老師的牌
    b = list(map(int, input().split()))  # 孩童的牌
    for i in range(n):  # 依序檢查每張牌
        t = a[i]  # 目標
        if t not in b:  # 如果 t 不在 b 之中，印出 -1
            print(-1, end="\n" if i == n-1 else " ")
        elif i == 0:  # 編號 0，只要向右找，索引值等於位置差
            if t not in b: print(-1, end=" ")  # 如果 t 不在 b 之中，印出 -1
            else: print(b.index(t), end=" ")
        elif i == n-1:  # 編號 n-1，只要向左找
            if t not in b: print(-1)  # 如果 t 不在 b 之中，印出 -1
            else: print(b[::-1].index(t))  # 先將 b 反過來再找 t
        else:  # 編號在中間，向右、向左各找一次，取較小的值
            left = b[:i+1][::-1]  # 取 b[0] ~ b[i+1]，再反向
            right = b[i:]  # 取 b[i] ~ b[n-1]
            p, q = n, n  # 儲存位置差的變數，先預設為 n
            if t in right: p = right.index(t)  # 向右找
            if t in left: q = left.index(t)  # 向左找
            print(min(p, q), end=" ")  # 印出小的那個

ZeroJudge 解題筆記：i069. 岩石觀察 (Stones)

作者：王一哲
日期：2025年4月5日



ZeroJudge 題目連結：i069. 岩石觀察 (Stones)

解題想法

因為 Python 會一次讀取整行的資料，存成串列後再找最大值、最小值。C++ 一次讀取一筆資料，可以在讀取所有盒子的資料時一邊找最大值、最小值。

Python 程式碼

使用時間約為 19 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # n 個盒子
    box = list(map(int, input().split()))  # 原來的數量
    avg = sum(box)//n  # 平均數量
    pmax = box.index(max(box))  # 數量最多的盒子編號
    pmin = box.index(min(box))  # 數量最少的盒子編號
    d = box[pmax] - avg  # 移動的數量
    box[pmax] -= d  # 減少 d
    box[pmin] += d  # 增加 d
    print(*box)  # 印出答案

ZeroJudge 解題筆記：h660. 躲避球 (DodgeBall)

作者：王一哲
日期：2025年4月4日



ZeroJudge 題目連結：h660. 躲避球 (DodgeBall)

解題想法

按照題目敘述計算位置即可，不需要複雜的寫法。

Python 程式碼

使用時間約為 41 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    x, r, v = map(int, line.split())  # 阿茂的位置、接球的左右延伸長度、可接球的球速上限
    for _ in range(int(input())):  # 執行 n 次
        p, s = map(int, input().split())  # 球的落點、速度
        if x-r <= p <= x+r:  # 球在可以接到的範圍內
            if s <= v: x = p  # 球速夠慢，可以接球，移動到 p
            else:  # 球速太快，不能接球
                if p >= x: x -= 15  # 球在右邊或朝人過去，向左移 15
                else: x += 15  # 球在左邊，向右移 15
    print(x)  # 印出最後的位置

ZeroJudge 解題筆記：h659. 計程車 (Taxi)

作者：王一哲
日期：2025年4月3日



ZeroJudge 題目連結：h659. 計程車 (Taxi)

解題想法

按照題目敘述的標準計算費用即可，不需要複雜的寫法。

Python 程式碼

使用時間約為 19 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    # 行駛總公里數、車輛延滯時間 (min)、上車及下車的時刻 (hr)
    k, w, s, e = map(int, line.split())
    fee = 0  # 費用
    # 計算行駛總公里數産生的費用
    if k <= 2: fee += 20  # 2 km 以內 20 元
    else: fee += 20 + (k-2)*5  # 超過 2 km 加錢 5 元/km
    # 計算車輛延滯時間産生的費用
    fee += w//2*5  # 每滿 2 min 加 5 元
    # 計算夜間加成産生的費用
    if s <= 18 and e >= 19: fee += 185  # 橫跨 18 ~ 19 時，加 185 元
    if s <= 19 and e >= 20: fee += 195  # 橫跨 19 ~ 20 時，加 195 元
    if s <= 20 and e >= 21: fee += 205  # 橫跨 20 ~ 21 時，加 205 元
    if s <= 21 and e >= 22: fee += 215  # 橫跨 21 ~ 22 時，加 215 元
    if s <= 22 and e >= 23: fee += 225  # 橫跨 22 ~ 23 時，加 225 元
    print(fee)  # 印出答案

ZeroJudge 解題筆記：h658. 捕魚 (Fishing)

作者：王一哲
日期：2025年4月2日



ZeroJudge 題目連結：h658. 捕魚 (Fishing)

解題想法

用距離平方判斷是否在範圍內即可，不需要開根號。

Python 程式碼

使用時間約為 19 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    x, y = map(int, line.split())  # 漁夫的座標
    n = int(input())  # n 筆資料
    ax, ay, d = 0, 0, float('inf')  # 最接近的魚群座標、距離的平方
    for _ in range(n):  # 執行 n 次
        xi, yi = map(int, input().split())  # 魚群座標
        di = (x - xi)**2 + (y - yi)**2  # 距離的平方
        if di < d:  # 如果距離較近，更新 ax, ay, d
            ax, ay, d = xi, yi, di
    print(ax, ay)

ZeroJudge 解題筆記：h035. 夜市 (Night Market)

作者：王一哲
日期：2025年4月1日



ZeroJudge 題目連結：h035. 夜市 (Night Market)

解題想法

注意題目中的這句「但一塊板子只會採計一次得分」，不能重複計分。測資應該只有單筆輸入。

Python 程式碼

使用時間約為 20 ms，記憶體約為 3.3 MB，通過測試。

import sys

for line in sys.stdin:
    n = int(line)  # 投球 n 次
    down = [-1]*10  # 各編號的格子被打落的時刻，-1 代表沒有被打落
    hit = [False]*10  # 各編號的格子是否被打落過
    cnt, score, perfect = 0, 0, False  # 目前打落的板子數量，總分，是否全清
    for i, x in enumerate(list(map(int, input().split())), start=1):  # 依序讀取投球命中的格子
        for j in range(1, 10):  # 檢查每塊板子是否能升起
            if down[j] != -1 and i == down[j] + 12:  # 如果第 j 塊板子已被打落而且 i 等於第 j 塊板子被打落的時刻加 12
                down[j] = -1; cnt -= 1  # 升起第 j 塊板子，cnt 減 1
        if x != -1 and down[x] == -1:  # 如果 x 不等於 -1 而且 x 號板子目前沒有被打落
            cnt += 1; down[x] = i  # cnt 加 1，設定 x 被打落的時刻為 i
            if not hit[x]:  # 如果 x 號板子沒有被打落過
                score += x; hit[x] = True  # 分數加 x，x 號板子被打落過
        if cnt == 9:  # 如果 cnt 等於 9，全清，中止迴圈
            perfect = True; break
    print("perfect" if perfect else score)