帷幕之後的虛幻城市

imgcity-data-v2

Tue, 28 Jul 2026 16:42:36 GMT

imgcity-data-v2

Source for 帷幕之後的虛幻城市 — a personal blog and notes site built with VitePress, deployed automatically to Netlify on push to main.

Develop

yarn install
yarn dev      # local server, hot reload
yarn build    # production build to .vitepress/dist
yarn preview  # serve the built site

Requires Node 22 LTS or newer (pinned in netlify.toml).

Content layout

Path	Purpose
`blog/YYYY/MM-DD-slug/index.md`	Dated blog post, colocated with its images / videos
`notes//.md`	Topic-organized evergreen notes
`draft/`	Work-in-progress posts. Excluded from the production build by `srcExclude` in `.vitepress/config.mts`.
`internal/`	Private pages. Same exclusion.
`about/`	About page(s)

Images sit alongside the markdown they appear in. Reference them by bare filename:

markdown

![](photo.webp)

Frontmatter conventions

Blog posts:

yaml

---
title: 文章標題
date: 2025-04-28        # YYYY-MM-DD only; no time / timezone
draft: false            # optional
tags:                   # optional
  - 旅行
---

Notes (lighter touch):

yaml

---
title: 頁面標題         # required; recent.data.mts filters titleless pages out of /recent/
status: incomplete      # optional convention for WIP pages
---

Maintenance scripts

scripts/normalize-blog-dates.mjs — rewrite blog date: lines to YYYY-MM-DD. scripts/backfill-note-frontmatter.mjs — prepend a minimal title: block to notes that lack one.

Both default to --dry-run. Pass --write to apply.

Lint

yarn lint

Runs markdownlint-cli2 via npx, so there's no local install step. Rules live in .markdownlint.jsonc; existing corpus (blog/, notes/, draft/, internal/) is currently in .markdownlintignore until the backlog of legacy formatting is triaged.

Deploy

Netlify watches main. CI on every PR / claude/** branch runs yarn lint + yarn build (see .github/workflows/build.yml). The Netlify build config (command, publish dir, NODE_VERSION) lives in netlify.toml.

關於我

Sat, 11 Jul 2026 08:18:55 GMT

關於我

努力為靈魂上色的香草。

我是香草，是個魔法師，住在蘑菇與鋼鐵的森林。

白天是後端工程師，工作上主要使用 C++、Golang，也會碰一些 Python；平時則喜歡把學到的技術、做過的 side project、以及一些零碎但有趣的想法記錄下來。

我喜歡電子書、塔羅與神祕學，也喜歡那些介於理性與幻想之間的事物。每天都會來一杯拿鐵。

這個網站可以怎麼看

如果你是第一次來到 Imgcity，可以從這幾個入口開始：

從這裡開始：我自己整理的精選文章入口。
旅行索引：旅行、散步與攝影相關文章。
Blog：按照時間排列的完整文章流。
Notes：技術筆記、知識整理與片段想法。
最近更新：最近改過或新增的頁面。

我在意的事情

技術與工程

我主要以後端開發為主，工作上常接觸 C++、Golang 與 Python。除了實務開發，也會把系統設計、資料庫、DevOps、Linux、程式片段與讀書筆記整理到 Notes 裡。

早期 Blog 裡也保留了不少程式競賽、OpenGL、OpenAL、C/C++ 與 side project 文章。那些內容有些已經是 archive，但它們記錄了我學習技術時留下的路徑。

旅行、攝影與生活紀錄

近年的 Blog 比較常出現旅行、散步、攝影與年度回顧。我喜歡把一段時間裡看見的風景、遇到的事情與當時的心情留下來，讓它們成為可以回頭瀏覽的城市街區。

幻想、整理與慢慢構築世界

我喜歡那些介於理性與幻想之間的東西：神祕學、塔羅、電子書、個人知識庫，以及可以慢慢整理空間的遊戲。比起追求立即完成，我更喜歡長期維護一個可以持續生長的地方。

玩的遊戲

偏好沙盒、經營或建造類型的遊戲，有時也會玩一些解謎類型的作品。

我喜歡那種可以慢慢整理空間、規劃動線，或按照自己的節奏構築世界的遊戲。
相較之下，需要長時間承受高壓挫敗感的類型就比較不合自己。

有一陣子也曾經很認真嘗試類魂遊戲，不過最後發現痛苦感明顯超過快樂感，所以就沒有繼續玩下去了。

以前很喜歡的恐怖解謎遊戲

大概在 2012 年前後，曾經被高中同學推坑，玩了不少這類型的小遊戲。像是《魔女之家》、《Ib 恐怖美術館》、《狂父》、《霧雨飄零之森》、《人魚沼》和《鑰匙小鎮》等，都是那時候很有印象的作品。

Minecraft

從高中開始玩 Minecraft，到現在還是很喜歡。
比起推進遊戲進度，我更喜歡慢慢蓋房子、整理空間。

也可以到我的筆記裡面可以看我以前蓋過的建築。

Gogh

做事時作為作業用 BGM。

在 Gogh 裡面的單間個人小房間，照相後送進 ChatGPT 請他做美化，並且把人物的形象換成自己。

可以在哪裡找到我？

有時會寫一些 Side Project，放在 Github。

也會把技術筆記、想法整理在這裡：帕秋莉的魔法技術筆記。

旅行索引

Sat, 11 Jul 2026 08:18:55 GMT

旅行索引

這裡整理 Blog 裡和旅行、散步、攝影有關的文章。完整時間流仍然可以回到 Blog；這頁則比較像是按地點與主題重新整理的入口。

海外旅行

英國

日本

台灣旅行與散步

攝影與出遊紀錄

從這裡開始

Sat, 11 Jul 2026 08:18:55 GMT

從這裡開始

如果你是第一次來到 Imgcity，可以先從這些文章認識我。這裡不是完整目錄，而是替第一次拜訪的人整理的入口：有年度回顧、旅行紀錄，也有一些早期技術與創作的痕跡。

年度回顧與時間線

這些文章比較像是每個階段的存檔，可以快速看見我在不同年份關注的事情。

旅行與攝影

近年的 Blog 有不少旅行與照片紀錄。如果想先看比較有畫面的內容，可以從這裡開始。

更多旅行文章可以看：旅行索引。

技術與創作 Archive

下面多半是比較早期的技術、競賽與 side project 文章。它們保留的是學習過程與當時的解題/實作痕跡；有些資訊可能已經過時，但仍是這座城市的地基。

也可以這樣逛

想看最新修改：/recent.html
想看完整 Blog 時間流：/blog
想看技術筆記與知識整理：/notes
想知道這個網站怎麼來的：/about/關於 imgcity

Advent of Code 2024 - 01

Tue, 07 Jul 2026 12:52:45 GMT

01

https://adventofcode.com/2024/day/1

Prob1

題目

輸入會給出兩個數組，要計算他們之間的距離，計算方式如下：

拿出兩邊最小的數，相減取絕對值。
拿出兩邊次小的數，相減儲絕對值。
...
把所有絕對值加總，得出距離

範例

Input

兩個數組：[1, 2, 3] 和 [3, 2, 4]

1   3
2   2
3   4

Output

| 1 - 2 | + | 2 - 3 | + | 3 - 4 | = 3

解法

兩個數組都排序後，直接把相同 index 的數字相減取絕對值加總。

python

import sys

xs = []
ys = []

for line in sys.stdin:
	x, y = map(int, line.split('   '))
	xs.append(x)
	ys.append(y)

xs.sort()
ys.sort()

ans = 0

for x, y in zip(xs, ys):
	ans += abs(x - y)

print(ans)

Prob2

題目

輸入會給出兩個數組，要計算他們之間的相似性，計算方式如下：

先看第一個數組第一個數字，然後這個數字在第二個數組的出現次數，計算數字x第二個數組的出現次數，
第二個數字也是如此，以此類推...
加總起來

Input

兩個數組：[1, 2, 3] 和 [3, 2, 2]

1   3
2   2
3   2

Output

1 \times 0 + 2 \times 2 + 3 \times 1 = 7

解法

把兩個數組都做成 count table: 數字對應到出現次數。然後計算數字x第一數組出現次數x第二數組出現次數，最後都加總起來。

python

import sys

xs = {}
ys = {}

for line in sys.stdin:
	x, y = map(int, line.split('   '))
	xs.setdefault(x, 0)
	xs[x] += 1
	ys.setdefault(y, 0)
	ys[y] += 1

ans = 0
for x, cnt in xs.items():
    ans += x*cnt*ys.get(x, 0)

print(ans)

Advent of Code 2024 - 02

Tue, 07 Jul 2026 12:52:45 GMT

02

https://adventofcode.com/2024/day/2

Prob1

題目

給堆數組，數有多少數組是「安全」的。安全的定義如下：

不是嚴格遞增，就是嚴格遞減
相鄰數字差距最多為 $3$

範例

Input

Output

1 2 3 4 5 符合安全條件。 5 4 3 1 符合安全條件。 1 5 6 7 中的 1 5 距離為 $4$ ，不安全。 1 3 1 非嚴格遞增或遞減，不安全。

解法

直接按照題目給的條件判斷。

python

import sys

import typing


def is_safe(xs: typing.List[int]):
    if len(xs) <= 1:
        return True

    if xs[0] == xs[1]:
        return False

    for i in range(1, len(xs)):
        diff = abs(xs[i-1] - xs[i])
        if diff == 0 or diff > 3:
            return False

        if (xs[0] - xs[1])*(xs[i-1] - xs[i]) < 0:
            return False

    return True


safe_cnt = 0

for line in sys.stdin:
    xs = list(map(int, line.split()))
    if is_safe(xs):
        safe_cnt += 1


print(safe_cnt)

Prob2

題目

安全條件一樣，但想確認拿掉一個數字可以讓數組變安全的數量。

Input

Output

1 2 3 4 5 符合安全條件。 5 4 3 1 符合安全條件。 1 5 6 7 中的 1 5 距離為 $4$ ，不安全。 1 3 1 非嚴格遞增或遞減，但移除第一個 1 或最後一個 1，就可以變安全。

解法

應該是有 $O (N)$ 的作法，但看題目實際給的數組長度沒有很長，直接暴力嘗試移除每個數字 $O (N^{2})$ 。

python

import sys

import typing


def is_safe(xs: typing.List[int]):
    if len(xs) <= 1:
        return True

    if xs[0] == xs[1]:
        return False

    for i in range(1, len(xs)):
        diff = abs(xs[i-1] - xs[i])
        if diff == 0 or diff > 3:
            return False

        if (xs[0] - xs[1])*(xs[i-1] - xs[i]) < 0:
            return False

    return True


safe_cnt = 0

for line in sys.stdin:
    xs = list(map(int, line.split()))

    ok = False
    for i in range(len(xs)):
        ys = xs[0:i] + xs[i+1:]
        if is_safe(ys):
            ok = True
            break

    if ok:
        safe_cnt += 1


print(safe_cnt)

Advent of Code 2024 - 03

Tue, 07 Jul 2026 12:52:45 GMT

03

https://adventofcode.com/2024/day/3

Prob1

題目

給一堆字串，找出所有 mul(a,b)，把所有 $a \times b$ 計算出來並且加總。

範例

Input

mul(1,2)mul(3,4]mul(5,6)

Output

1 \times 2 + 5 \times 6 = 32

解法

直接用 regex findall mul(\d+,\d+)。

python

import sys
import re

ans = 0
ok = True
for line in sys.stdin:
    for match in re.findall('mul\\(\\d+,\\d+\\)', line):
        if not ok:
            continue

        a, b = match.split(',')
        ia = int(a[4:])
        ib = int(b[:-1])
        ans += ia*ib

print(ans)

Prob2

題目

給一堆字串，找出所有 mul(a,b) 、 do()、don't()。

mul(a,b): 計算 $a \times b$ ``
don't(): 會把接下來的 mul 操作 disable。
do(): 會把接下來的 mul 操作 enable。

範例

Input

mul(1,2)don't()mul(3,4)do()mul(5,6)

Output

1 \times 2 + 5 \times 6 = 32

解法

一樣用 regex findall mul(\d+,\d+)|do|don't 😂

python

import sys
import re

ans = 0
ok = True
for line in sys.stdin:
    for match in re.findall('mul\\(\\d+,\\d+\\)|do\\(\\)|don\'t\\(\\)', line):
        if match == 'do()':
            ok = True
            continue

        if match == 'don\'t()':
            ok = False
            continue

        if not ok:
            continue

        a, b = match.split(',')
        ia = int(a[4:])
        ib = int(b[:-1])
        ans += ia*ib

print(ans)

Advent of Code 2024 - 04

Tue, 07 Jul 2026 12:52:45 GMT

04

https://adventofcode.com/2024/day/4

Prob1

題目

給一個字元方陣，找出橫的、直的、45度斜的 XMAS 的出現次數。

範例

Input

XMAS
MXXA
AXXM
SAMX

Output

解法

直接迭代每個點出發的 XMAS。時間複雜度 $O (N M)$

python

import sys

mat = []

for line in sys.stdin:
    mat.append(line.strip())


mi = len(mat)
mj = len(mat[0])

def get_idx(x, y):
    if x < 0 or x >= mi or y < 0 or y >= mj:
        return '.'
    return mat[x][y]


cnt = 0

for i in range(mi):
    for j in range(mj):
        if mat[i][j] != 'X':
            continue

        # XMAS
        dt = [(-1, 1), (-1, 0), (-1, -1), (0, 1),
              (0, -1), (1, 1), (1, 0), (1, -1)]
        for di, dj in dt:
            w = get_idx(i + di, j + dj) + \
                get_idx(i + 2*di, j + 2*dj) + \
                get_idx(i + 3*di, j + 3*dj)
            if w == "MAS":
                cnt += 1

print(cnt)

Prob2

題目

找出所有形成 X 形狀的 MAS。

M.S
.A.
M.S

M.M
.A.
S.S

S.M
.A.
S.M

S.S
.A.
M.M

解法

迭代所有 A 的點，時間複雜度 $O (N M)$

python

import sys

mat = []

for line in sys.stdin:
    mat.append(line.strip())

mi = len(mat)
mj = len(mat[0])

cnt = 0

for i in range(1, mi-1):
    for j in range(1, mj-1):
        if mat[i][j] != 'A':
            continue

        w = mat[i-1][j-1] + mat[i-1][j+1] + mat[i+1][j+1] + mat[i+1][j-1]
        if w in ['MMSS', 'MSSM', 'SSMM', 'SMMS']:
            cnt += 1

print(cnt)

Advent of Code 2024 - 05

Tue, 07 Jul 2026 12:52:45 GMT

05

https://adventofcode.com/2024/day/5

我懷疑我假解這題了，先等等。

Prob1

題目

給定一堆數字需要的前後順序和一堆數字序列，檢查數字序列是否符合前面條件。

python

import sys

rules = set()
tests = []

for line in sys.stdin:
    line = line.strip()
    if '|' in line:
        rules.add(line)
    elif ',' in line:
        tests.append(line.split(','))

ans = 0
for test in tests:
    ok = True
    
    for i in range(n):
        for j in range(i + 1, n):
            rule = test[i] + '|' + test[j]
            if rule not in rules:
                ok = False
                break
        if not ok:
            break
    if ok:
        ans += int(test[n // 2])

print(ans)

python

import sys

tests = []
rules = set()

for line in sys.stdin:
    line = line.strip()
    if '|' in line:
        rules.add(line)
    elif ',' in line:
        tests.append(line.split(','))

ans = 0
for test in tests:
    ok = True
    n = len(test)
    for i in range(n):
        for j in range(i + 1, n):
            rule = test[j] + '|' + test[i]
            if rule in rules:
                test[i], test[j] = test[j], test[i]
                ok = False

    if not ok:
        ans += int(test[n // 2])


print(ans)

Advent of Code 2024 - 06

Tue, 07 Jul 2026 12:52:45 GMT

06

https://adventofcode.com/2024/day/6

Prob1

題目

給一張地圖，裡面有主角和障礙物，主角一開始向上走，只要碰到障礙物，就會右轉，然後繼續向前走。問：主角在離開地圖前經過幾個不一樣的方？

範例

Input

..#..
....#
...#.
..^..

Output

把實際經過的地方打 x 就會得到：

..#..
xxxx#
..x#.
..x..

所以答案是 6

解法

直接模擬。

python

import sys

x_max = 0
y_max = 0

stone = set()

ch_dir = 0
ch_p = (0, 0)
dirs = [(0, -1), (1, 0), (0, 1), (-1, 0)]

for line in sys.stdin:
    line = line.strip()
    x_max = len(line)
    y_max += 1
    for x, c in enumerate(line):
        p = (x + 1, y_max)
        if c == '#':
            stone.add(p)
        elif c == '^':
            ch_p = p

vis = set()

vis.add(ch_p)

while True:
    dx, dy = dirs[ch_dir]
    cx, cy = ch_p

    nx = cx + dx
    ny = cy + dy

    if nx <= 0 or nx > x_max or ny <= 0 or ny > y_max:
        break

    if (nx, ny) in stone:
        ch_dir = (ch_dir + 1) % 4
        continue

    ch_p = (nx, ny)
    vis.add(ch_p)

print(len(vis))

Prob2

題目

給一張地圖，裡面有主角和障礙物，主角一開始向上走，只要碰到障礙物，就會右轉，然後繼續向前走。

在地圖上增加一個石頭，可能會讓主角陷入迴圈，問有多少個點符合這條件？(排除直接在主角位置上增加石頭。)

Input

..#..
....#
...#.
..^..

Output

把符合條件的地方打 x 就會得到：

..#..
.x..#
...#.
.....

所以答案是 1

解法

直接確認假如每個點追加一顆石頭的情況。

在檢查迴圈時，把『紀錄經過的點』變成『紀錄經過的點和當時方向』，這樣只要相同的『位置和方向』被重複經過，就可以判定有迴圈。

python

import sys

x_max = 0
y_max = 0

stone = set()

origin = (0, 0)
dirs = [(0, -1), (1, 0), (0, 1), (-1, 0)]

for line in sys.stdin:
    line = line.strip()
    x_max = len(line)
    y_max += 1
    for x, c in enumerate(line):
        p = (x + 1, y_max)
        if c == '#':
            stone.add(p)
        elif c == '^':
            origin = p

cnt = 0

for stone_x in range(1, x_max + 1):
    for stone_y in range(1, y_max + 1):
        new_stone = (stone_x, stone_y)
        if new_stone in stone:
            continue

        if new_stone == origin:
            continue

        ch_p = origin
        ch_dir = 0

        stone.add(new_stone)

        vis = set()
        vis.add((ch_p, ch_dir))
        loop = False
        while True:
            dx, dy = dirs[ch_dir]
            cx, cy = ch_p

            nx = cx + dx
            ny = cy + dy

            if nx <= 0 or nx > x_max or ny <= 0 or ny > y_max:
                break

            if (nx, ny) in stone:
                ch_dir = (ch_dir + 1) % 4
                continue

            ch_p = (nx, ny)
            if (ch_p, ch_dir) in vis:
                loop = True
                break
            vis.add((ch_p, ch_dir))

        if loop:
            print(new_stone)
            cnt += 1

        stone.remove(new_stone)

print(cnt)

Advent of Code 2024 - 07

Tue, 07 Jul 2026 12:52:45 GMT

07

https://adventofcode.com/2024/day/7

Prob1

題目

給一串數字 $x_{i}$ ，問有沒有辦法經過以下操作得到 $a$ 。

把 $x$ 的前面兩個數字拿出來相加，再放回 $x$ 前面
把 $x$ 的前面兩個數字拿出來相乘，再放回 $x$ 前面

輸入會給很多組數字和其對應的 $a$ ，把可行的 $a$ 都加起來作為輸出。

範例

Input

100: 10 10
191: 19 10
120: 10 2 10

Output

100 是可行的 $10 \times 10 = 100$
191 是不可行的
120 是可行的 $(10 + 2) \times 10 = 120$

解法

直接搜索無法剪枝，所以從尾巴逆著搜索，可以用結果是否不小於數字或整除數字來判斷。

python

import sys

from typing import List


def test(target: int, xs: List[int]) -> bool:
    if len(xs) == 1:
        return target == xs[0]

    if target < xs[0]:
        return False

    if xs[0] > 0 and target % xs[0] == 0:
        if test(target//xs[0], xs[1:]):
            return True

    return test(target - xs[0], xs[1:])


ans = 0

for line in sys.stdin:
    target, xs_str = line.strip().split(':')
    target = int(target)
    xs = list(map(int, xs_str.strip().split(' ')))
    xs.reverse()
    if test(target, xs):
        ans += target

print(ans)

Prob2

題目

給一串數字 $x_{i}$ ，問有沒有辦法經過以下操作得到 $a$ 。

把 $x$ 的前面兩個數字拿出來相加，再放回 $x$ 前面
把 $x$ 的前面兩個數字拿出來相乘，再放回 $x$ 前面
把 $x$ 的前面兩個數字拿出來用字串組合的方式加起來，再放回 $x$ 前面 ("1" + "2" = "12")

輸入會給很多組數字和其對應的 $a$ ，把可行的 $a$ 都加起來作為輸出。

範例

Input

100: 10 10
191: 19 10
1020: 10 2 10

Output

100 是可行的 $10 \times 10 = 100$
191 是不可行的
1020 是可行的 $(10 | 2) \times 10 = 120$

解法

一樣從尾巴逆著搜索，字串組合更好剪。

python

import sys

from typing import List


def test(target: int, xs: List[int]) -> bool:
    if len(xs) == 1:
        return target == xs[0]

    if target < xs[0]:
        return False

    if xs[0] > 0 and target % xs[0] == 0:
        if test(target//xs[0], xs[1:]):
            return True

    if target != xs[0] and str(target).endswith(str(xs[0])):
        new_target = int(str(target).removesuffix(str(xs[0])))
        if test(new_target, xs[1:]):
            return True

    return test(target - xs[0], xs[1:])


ans = 0

for line in sys.stdin:
    target, xs_str = line.strip().split(':')
    target = int(target)
    xs = list(map(int, xs_str.strip().split(' ')))
    xs.reverse()
    if test(target, xs):
        ans += target

print(ans)

Advent of Code 2024 - 08

Tue, 07 Jul 2026 12:52:45 GMT

08

https://adventofcode.com/2024/day/8

Prob1

題目

給定一個盤面，上面有些點有上不同的顏色。

對於任兩個相同顏色的點 $A B$ ，我們把符合下面條件的格子點 $X$ 標出來：

$X$ 在 $A B$ 外面（這是我加的，否則按照題目定義應該要產生 $4$ 個反節點，而不是 $2$ 個）
$X A B$ 在一直線上
$2 | \overset{―}{X A} | = | \overset{―}{X B} |$

計算這些點的數量，相同位置算同一個，產生在上色的點也算。

範例

Input

......
.A.a..
A...a.
......

Output

把產生的點標出來 x

..x...
.A.a..
A...a.
.....x

所以會產生 2 個

解法

對任兩同色點對計算 $2 A - B$ 。

python

import sys

from typing import List, Dict, Tuple, Set


pt_map: Dict[str, List[Tuple[int, int]]] = {}

y_max = 0
x_max = 1

for line in sys.stdin:
  line = line.strip()
  x_max = len(line)
  for x, c in enumerate(line):
    if c == '.':
      continue
    pt_map.setdefault(c, list()).append((x + 1, y_max + 1))
  y_max += 1


a_set: Set[Tuple[int, int]] = set()

for _, pts in pt_map.items():
  n = len(pts)
  for i in range(n):
    for j in range(n):
      if i == j:
        continue
      x1, y1 = pts[i]
      x2, y2 = pts[j]
    
      x3 = 2*x2 - x1
      y3 = 2*y2 - y1
      if x3 < 1 or x3 > x_max or y3 < 1 or y3 > y_max:
        continue

      a_set.add((x3, y3))
      print(x3, y3)

print(len(a_set))

Prob2

題目

給定一個盤面，上面有些點有上不同的顏色。

對於任兩個相同顏色的點 $A B$ ，把所有在同一線上的格子標出來。

總共多少格子點？

範例

Input

......
.A....
A...a.
.....a

Output

把產生的點標出來 x

..x...
.A.x..
A...a.
.....a

所以會產生 2 個

解法

枚舉同色點對，然後計算每個 row 是哪個點和 $A B$ 相交。

我當下沒考慮兩點都在同一 row ，但測資沒出現 🤣

python

import sys

from typing import List, Dict, Tuple, Set


pt_map: Dict[str, List[Tuple[int, int]]] = {}

y_max = 0
x_max = 1

for line in sys.stdin:
  line = line.strip()
  x_max = len(line)
  for x, c in enumerate(line):
    if c == '.':
      continue
    pt_map.setdefault(c, list()).append((x + 1, y_max + 1))
  y_max += 1


a_set: Set[Tuple[int, int]] = set()

for _, pts in pt_map.items():
  n = len(pts)
  for i in range(n):
    for j in range(n):
      if i == j:
        continue
      x1, y1 = pts[i]
      x2, y2 = pts[j]

      dx = x2 - x1
      dy = y2 - y1

      for x3 in range(1, 51):
        # y3 = dy*(x3 - x2)/dx + y2
        v = dy*(x3 - x2)
        if v % dx != 0:
          continue

        y3 = v//dx + y2

        if x3 < 1 or x3 > x_max or y3 < 1 or y3 > y_max:
          continue
    
        a_set.add((x3, y3))
        print(x3, y3)

print(len(a_set))

Advent of Code 2024 - 09

Tue, 07 Jul 2026 12:52:45 GMT

09

https://adventofcode.com/2024/day/9

Prob1

題目

在使用硬碟寫檔刪檔時，有時會讓硬碟連續空間中間出現空缺。簡單來說如下：

111xxxx333

111 和 333 是目前仍然活著的檔案，xxxx是之前使用，但是被刪掉的檔案，這樣會降低硬碟使用效率。（當然，一個字母可能代表的不只是一個 byte，可能是 1kb，這件事在這題不重要）

所以我們會需要定期做「磁碟重組」。現在考慮以下「磁碟重組」方式：不斷地把最後一個字母移動到當前第一個沒有使用的點，直到沒辦法這樣做。

例如：

11xxx2222xxxx3333xxx4444

會這樣：

0: 11xxx2222xxxx3333xxx4444
1: 114xx2222xxxx3333xxx444x
...
4: 1144422224xxx3333xxxxxxx
...
7: 11444222243333xxxxxxxxxx

輸入是個由數字組成的字串

例如： 133，這樣的意思是 1 格檔案， 3 格空格， 3 格檔案

1xxx222

最後輸出結果的 checksum: $\sum i x_{i}$

範例

Input

Output

輸入的硬碟是這樣 1xx22，重組後變成結果變成 122xx， checksum = $1 \times 0 + 2 \times 1 + 2 \times 2 = 5$

解法

two-pointers: 一個指標從前面跑，找到最小的空的點。一個從後面跑，找到有檔案的點就往前放。

時間複雜度: $O (N)$

python

import sys

line = sys.stdin.readline().strip()

arr = []
for idx, cnt_str in enumerate(line):
    cnt = int(cnt_str)
    if idx % 2 == 0:
        arr.extend([idx//2]*cnt)
    else:
        arr.extend([-1]*cnt)

print(arr)

lptr = 0
rptr = len(arr) - 1

while lptr < rptr:
    while lptr < rptr and arr[lptr] != -1:
        lptr += 1

    if lptr >= rptr:
        break

    while lptr < rptr and arr[rptr] == -1:
        rptr -= 1

    if lptr >= rptr:
        break

    arr[lptr] = arr[rptr]
    lptr += 1
    rptr -= 1

arr = arr[:rptr + 1]
print(arr)

checksum = 0
for idx, x in enumerate(arr):
    if x == -1:
        continue
    checksum += idx*x
print(checksum)

Prob2

上面的方式顯然增加了大量的檔案碎片，讓檔案系統變得更慢了！

所以我們這次只考慮不讓檔案碎片化的移動方法：

從後面的檔案往前決定
一樣讓檔案開始的 index 越小越好
沒有辦法移動就跳過

例如：

11xxx2222xxxx33xxxxx4444

移動 4 檔案

11xxx2222444433xxxxxxxxx

移動 3 檔案

1133x22224444xxxxxxxxxxx

輸出 checksum: $\sum i x_{i}$

範例

Input

Output

輸入表示：1xx22xxx3x444。結果變成 13x22444xxxxx。

checksum = $1 \times 0 + 3 \times 1 + 2 \times (3 + 4) + 4 \times (5 + 6 + 7) = 99$

解法

python

import sys

from typing import List, Tuple

line = sys.stdin.readline().strip()

files: List[Tuple[int, int]] = []

# (l, r)
holes: List[Tuple[int, int]] = []

ptr = 0
for idx, cnt_str in enumerate(line):
    cnt = int(cnt_str)
    if cnt == 0:
        continue
    if idx % 2 == 0:
        files.append((ptr, ptr + cnt))
    else:
        #if holes and holes[-1][1] == ptr:
        #    holes[-1][1] += cnt
        #else:
        holes.append((ptr, ptr + cnt))
    ptr += cnt

for fidx in range(len(files) - 1, -1, -1):
    fl, fr = files[fidx]
    flen = fr - fl
    for hidx, hole in enumerate(holes):
        l, r = hole
        if l > fl:
            continue
        if flen > r - l:
            continue
        holes[hidx] = (l + flen, r)
        files[fidx] = (l, l + flen)
        break

check_sum = 0
for fidx, file in enumerate(files):
    l, r = file
    check_sum += fidx*((r-1)*r - (l-1)*l)//2

print(check_sum)

Advent of Code 2024 - 10

Tue, 07 Jul 2026 12:52:45 GMT

10

https://adventofcode.com/2024/day/10

Prob1

題目

給一個0-9 的高度地圖，問有幾個 9 可以從 0 走到(路徑經過的高度必須剛好按照順序 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)。

範例

Input

0123456789
9876543210

Output

Code

python

import sys

from typing import Dict, List, Tuple, Set

mat = []

for line in sys.stdin:
    mat.append(list(map(int, line.strip())))

x_max = len(mat)
y_max = len(mat[0])


h_map: Dict[int, List[Tuple[int, int]]] = {}

for h in range(0, 10):
    h_map[h] = []

for i in range(x_max):
    for j in range(y_max):
        h_map[mat[i][j]].append((i, j))

tab: Dict[Tuple[int, int], Set[Tuple[int, int]]] = {}
for (x, y) in h_map[9]:
    tab[(x, y)] = {(x, y)}

for h in range(8, -1, -1):
    tab2: Dict[Tuple[int, int], int] = {}
    for (x, y) in h_map[h]:
        tab2[(x, y)] = tab.get((x + 1, y), set()) | \
                       tab.get((x - 1, y), set()) | \
                       tab.get((x, y + 1), set()) | \
                       tab.get((x, y - 1), set())
    tab = tab2

ans = 0
for pt, set9 in tab.items():
    ans += len(set9)

print(ans)

Prob2

題目

給一個 0-9 的高度地圖，問有多少條路徑(路徑必須剛好按照順序 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)。

Input

0123456789
9876543210

Output

解法

python

import sys

from typing import Dict, List, Tuple, Set

mat = []

for line in sys.stdin:
    mat.append(list(map(int, line.strip())))

x_max = len(mat)
y_max = len(mat[0])


h_map: Dict[int, List[Tuple[int, int]]] = {}

for h in range(0, 10):
    h_map[h] = []

for i in range(x_max):
    for j in range(y_max):
        h_map[mat[i][j]].append((i, j))

tab: Dict[Tuple[int, int], int] = {}
for (x, y) in h_map[9]:
    tab[(x, y)] = 1

for h in range(8, -1, -1):
    tab2: Dict[Tuple[int, int], int] = {}
    for (x, y) in h_map[h]:
        tab2[(x, y)] = tab.get((x + 1, y), 0) + \
                       tab.get((x - 1, y), 0) + \
                       tab.get((x, y + 1), 0) + \
                       tab.get((x, y - 1), 0)
    tab = tab2

ans = 0
for pt, cnt in tab.items():
    ans += cnt

print(ans)

Advent of Code 2024 - 11

Tue, 07 Jul 2026 12:52:45 GMT

11

https://adventofcode.com/2024/day/11

Prob

題目

給一條堆數字，每過一秒，每個數字都會根據下面規則產生變化 (使用優先符合條件的規則)：

0 → 1
假如位數是偶數，那從中間切一半分裂成兩個數字，例如：
1. 1234 → 12,34
2. 1201 → 12, 1
都不符合以上條件則就變成 2024 倍，例如： 3 → 6072

Prob1：算 25 秒之後有幾個數字
Prob2：算 75 秒之後有幾個數字

作法

直接用 map: 數字 → 個數模擬，25 秒和 75 秒都可以短時間內跑出來。

python

import sys

def add_stone(d: dict, stone: int, stone_cnt: int):
    d.setdefault(stone, 0)
    d[stone] += stone_cnt

n = int(sys.argv[1])
stones = {}

for s in list(map(int, sys.stdin.readline().strip().split(' '))):
    add_stone(stones, s, 1)

for i in range(n):
    new_stones = {}
    for s, cnt in stones.items():
        if s == 0:
            add_stone(new_stones, 1, cnt)
        elif len(str(s)) % 2 == 0:
            str_stone = str(s)
            half_len = len(str_stone)//2
            add_stone(new_stones, int(str_stone[:half_len]), cnt)
            add_stone(new_stones, int(str_stone[half_len:]), cnt)
        else:
            add_stone(new_stones, s*2024, cnt)
    stones = new_stones

ans = 0
for _, cnt in stones.items():
    ans += cnt

print(ans)

Advent of Code 2024 - 12

Tue, 07 Jul 2026 12:52:45 GMT

12

https://adventofcode.com/2024/day/12

Prob1

題目

給定一個上色地圖，計算所有聯通塊的週長x面積的和。

範例

Input

AAA
AAC
BBA

Output

AAA
AA.

面積=5 週長=9

面積=1 週長=4

BB

面積=2 週長=6

面積=1 週長=4

解法

先把連通塊上不同顏色，然後就可以迭代每個點：

這個顏色有這塊面積。
假如向某個方向是不同色的，就代表該連通塊有這個方向的邊。

python

import sys

from typing import Dict, List


def recolor(mat: List[str]) -> List[str]:
    row_max = len(mat)
    col_max = len(mat[0])

    ret = [['']*col_max for r in range(row_max)]

    def color(i, j, c, target):
        if i < 0 or j < 0 or i >= row_max or j >= col_max:
            return

        if ret[i][j]:
            return

        if mat[i][j] != target:
            return

        ret[i][j] = c
        color(i - 1, j, c, target)
        color(i + 1, j, c, target)
        color(i, j - 1, c, target)
        color(i, j + 1, c, target)

    idx = 0
    for r in range(row_max):
        for c in range(col_max):
            if ret[r][c]:
                continue
            color(r, c, str(idx), mat[r][c])
            idx += 1

    return ret


mat = []
for line in sys.stdin:
    mat.append(line.strip())

mat = recolor(mat)

area: Dict[str, int] = {}
row_max = len(mat)
col_max = len(mat[0])
for row in mat:
    for c in row:
        area.setdefault(c, 0)
        area[c] += 1


def get(r: int, c: int) -> str:
    if r < 0 or c < 0 or r >= row_max or c >= col_max:
        return '.'
    return mat[r][c]


mult: Dict[str, int] = {}
for i in range(row_max):
    for j in range(col_max):
        for (di, dj) in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            if get(i + di, j + dj) != mat[i][j]:
                mult.setdefault(mat[i][j], 0)
                mult[mat[i][j]] += 1

print(area, mult)

ans = 0
for c in area:
    print(c, area[c], mult[c])
    ans += area[c]*mult[c]

print(ans)

Prob2

題目

給定一個上色地圖，計算所有聯通塊的邊數x面積的和。

範例

Input

AAA
AAC
BBA

Output

AAA
AA.

面積=5 邊數=6

面積=1 邊數=4

BB

面積=2 週長=4

面積=1 週長=4

解法

先把連通塊上不同顏色，然後就可以迭代每個點：

這個顏色有這塊面積。
假如向某個方向是不同色的，就代表該連通塊有這個方向的邊。

python

import sys

from typing import Dict, List


def recolor(mat: List[str]) -> List[List[str]]:
    row_max = len(mat)
    col_max = len(mat[0])

    ret = [['']*col_max for r in range(row_max)]

    def color(i, j, c, target):
        if i < 0 or j < 0 or i >= row_max or j >= col_max:
            return

        if ret[i][j]:
            return

        if mat[i][j] != target:
            return

        ret[i][j] = c
        color(i - 1, j, c, target)
        color(i + 1, j, c, target)
        color(i, j - 1, c, target)
        color(i, j + 1, c, target)

    idx = 0
    for r in range(row_max):
        for c in range(col_max):
            if ret[r][c]:
                continue
            color(r, c, str(idx), mat[r][c])
            idx += 1

    return ret


def cal_seg(seg: List[int]) -> int:
    cnt = 1
    for i in range(len(seg) - 1):
        if seg[i] != seg[i+1] - 1:
            cnt += 1
    return cnt


def main():
    mat = []
    for line in sys.stdin:
        mat.append(line.strip())

    mat = recolor(mat)
    print(mat)

    def get(r: int, c: int) -> str:
        if r < 0 or c < 0 or r >= row_max or c >= col_max:
            return '.'
        return mat[r][c]

    area: Dict[str, int] = {}
    row_max = len(mat)
    col_max = len(mat[0])
    for row in mat:
        for c in row:
            area.setdefault(c, 0)
            area[c] += 1

    edge_table: Dict[str, Dict[str, List[int]]] = {}
    for i in range(row_max):
        for j in range(col_max):
            for dir, (di, dj) in enumerate([(-1, 0), (1, 0), (0, -1), (0, 1)]):
                if get(i + di, j + dj) == mat[i][j]:
                    continue

                if dir == 0 or dir == 1:
                    edge_name = f'{dir}_{i}'
                    edge_idx = j
                else:
                    edge_name = f'{dir}_{j}'
                    edge_idx = i

                edge_table.setdefault(mat[i][j], {}).setdefault(
                    edge_name, []).append(edge_idx)

    ans = 0
    for c in area:
        edge_cnt = 0
        print(edge_table[c])
        for edge_name, segs in edge_table[c].items():
            edge_cnt += cal_seg(segs)
        ans += area[c]*edge_cnt
        print(c, area[c], edge_cnt)

    print(ans)


if __name__ == '__main__':
    main()

Advent of Code 2024 - 13

Tue, 07 Jul 2026 12:52:45 GMT

13

https://adventofcode.com/2024/day/13

Prob

給定 $a_{1}, b_{1}, c_{1}, a_{2}, b_{2}, c_{2} \in N$

在這條件下，找 $3 x + y$ 的最小值

{\begin{cases} a_{1} x + b_{1} y = c_{1} \\ a_{2} x + b_{2} y = c_{2} \\ x, y \in N \end{cases}

解法

(假解)

解完聯立方程式時，理論上是要判斷 $Δ = 0$ 是可以去繼續確認其他事情的，但是看起來測試資料沒有這部分 😆

python

import sys

button_a_line = ''
button_b_line = ''
prize_line = ''

ans = 0
for line in sys.stdin:
    line = line.strip()
    if line.startswith('Button A'):
        button_a_line = line.removeprefix('Button A: ')
        continue
    elif line.startswith('Button B'):
        button_b_line = line.removeprefix('Button B: ')
        continue
    elif not line.startswith('Prize'):
        continue

    prize_line = line.removeprefix('Prize: ')

    a1, b1 = map(int, button_a_line.replace(
        'X+', '').replace('Y+', '').split(','))
    a2, b2 = map(int, button_b_line.replace(
        'X+', '').replace('Y+', '').split(','))
    x0, y0 = map(int, prize_line.replace(
        'X=', '').replace('Y=', '').split(','))
    a2, b1 = b1, a2

    x0 += 10000000000000
    y0 += 10000000000000

    '''
        a1x + b1y = x0
        a2x + b2y = y0
    '''
    print(a1, b1)
    print(a2, b2)

    det = a1*b2 - b1*a2
    if det == 0:
        continue

    x = x0*b2 - y0*b1
    if x % det != 0:
        continue
    x //= det

    y = - (x0*a2 - y0*a1)
    if y % det != 0:
        continue
    y //= det
    print(x, y)

    if x >= 0 and y >= 0:
        ans += 3*x + y

print(ans)

Advent of Code 2024 - 14

Tue, 07 Jul 2026 12:52:45 GMT

14

https://adventofcode.com/2024/day/14

Prob1

有螢幕上有一堆點，給定每個點的初始位置和速度，詢問在 100 秒後這些點落在四個象限的數量相乘是多少。

這些點從左邊出去後會從右邊進來，從下面出去後從上面進來。

做法

直接算...

python

import sys

second = int(sys.argv[1])

bots = []

w = 101
mx = (w-1)//2

h = 103
my = (h-1)//2

q = [0, 0, 0, 0]

for line in sys.stdin:
    print(line)
    p_str, v_str = line.strip().split(' ')
    px, py = map(int, p_str.removeprefix('p=').split(','))
    vx, vy = map(int, v_str.removeprefix('v=').split(','))

    px = (px + vx*second) % w
    py = (py + vy*second) % h
    print(px, py)
    if px > mx and py > my:
        q[0] += 1
    elif px < mx and py > my:
        q[1] += 1
    elif px < mx and py < my:
        q[2] += 1
    elif px > mx and py < my:
        q[3] += 1

print(q)
print(q[0]*q[1]*q[2]*q[3])

Prob2

接上題，什麼時候可以出現像是聖誕樹的樣子？

不知道怎麼做 😭

Advent of Code 2024 - 15

Tue, 07 Jul 2026 12:52:45 GMT

15

https://adventofcode.com/2024/day/15

Prob1

推箱子。

給定地圖和操作，問最後箱子的位置的座標總和。

做法

直接模擬。

Code

python

import sys

from typing import Tuple, Set

walls: Set[Tuple[int, int]] = set()
boxes: Set[Tuple[int, int]] = set()
op_list = ''
cur: Tuple[int, int] = (0, 0)

y = 0
for line in sys.stdin:
    line = line.strip()
    if line == '':
        continue
    if line.startswith('#'):
        for x, ch in enumerate(line):
            p = (x, y)
            if ch == '#':
                walls.add(p)
            elif ch == 'O':
                boxes.add(p)
            elif ch == '@':
                cur = p
        y += 1
    else:
        op_list += line

print(walls)
print(boxes)
print(op_list)

dir_tab = {
    '>': (1, 0),
    '<': (-1, 0),
    'v': (0, 1),
    '^': (0, -1),
}

for op in op_list:
    px, py = cur
    dx, dy = dir_tab[op]
    nx, ny = px + dx, py + dy

    np = (nx, ny)

    if np in walls:
        continue

    if np not in boxes:
        cur = np
        continue

    affect_box: Tuple[int, int] = np
    while True:
        nx, ny = nx + dx, ny + dy
        np = (nx, ny)
        if np in boxes:
            continue

        if np in walls:
            # ok, no move
            break

        # empty space, we can make a move!
        cur = affect_box
        boxes.remove(affect_box)
        boxes.add(np)
        break

ans = 0
for (bx, by) in boxes:
    ans += 100*by + bx

print(ans)

Prob2

題目

一樣是推箱子，但是箱子長度變2倍，寬度不變。

做法

推箱子由於有可能會像是樹狀般影響到其他箱子，需要 BFS 去計算被影響的箱子。

Code

python

import sys

from queue import Queue

from typing import Tuple, Set, List

walls: Set[Tuple[int, int]] = set()
boxes: Set[Tuple[int, int]] = set()
op_list = ''
cur: Tuple[int, int] = (0, 0)

y = 0
for line in sys.stdin:
    line = line.strip()
    if line == '':
        continue
    if line.startswith('#'):
        for x, ch in enumerate(line):
            if ch == '#':
                walls.add((2*x, y))
                walls.add((2*x + 1, y))
            elif ch == 'O':
                boxes.add((2*x, y))
            elif ch == '@':
                cur = (2*x, y)
        y += 1
    else:
        op_list += line

print(walls)
print(boxes)
print(op_list)

dir_tab = {
    '>': (1, 0),
    '<': (-1, 0),
    'v': (0, 1),
    '^': (0, -1),
}

for op in op_list:
    dx, dy = dir_tab[op]

    px, py = cur
    nx, ny = px + dx, py + dy
    np = (nx, ny)

    if np in walls:
        continue

    affect_boxes: Set[Tuple[int, int]] = set()
    visited_boxes: Set[Tuple[int, int]] = set()
    affect_queue = Queue()
    pushable = True

    if np in boxes:
        affect_boxes.add(np)
        affect_queue.put(np)

    n2p = (nx - 1, ny)
    if n2p in boxes:
        affect_boxes.add(n2p)
        affect_queue.put(n2p)

    while not affect_queue.empty():
        px, py = affect_queue.get()
        visited_boxes.add((px, py))

        n1p = px + dx, py + dy
        n2p = px + dx + 1, py + dy
        n3p = px + dx - 1, py + dy

        if n1p in walls or n2p in walls:
            pushable = False
            break

        if n1p in boxes and n1p not in visited_boxes:
            affect_boxes.add(n1p)
            affect_queue.put(n1p)

        if n2p in boxes and n2p not in visited_boxes:
            affect_boxes.add(n2p)
            affect_queue.put(n2p)

        if n3p in boxes and n3p not in visited_boxes:
            affect_boxes.add(n3p)
            affect_queue.put(n3p)

    if not pushable:
        # print('not pushable')
        continue

    new_boxes: List[Tuple[int, int]] = []
    for (bx, by) in affect_boxes:
        new_boxes.append((bx + dx, by + dy))

    print('affect', affect_boxes, '->', new_boxes)

    for box in affect_boxes:
        boxes.remove(box)

    for box in new_boxes:
        boxes.add(box)

    px, py = cur
    cur = (px + dx, py + dy)

    # print(boxes)

print(boxes)

ans = 0
for (bx, by) in boxes:
    ans += 100*by + bx

print(ans)

Advent of Code 2024 - 16

Tue, 07 Jul 2026 12:52:45 GMT

16

https://adventofcode.com/2024/day/16

Prob1

python

import queue
import sys

from typing import Tuple


mat = []
for line in sys.stdin:
    line = line.strip()
    mat.append(line)

x_max = len(mat[0])
y_max = len(mat)

start = (0, 0)
end = (0, 0)

for x in range(x_max):
    for y in range(y_max):
        if mat[y][x] == 'S':
            start = (x, y)
        elif mat[y][x] == 'E':
            end = (x, y)

dir_map = [(0, -1), (1, 0), (0, 1), (-1, 0)]

tab4 = [[[None]*x_max for y in range(y_max)] for d in range(4)]

que = queue.PriorityQueue()

def put_que(dis: int, pt: Tuple[int, int], dir):
    v = tab4[dir][pt[1]][pt[0]]
    if v and v <= dis:
        return

    que.put((dis, pt, dir))
    tab4[dir][pt[1]][pt[0]] = dis

put_que(0, start, 1)

while not que.empty():
    dis, pt, dir = que.get()
    if tab4[dir][pt[1]][pt[0]] < dis:
        continue

    print(dis, pt, dir)

    # rotate
    put_que(dis + 1000, pt, (dir + 1)%4)
    put_que(dis + 2000, pt, (dir + 2)%4)
    put_que(dis + 1000, pt, (dir + 3)%4)

    # forward
    dx, dy = dir_map[dir]
    nx, ny = pt[0] + dx, pt[1] + dy
    if mat[ny][nx] in ['.', 'E']:
        put_que(dis + 1, (nx, ny), dir)

ans = None
for d in range(3):
    v = tab4[0][end[1]][end[0]]
    if not v:
        continue
    if not ans or ans > v:
        ans = v

print(ans)

帷幕之後的虛幻城市

imgcity-data-v2

imgcity-data-v2

Develop

Content layout

Frontmatter conventions

Maintenance scripts

Lint

Deploy

關於我

關於我

這個網站可以怎麼看

我在意的事情

技術與工程

旅行、攝影與生活紀錄

幻想、整理與慢慢構築世界

玩的遊戲

以前很喜歡的恐怖解謎遊戲

Minecraft

Gogh

可以在哪裡找到我？

旅行索引

旅行索引

海外旅行

英國

日本

台灣旅行與散步

攝影與出遊紀錄

相關入口

從這裡開始

從這裡開始

年度回顧與時間線

旅行與攝影

技術與創作 Archive

也可以這樣逛

Advent of Code 2024 - 01

01

Prob1

題目

範例

Input

Output

解法

Prob2

題目

Input

Output

解法

Advent of Code 2024 - 02

02

Prob1

題目

範例

Input

Output

解法

Prob2

題目

Input

Output

解法

Advent of Code 2024 - 03

03

Prob1

題目

範例

Input

Output

解法

Prob2

題目

範例

Input

Output

解法

Advent of Code 2024 - 04

04

Prob1

題目

範例