diff --git a/.markdownlint.json b/.markdownlint.json
index d3f5138f..8b73cc44 100644
--- a/.markdownlint.json
+++ b/.markdownlint.json
@@ -56,6 +56,8 @@
     "MD042": false,
     "MD046": { "style": "fenced" },
     "MD048": { "style": "backtick" },
+    "MD049": false,
+    "MD050": false,
     "MD058": false,
     "MD060": false
 }
diff --git a/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Python.md b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Python.md
new file mode 100644
index 00000000..b7bb8300
--- /dev/null
+++ b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Python.md	
@@ -0,0 +1,370 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python
+> 適用ルールセット: 共通5ルール + Py固有4ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# Pascal's Triangle（パスカルの三角形）— Python版
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「三角形の形に並んだ数値の表を、上から順番に1行ずつ積み上げて作る問題」** です。
+
+まず目で確認しましょう。
+
+```
+行0：   [1]
+行1：  [1, 1]
+行2： [1, 2, 1]
+行3：[1, 3, 3, 1]
+行4：[1, 4, 6, 4, 1]
+```
+
+ルールは2つだけです：
+
+- 各行の **両端は必ず `1`**
+- 内側の要素は **真上の左と右の数値を足した値**（例：行2の `2` = 行1の `1 + 1`）
+
+**Pythonで解く際のCPython特有の注意点**：この問題は新しいリストを行ごとに生成していく処理のため、メモリアロケーション（＝メモリを新たに確保すること）が頻繁に発生します。`numRows ≤ 30` という制約のため現実的には問題になりませんが、リスト内包表記（`[1] + [...] + [1]` のような書き方）はCPythonのバイトコードレベルで最適化されており、素朴な `for` ループより高速に動作します。
+
+---
+
+### 競技プログラミング視点
+
+- **制約分析**：`numRows ≤ 30` → 最大でも `30×31/2 = 465要素` しか生成しません。O(n²) で十分間に合います
+- **最速手法**：各行をリスト内包表記で一括生成する。C実装（＝C言語で書かれた高速な処理）の恩恵を受けやすい
+- **メモリ最小化**：直前の1行だけ参照すれば次の行を作れるため、全行を保持しながら結果を構築します
+
+### 業務開発視点
+
+- **型安全設計**：`list[list[int]]` を戻り値型として明示。`numRows: int` の入力検証で範囲外を早期に弾く
+- **エラーハンドリング**：制約 `1 ≤ numRows ≤ 30` の範囲外、または `int` 以外の型が渡されたときに分かりやすいエラーを投げる
+- **可読性**：各処理を `_build_row()` ヘルパーに分離し、メインロジックを短く保つ
+
+### Python特有分析
+
+- **データ構造選択**：行は `list[int]` が最適。両端操作はなく、インデックスアクセスが頻繁なため `deque`（＝前後から出し入れできる両端キュー）よりも `list` が向いています
+- **標準ライブラリ活用度**：今回は `itertools` や `collections` は不要。`list` と内包表記だけで完結します
+- **CPython最適化度**：リスト内包表記でC実装レベルの高速化を活かせます
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**：最も広く使われるPythonの実装。C言語で書かれており、組み込み関数の多くがC実装のため高速
+> - **リスト内包表記**：`[式 for 変数 in イテラブル]` という形でリストを1行で作る書き方。`for` ループより高速な理由は、CPythonが内包表記専用の最適化されたバイトコード命令（`LIST_APPEND`）を使うから
+> - **制約分析**：問題の入力サイズ上限から「どのくらいの計算量まで許容されるか」を逆算すること
+> - **メモリアロケーション**：プログラムが新しいデータを格納するためにメモリ領域を確保すること
+
+---
+
+## 2. 採用アルゴリズムと根拠
+
+> 💡 **初学者向け補足**
+> 同じ問題でも解き方は複数あります。それぞれの「速さ（時間計算量）」と「メモリの使いやすさ（空間計算量）」を比べて最適なものを選びます。
+
+| アプローチ                    | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用 | CPython最適化  | 備考                                                                   |
+| ----------------------------- | ---------- | ---------- | ---------------- | ------ | ------------------ | -------------- | ---------------------------------------------------------------------- |
+| **A. 逐次行構築（今回選択）** | O(n²)      | O(n²)      | 低               | ★★★    | list のみ          | 適（内包表記） | 直感的で最もシンプル                                                   |
+| B. 二項係数で直接計算         | O(n²)      | O(n²)      | 中               | ★★☆    | math.comb          | 適             | 大きな整数で精度は問題なし（Pythonは多倍長整数）。ただし実装がやや難解 |
+| C. 再帰（メモ化なし）         | 最悪で指数的／再帰定義で変化 | O(n²)      | 高               | ★☆☆    | なし               | 不適           | 同じ値を何度も再計算。`@lru_cache` 追加で改善できるが過剰              |
+
+**選択理由**：**方法A（逐次行構築）** を選びます。
+
+- **方法Bを選ばなかった理由**：`math.comb(n, k)` で計算は可能ですが、「前行を使って次行を作る」というパスカルの三角形の本質的なルールを直接コードで表現できる方法Aの方が可読性・保守性に優れています
+- **方法Cを選ばなかった理由**：再帰は呼び出しスタック（＝関数呼び出しを記録する領域）を消費し、計算量も非効率（再帰定義に依存し、指数的になることがある）で、この問題には適しません
+- **Python最適化戦略**：各行の内側をリスト内包表記で一括生成することで、CPythonの内包表記最適化の恩恵を受けます
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **`math.comb(n, k)`**：組み合わせの数 C(n,k) を計算するPython 3.8+ の標準関数。Pythonは多倍長整数（＝桁数の制限がない整数）を扱えるため精度の問題はない
+> - **呼び出しスタック**：関数が関数を呼び出すとき、どこから呼ばれたかを記録するメモリ領域。深い再帰はここを使い尽くして `RecursionError` を起こす
+
+---
+
+## 3. 実装パターン
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. 入力 `numRows` の型・範囲を検証する
+> 2. 結果格納用の2次元リストを用意する
+> 3. 1行目（`[1]`）を無条件で追加する
+> 4. 2行目以降：先頭と末尾を `1` に固定し、内側をリスト内包表記で計算する
+> 5. 完成した三角形を返す
+
+---
+
+### 業務開発版
+
+```
+【業務開発版を使う場面】
+チームで長期間メンテナンスするプロダクションコードに向きます。
+型ヒントとdocstringにより、後から読む人が処理の意図を理解しやすく、
+pylanceによる静的型チェックでバグを実行前に発見できます。
+```
+
+```python
+# Runtime 0 ms
+# Beats 100.00%
+# Memory 19.35 MB
+# Beats 28.62%
+from typing import Any
+
+
+class Solution:
+    """
+    パスカルの三角形生成クラス（業務開発版）
+
+    各行は前の行だけを参照して O(n) で構築する。
+    全体の時間計算量は O(n²)、空間計算量は O(n²)。
+    """
+
+    def generate(self, numRows: int) -> list[list[int]]:
+        """
+        パスカルの三角形の最初の numRows 行を生成して返す。
+
+        Args:
+            numRows: 生成する行数。制約: 1 ≤ numRows ≤ 30
+
+        Returns:
+            各行を list[int] で表した 2 次元リスト
+
+        Raises:
+            TypeError: numRows が int 型でない場合
+            ValueError: numRows が制約範囲外（1〜30以外）の場合
+
+        Time Complexity:  O(n²)  n = numRows
+        Space Complexity: O(n²)
+        """
+        # ─── 入力検証 ─────────────────────────────────────────────
+        # isinstance() で型チェックする。
+        # Python は動的型付け言語のため、呼び出し元が誤った型を渡しても
+        # 実行時まで気づかない。ここで弾くことで分かりやすいエラーにする。
+        # bool は int のサブクラスなので isinstance(True, int) → True になる。
+        # それを防ぐために bool チェックを先に行う。
+        if isinstance(numRows, bool) or not isinstance(numRows, int):
+            raise TypeError(
+                f"numRows must be an int, got: {type(numRows).__name__}"
+            )
+
+        # 制約「1 ≤ numRows ≤ 30」の範囲外を弾く。
+        # 後続の処理でリストの範囲外アクセスが起きるのを防ぐため。
+        if numRows < 1 or numRows > 30:
+            raise ValueError(
+                f"numRows must be between 1 and 30, got: {numRows}"
+            )
+
+        # ─── 結果配列の準備 ───────────────────────────────────────
+        # list[list[int]] = 「整数のリスト」を要素とする2次元リスト
+        triangle: list[list[int]] = []
+
+        # ─── 行を1行ずつ積み上げる ────────────────────────────────
+        for row_index in range(numRows):
+            # 各行の内側の要素だけを計算し、両端は後で [1] + [...] + [1] で追加する
+            current_row = self._build_row(triangle, row_index)
+            triangle.append(current_row)
+
+        return triangle
+
+    def _build_row(
+        self, triangle: list[list[int]], row_index: int
+    ) -> list[int]:
+        """
+        指定した行インデックスの行を構築して返すヘルパー関数。
+
+        Args:
+            triangle: これまでに構築した三角形（前行を参照するために使う）
+            row_index: 今から構築する行のインデックス（0始まり）
+
+        Returns:
+            新しく構築した行（list[int]）
+        """
+        # 0行目：要素は [1] だけ。前の行が存在しないのでそのまま返す。
+        if row_index == 0:
+            return [1]
+
+        # 1行目：[1, 1]。内側の要素がないのでそのまま返す。
+        if row_index == 1:
+            return [1, 1]
+
+        # 2行目以降：前の行を参照して内側を計算する。
+        # prev は前の行への参照。型は list[int] とわかっているため型安全。
+        prev: list[int] = triangle[row_index - 1]
+
+        # リスト内包表記（＝リストを1行で作る書き方）で内側の要素を一括計算する。
+        # なぜリスト内包表記を使うか：CPythonがバイトコードレベルで
+        # ループ専用の最適化命令（LIST_APPEND）を使うため、
+        # 素朴な for ループよりも高速に動作するから。
+        # prev[col - 1] + prev[col] ＝ 真上の左 + 真上の右
+        inner: list[int] = [
+            prev[col - 1] + prev[col]
+            for col in range(1, row_index)   # 先頭と末尾はスキップ（両端は必ず 1）
+        ]
+
+        # 先頭の [1] + 内側 + 末尾の [1] を結合して完成した行にする
+        return [1] + inner + [1]
+```
+
+---
+
+### 競技プログラミング版
+
+```
+【競技プログラミング版を使う場面】
+LeetCodeの制限時間内に正解を出すことが目的のコードに向きます。
+型チェックやエラーハンドリングを省略し、コードを最短・最速にしています。
+可読性よりも実行速度とコードの短さを最優先にした書き方です。
+```
+
+```python
+class Solution:
+    def generate(self, numRows: int) -> list[list[int]]:
+        # 結果を格納するリスト。まず1行目を直接入れる
+        tri: list[list[int]] = [[1]]
+
+        # 2行目以降をループで積み上げる（range(1, numRows) で0行目をスキップ）
+        for i in range(1, numRows):
+            # 直前の行を取り出す（インデックス -1 は末尾 = 直前の行）
+            p = tri[-1]
+
+            # 両端の [1] と内側を内包表記で一括生成して1行で完成させる。
+            # p[j-1] + p[j] ＝ 真上の左 + 真上の右
+            tri.append([1] + [p[j - 1] + p[j] for j in range(1, i)] + [1])
+
+        return tri
+```
+
+---
+
+### 💡 コードの動作トレース（`numRows = 5` の場合）
+
+業務開発版の流れを具体的に追います。
+
+```
+入力: numRows = 5
+
+─── 入力検証 ───
+isinstance(5, bool) → False（boolチェック通過）
+isinstance(5, int)  → True（型チェック通過）
+1 <= 5 <= 30        → 検証通過 ✅
+
+─── ループ開始 ───
+
+[row_index = 0]
+  _build_row() → row_index == 0 なので [1] を即返す
+  triangle = [[1]]
+
+[row_index = 1]
+  _build_row() → row_index == 1 なので [1, 1] を即返す
+  triangle = [[1], [1, 1]]
+
+[row_index = 2]
+  prev = [1, 1]
+  inner = [prev[0] + prev[1]] = [1 + 1] = [2]   ← col=1 の1ステップだけ
+  current_row = [1] + [2] + [1] = [1, 2, 1]
+  triangle = [[1], [1,1], [1,2,1]]
+
+[row_index = 3]
+  prev = [1, 2, 1]
+  inner:
+    col=1 → prev[0] + prev[1] = 1 + 2 = 3
+    col=2 → prev[1] + prev[2] = 2 + 1 = 3
+  inner = [3, 3]
+  current_row = [1] + [3, 3] + [1] = [1, 3, 3, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1]]
+
+[row_index = 4]
+  prev = [1, 3, 3, 1]
+  inner:
+    col=1 → prev[0] + prev[1] = 1 + 3 = 4
+    col=2 → prev[1] + prev[2] = 3 + 3 = 6
+    col=3 → prev[2] + prev[3] = 3 + 1 = 4
+  inner = [4, 6, 4]
+  current_row = [1] + [4, 6, 4] + [1] = [1, 4, 6, 4, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+─── 完成 ───
+出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **リスト内包表記**：`[式 for 変数 in イテラブル]` という形でリストを1行で作る書き方。CPythonは内包表記専用の最適化されたバイトコード命令（`LIST_APPEND`）を使うため、同じ処理を `for` ループで書くより高速
+> - **`isinstance()`**：変数がある型かどうかを調べる組み込み関数。C言語実装のため高速。`type(x) == int` とは異なり、サブクラスも含めてチェックする
+> - **`bool` は `int` のサブクラス**：Pythonでは `True` は内部的に `1`、`False` は `0` として扱われる。そのため `isinstance(True, int)` が `True` を返してしまい、意図しない値を通過させるバグになりやすい。先に `isinstance(x, bool)` をチェックする順番が重要
+> - **型ヒント**：関数の引数や戻り値に型を注釈として書く仕組み。`def f(x: int) -> list[int]:` のように書く。Pythonは動的型付けなので型を書かなくても動くが、pylanceによる静的型チェックを活用するために書く
+> - **`tri[-1]`**：リストの末尾要素へのアクセス。Python固有の負のインデックス記法。`tri[len(tri)-1]` と同じ意味だが短く書ける
+
+---
+
+## 4. 検証（エッジケース確認）
+
+エッジケースのテストは、アルゴリズムが「ふつうの入力」だけでなく「極端な入力」でも正しく動くかを確かめるためのものです。
+
+```python
+# ─── 境界値テスト（業務開発版） ───
+
+sol = Solution()
+
+# 最小値：numRows = 1
+# 期待値: [[1]]
+assert sol.generate(1) == [[1]]
+
+# 最大値：numRows = 30
+# 期待値の最後の行が C(29,0)...C(29,29) になっていることを確認
+result_30 = sol.generate(30)
+assert len(result_30) == 30           # 30行あること
+assert result_30[0] == [1]            # 先頭行が [1] であること
+assert result_30[-1][0] == 1          # 最終行の先頭が 1 であること
+assert result_30[-1][-1] == 1         # 最終行の末尾が 1 であること
+assert result_30[4] == [1,4,6,4,1]   # 5行目の値が正しいこと
+
+# Example 1: numRows = 5
+assert sol.generate(5) == [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+# Example 2: numRows = 1
+assert sol.generate(1) == [[1]]
+
+# ─── 型・範囲エラーのテスト（業務開発版のみ） ───
+
+import traceback
+
+# int でない型を渡す → TypeError が発生するか確認
+try:
+    sol.generate("5")           # type: ignore[arg-type]
+    assert False, "TypeError が発生するべき"
+except TypeError:
+    pass  # 期待通り ✅
+
+# bool を渡す → TypeError が発生するか確認（bool は int のサブクラスなので注意）
+try:
+    sol.generate(True)          # type: ignore[arg-type]
+    assert False, "TypeError が発生するべき"
+except TypeError:
+    pass  # 期待通り ✅
+
+# 範囲外（0以下）→ ValueError が発生するか確認
+try:
+    sol.generate(0)
+    assert False, "ValueError が発生するべき"
+except ValueError:
+    pass  # 期待通り ✅
+
+# 範囲外（31以上）→ ValueError が発生するか確認
+try:
+    sol.generate(31)
+    assert False, "ValueError が発生するべき"
+except ValueError:
+    pass  # 期待通り ✅
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **エッジケース**：空のリスト・最小値・最大値など、境界的な条件のこと。通常の入力では動いても、境界では壊れるアルゴリズムは多い
+> - **境界値テスト**：エッジケースに対してもアルゴリズムが正しく動くかを確かめること
+> - **静的型チェック**：pylanceがコードを実行せず読むだけでバグや型エラーを検出する手法。`# type: ignore` コメントで意図的に型チェックを無効化することもできる
+> - **`assert`文**：条件が `False` のとき `AssertionError` を発生させる構文。テストコードで「この値であるはず」を表現するときによく使う
diff --git a/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Typescript.md b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Typescript.md
new file mode 100644
index 00000000..ba7ab4e8
--- /dev/null
+++ b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/Pascal's_Triangle_Typescript.md	
@@ -0,0 +1,268 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# Pascal's Triangle（パスカルの三角形）
+
+---
+
+## 1. 問題の分析
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「三角形の形に並んだ数値の表を、上から順番に行を積み上げて作る問題」** です。
+
+パスカルの三角形とは何かを先に目で確認しましょう。
+
+```
+行0：        [1]
+行1：       [1, 1]
+行2：      [1, 2, 1]
+行3：     [1, 3, 3, 1]
+行4：    [1, 4, 6, 4, 1]
+```
+
+**ルール**はたった2つです：
+
+- 各行の **両端は必ず `1`**
+- 内側の要素は **真上の左と右の要素を足した値**（例：行2の `2` = 行1の `1 + 1`）
+
+---
+
+### 競技プログラミング視点での分析
+
+- 各行を前の行から `O(k)`（kはその行の要素数）で構築できます
+- 全体の要素数は `1 + 2 + 3 + ... + numRows = numRows*(numRows+1)/2` なので、**最低でも O(numRows²) の時間・空間**が必要
+- `numRows ≤ 30` という制約（＝入力が最大30という上限）があるため、最悪でも `30*31/2 = 465要素` しか生成しません。計算量を特別に最小化しなくても十分高速です
+
+### 業務開発視点での分析
+
+- **型安全性**：戻り値 `number[][]`（数値の2次元配列）を明示し、各行が `number[]` であることをコンパイル時に保証します
+- **エラーハンドリング**：制約 `1 ≤ numRows ≤ 30` の範囲外入力を実行時に検出して弾きます
+- **イミュータブル志向**（＝データを直接書き換えず、新しいデータとして作る考え方）：各行を新しい配列として構築し、前の行を壊しません
+
+### TypeScript特有の考慮点
+
+- **型推論**（＝型を書かなくてもTypeScriptが自動判断する機能）：`prev.length` などから `number` 型が自動推論されます
+- `readonly number[]`（＝読み取り専用の数値配列）を前行の型として使い、誤って前行を書き換えるバグをコンパイル時に防止します
+- 戻り値の `number[][]` の明示により、呼び出し元で型エラーが起きにくくなります
+
+> 📖 **このセクションで登場した用語**
+>
+> - **コンパイル時**：TypeScriptのコードをJavaScriptに変換する段階。ここでエラーを検出すると、プログラムを実行する前にバグを発見できる
+> - **型安全性**：間違った型（例：数値の場所に文字列を渡すなど）のデータが紛れ込まないように守る仕組み
+> - **イミュータブル**：変更できない・変更しない状態のこと。元のデータを壊さないため、バグが起きにくい
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 **初学者向け補足**
+> 同じ問題でも解き方は複数あります。それぞれの「速さ（時間計算量（＝処理にかかる手間の目安））」と「メモリの使いやすさ（空間計算量（＝使うメモリ量の目安））」を比べて最適なものを選びます。
+
+| アプローチ                    | 時間計算量 | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                                                      |
+| ----------------------------- | ---------- | ---------- | ------------ | -------- | ------ | --------------------------------------------------------- |
+| **A. 逐次行構築（今回選択）** | O(n²)      | O(n²)      | 低           | 高       | 高     | 前の行だけ見て次の行を作る                                |
+| B. 二項係数で直接計算         | O(n²)      | O(n²)      | 中           | 中       | 中     | C(n,k)公式を使う。大きいnで整数オーバーフローのリスクあり |
+| C. 再帰（メモ化なし）         | 最悪で指数的／再帰定義で変化 | O(n²)      | 高           | 中       | 低     | 同じ値を何度も再計算するため非効率                        |
+
+> 💡 **Big-O記法の読み方**（初学者向け）
+>
+> - `O(1)`：入力の大きさに関わらず、常に一定の時間・メモリ
+> - `O(n)`：入力が2倍になると処理も約2倍
+> - `O(n²)`：入力が2倍になると処理は約4倍（二重ループに多い）
+
+> 📖 **このセクションで登場した用語**
+>
+> - **二項係数**：組み合わせの数を表す数学的な値。`C(n, k) = n! / (k! * (n-k)!)` で計算できるが、階乗（＝1×2×3×…×n）が大きくなりすぎる問題がある
+> - **再帰**：関数が自分自身を呼び出して問題を解く方法。ツリー構造の問題に向くが、呼び出しが深くなるとメモリを消費する
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **A. 逐次行構築（イテレーティブ＝繰り返し処理による方法）**
+- **理由**:
+    - **方法Bを選ばなかった理由**：二項係数は数式で一見エレガントですが、`numRows=30`のとき `30!`（30の階乗）という非常に大きな数を扱う必要があり、JavaScriptのNumber型（＝浮動小数点数）で精度が落ちるリスクがあります
+    - **方法Cを選ばなかった理由**：再帰は同じ値を何度も計算し直すため、最悪時指数時間となる可能性があり、この問題には不向きです
+    - **方法Aを選んだ理由**：前の行だけを参照して次の行を作る「積み上げ式」のため、計算の無駄がなく、コードの流れも人間の直感と一致していて読みやすいです
+
+- **TypeScript特有の最適化ポイント**:
+    - `readonly number[]` で前行の参照を保護し、「前行を誤って書き換えるバグ」をコンパイル時に防止します
+    - 戻り値型 `number[][]` の明示により、呼び出し元でも型の恩恵を受けられます
+    - 入力検証を関数冒頭で行い、不正な `numRows` が渡されたときに分かりやすいエラーを返します
+
+> 📖 **このセクションで登場した用語**
+>
+> - **イテレーティブ**：ループ（for文など）で繰り返す処理方法。再帰と対比して使う語
+> - **浮動小数点数**：コンピュータが小数を近似値で表す方式。非常に大きな整数を扱うと誤差が生じることがある
+> - **コンパイル時エラー**：TypeScriptのコードをJavaScriptに変換する際に発見されるエラー。実行前にバグを発見できる
+
+---
+
+## 4. 実装コード
+
+> 💡 **このコードの大まかな構造（骨格）**
+>
+> 1. 入力値 `numRows` の検証（範囲外の値を弾く）
+> 2. 結果を格納する空の2次元配列を用意する
+> 3. 1行目（`[1]`）を無条件でセットする
+> 4. 2行目以降は「前の行」を参照して両端を`1`、内側を隣合う値の和で埋める
+> 5. 完成した三角形全体を返す
+
+```typescript
+// Runtime 1 ms
+// Beats 33.72%
+// Memory 56.02 MB
+// Beats 78.88%
+
+/**
+ * パスカルの三角形の最初の numRows 行を生成して返す
+ * @param numRows - 生成する行数（1以上30以下）
+ * @returns 各行を number[] で表した2次元配列
+ * @throws {RangeError} numRows が制約範囲外のとき
+ * @complexity Time: O(n²), Space: O(n²)  n = numRows
+ */
+function generate(numRows: number): number[][] {
+    // ─── 入力検証 ─────────────────────────────────────────────
+    // 制約「1 ≤ numRows ≤ 30」を満たさない値が来たときに
+    // 後続処理で意味不明なバグになる前に、分かりやすいエラーを投げる
+    if (!Number.isInteger(numRows) || numRows < 1 || numRows > 30) {
+        throw new RangeError(`numRows must be an integer between 1 and 30, got: ${numRows}`);
+    }
+
+    // ─── 結果配列の準備 ───────────────────────────────────────
+    // number[][] = 「数値の配列」を要素とする配列（2次元配列）
+    // TypeScriptが戻り値の型をここで確定させるため、明示的に型を付ける
+    const triangle: number[][] = [];
+
+    // ─── 行を1行ずつ積み上げる ────────────────────────────────
+    for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
+        // 各行は rowIndex+1 個の要素を持つ（0行目は1個、1行目は2個…）
+        // Array.from で「長さだけ決まった配列」を作り、すべて 1 で初期化する
+        // 初期値を 1 にする理由：両端は必ず 1 なので、後で端以外だけ上書きすれば済む
+        const currentRow: number[] = Array.from({ length: rowIndex + 1 }, () => 1);
+
+        // 内側の要素を計算する（先頭と末尾は既に 1 なのでスキップ）
+        // 例）rowIndex=3 のとき、更新するのは index 1 と 2 だけ
+        for (let col = 1; col < rowIndex; col++) {
+            // 前の行（readonly として参照）の左上 + 右上 = 現在のセルの値
+            // readonly number[] を型として用いることで、前行を誤って
+            // 書き換えるバグをコンパイル時に防止している（TypeScript固有の恩恵）
+            const prevRow: readonly number[] = triangle[rowIndex - 1];
+            currentRow[col] = prevRow[col - 1] + prevRow[col];
+        }
+
+        // 完成した行を三角形に追加する
+        triangle.push(currentRow);
+    }
+
+    // 全行が揃った三角形を返す
+    return triangle;
+}
+```
+
+---
+
+### 💡 コードの動作トレース（`numRows = 5` の場合）
+
+入力がどのように変化していくかをステップごとに追います。
+
+```
+入力: numRows = 5
+
+─── 入力検証 ───
+Number.isInteger(5) → true
+5 >= 1 かつ 5 <= 30 → 検証通過 ✅
+
+─── ループ開始 ───
+
+[rowIndex = 0]
+  currentRow の初期 = [1]   (長さ1、すべて1)
+  内側ループ: col の範囲 1 ～ -1 → 実行なし（両端だけの行）
+  triangle = [[1]]
+
+[rowIndex = 1]
+  currentRow の初期 = [1, 1]   (長さ2、すべて1)
+  内側ループ: col の範囲 1 ～ 0 → 実行なし（1と1の2要素だけ）
+  triangle = [[1], [1,1]]
+
+[rowIndex = 2]
+  currentRow の初期 = [1, 1, 1]   (長さ3、すべて1)
+  内側ループ: col=1 のみ
+    prevRow = [1, 1]
+    currentRow[1] = prevRow[0] + prevRow[1] = 1 + 1 = 2
+  currentRow 確定 = [1, 2, 1]
+  triangle = [[1], [1,1], [1,2,1]]
+
+[rowIndex = 3]
+  currentRow の初期 = [1, 1, 1, 1]   (長さ4、すべて1)
+  内側ループ: col=1, col=2
+    col=1: prevRow=[1,2,1] → currentRow[1] = 1 + 2 = 3
+    col=2: prevRow=[1,2,1] → currentRow[2] = 2 + 1 = 3
+  currentRow 確定 = [1, 3, 3, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1]]
+
+[rowIndex = 4]
+  currentRow の初期 = [1, 1, 1, 1, 1]   (長さ5、すべて1)
+  内側ループ: col=1, col=2, col=3
+    col=1: prevRow=[1,3,3,1] → currentRow[1] = 1 + 3 = 4
+    col=2: prevRow=[1,3,3,1] → currentRow[2] = 3 + 3 = 6
+    col=3: prevRow=[1,3,3,1] → currentRow[3] = 3 + 1 = 4
+  currentRow 確定 = [1, 4, 6, 4, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+─── 完成 ───
+出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`readonly`**：変数の値を変更できないようにするTypeScript固有の修飾子。JavaScriptにはこの制限がなく、意図せぬ書き換えがバグの原因になりやすい。TypeScriptで `readonly` を付けるとコンパイル時に書き換えを防止できる
+> - **`RangeError`**：値の範囲が不正な場合に投げるエラーの種類。例えば「1〜30以外の数値」など、型は正しいが値が不正なときに使う（型そのものが違う場合は `TypeError` を使う）
+> - **`Array.from({ length: n }, () => 1)`**：長さ `n` の配列を作り、全要素を `1` で初期化するイディオム（＝よく使われる定番の書き方）。`new Array(n).fill(1)` と同じ効果だが、こちらの方が型推論と相性が良い
+> - **Pure function（純粋関数）**：同じ入力を与えると必ず同じ出力を返し、外部の変数や状態を書き換えない関数。テストしやすく、バグが起きにくい
+
+---
+
+## 5. LeetCode 提出用コード
+
+```typescript
+function generate(numRows: number): number[][] {
+    const triangle: number[][] = [];
+
+    for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
+        const currentRow: number[] = Array.from({ length: rowIndex + 1 }, () => 1);
+
+        for (let col = 1; col < rowIndex; col++) {
+            const prevRow: readonly number[] = triangle[rowIndex - 1];
+            currentRow[col] = prevRow[col - 1] + prevRow[col];
+        }
+
+        triangle.push(currentRow);
+    }
+
+    return triangle;
+}
+```
+
+---
+
+## TypeScript固有の最適化観点まとめ
+
+### 型安全性の活用
+
+- **`readonly number[]`**：前行の参照に `readonly` を付けることで「前行を書き換えてしまう」バグをコンパイル時に検出できます。JavaScriptには `readonly` の概念がなく、実行して初めてバグに気づく場合があります
+- **`number[][]` の明示**：戻り値型を明示することで、呼び出し元でも配列の各要素が `number[]` であるという情報が伝わります。型を省略すると、IDEの補完（IntelliSense）が弱くなります
+
+### コンパイル時最適化
+
+- **型推論の活用**：`Array.from({ length: rowIndex + 1 }, () => 1)` の戻り値は `number[]` と自動推論されるため、`:number[]` を明示しなくても型チェックが機能します
+- **`Number.isInteger()`** を使った入力バリデーション：`typeof numRows === 'number'` だけでは小数（例：`5.5`）が通ってしまうため、より厳密な整数チェックを行っています
+
+### 開発効率と保守性
+
+- 各ループ変数 `rowIndex`・`col` に意味のある名前を付けることで、「何番目の行か」「何番目の列か」が一目で分かります
+- `triangle[rowIndex - 1]` を `prevRow` という変数に取り出すことで、コードが「前の行を参照している」という意図を明確に伝えます
diff --git a/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README.md b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README.md
new file mode 100644
index 00000000..d60ca273
--- /dev/null
+++ b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README.md	
@@ -0,0 +1,758 @@
+# Pascal's Triangle - 行を積み上げてパスカルの三角形を生成する
+
+---
+
+## 目次（Table of Contents）
+
+- [概要](#overview)
+- [アルゴリズム要点 TL;DR](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython 最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">概要</h2>
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「三角形の形に並んだ数値の表を、上から1行ずつ積み上げて作る問題」** です。
+> なぜ「積み上げ」かというと、各行の内側の値は **直上の左と右の値を足すだけ** で決まるからです。
+
+### 問題の要件
+
+与えられた整数 `numRows` に対して、パスカルの三角形の最初の `numRows` 行を返します。
+
+```
+行0：     [1]
+行1：    [1, 1]
+行2：   [1, 2, 1]
+行3：  [1, 3, 3, 1]
+行4： [1, 4, 6, 4, 1]
+```
+
+**ルールは 2 つだけ：**
+
+1. 各行の **両端は必ず `1`**
+2. 内側の要素は **真上の左と右の値を足した値**（例：行 2 の `2` = 行 1 の `1 + 1`）
+
+**なぜこの問題が面白いのか：**
+「前の行だけ見れば次の行を作れる」という局所的なルールが積み重なると、美しい三角形ができ上がります。
+この「局所ルールの積み上げ」は、動的計画法（＝部分問題の答えを使って全体の答えを組み立てる手法）の入門として最適な題材です。
+
+### 制約
+
+| 項目             | 値                 |
+| ---------------- | ------------------ |
+| `numRows` の範囲 | `1 ≤ numRows ≤ 30` |
+| 戻り値の型       | `list[list[int]]`  |
+
+> 📖 **この章で登場した用語**
+>
+> - **制約**：入力として与えられる値の範囲や条件のこと。例：「numRows は 1 以上 30 以下」
+> - **動的計画法**：問題を小さな部分問題に分割し、その結果を記録しながら全体の答えを組み立てる手法
+
+---
+
+<h2 id="tldr">アルゴリズム要点（TL;DR）</h2>
+
+> 💡 **TL;DR とは**：Too Long; Didn't Read（長くて読めない人向けの要約）という意味です。
+> ここでは「なんとなくこういう手順で解くんだな」というイメージを掴むことが目標です。
+> 各ステップの詳細は後の章で説明します。
+
+- **戦略**：`for` ループで行を 1 行ずつ積み上げる。前の行だけ参照すれば次の行が作れるので、余分な情報を保持する必要がない
+- **データ構造**：`list[list[int]]`（整数のリストを要素とする 2 次元リスト）。インデックスアクセスが頻繁なため `deque` より `list` が適切
+- **時間計算量**：O(n²)。全要素数が `1 + 2 + ... + n = n(n+1)/2` なので避けられない下限
+- **空間計算量**：O(n²)。全行をメモリに保持して返すため
+- **Python 最適化**：内側の要素はリスト内包表記（＝リストを 1 行で作る書き方）で一括生成。CPython のバイトコードレベルの最適化が効く
+
+> 📖 **この章で登場した用語**
+>
+> - **TL;DR**：「長くて読めない人向けの要約」を意味する略語
+> - **バイトコード**：Python のコードが実行される前に変換される中間形式。`for` ループより内包表記の方が、専用のバイトコード命令を使うため高速
+> - **リスト内包表記**：`[式 for 変数 in イテラブル]` という形でリストを 1 行で作る書き方
+
+---
+
+<h2 id="figures">図解</h2>
+
+> 💡 **Mermaid フローチャートの読み方**
+>
+> - **長方形 `[]`**：処理ステップ（何かをする）
+> - **ひし形 `{}`**：条件分岐（Yes か No かで処理が分かれる）
+> - **矢印 `-->`**：処理の流れの方向
+>
+> 上から下へ（または左から右へ）読み進めてください。
+
+### フローチャート
+
+この図は `generate(numRows)` 関数が内部でどのような手順を踏むかを表しています。
+上から下へ読み進めることで、入力の検証から行の積み上げ、結果の返却までの流れが分かります。
+
+```mermaid
+flowchart TD
+  Start[Start generate numRows]
+  Start --> Validate{Valid input?}
+  Validate -- No --> Err[Raise TypeError or ValueError]
+  Validate -- Yes --> Init[Init empty triangle]
+  Init --> Loop{row_index &lt; numRows?}
+  Loop -- No --> Return[Return triangle]
+  Loop -- Yes --> BuildRow[Build current row]
+  BuildRow --> IsSmall{row_index &lt;= 1?}
+  IsSmall -- Yes --> Fixed[Return fixed row 1 or 1 1]
+  IsSmall -- No --> Prev[Get prev row]
+  Prev --> Inner[Compute inner via list comprehension]
+  Inner --> Assemble[Assemble 1 + inner + 1]
+  Fixed --> Append[Append row to triangle]
+  Assemble --> Append
+  Append --> Increment[Increment row_index]
+  Increment --> Loop
+```
+
+**主要ノードの意味：**
+
+- `Start`：`generate(numRows)` の呼び出し入口
+- `Validate`（ひし形）：型チェックと範囲チェック。不正な入力をここで弾く
+- `Init`：結果リストを `[]`（空リスト）で初期化する
+- `Loop`（ひし形）：`row_index`（0 から開始）が `numRows` に達するまで繰り返す終了条件の判定
+- `BuildRow`：`_build_row()` ヘルパーを呼び出す
+- `IsSmall`（ひし形）：0 行目・1 行目は特殊処理（内側の要素がない）
+- `Inner`：リスト内包表記で `prev[col-1] + prev[col]` を計算
+- `Assemble`：`[1] + inner + [1]` で行を完成させる
+- `Append`：完成した行を `triangle` に追加する
+
+---
+
+### データフロー図
+
+この図は `numRows=5` のとき、各行のデータがどのように生成・蓄積されていくかを表しています。
+
+```mermaid
+graph LR
+  subgraph Input
+    A[numRows = 5]
+  end
+  subgraph Row0
+    B[row0 = 1]
+  end
+  subgraph Row1
+    C[row1 = 1 1]
+  end
+  subgraph Row2
+    D[prev = 1 1]
+    E[inner = 2]
+    F[row2 = 1 2 1]
+    D --> E
+    E --> F
+  end
+  subgraph Row3
+    G[prev = 1 2 1]
+    H[inner = 3 3]
+    I[row3 = 1 3 3 1]
+    G --> H
+    H --> I
+  end
+  subgraph Row4
+    J[prev = 1 3 3 1]
+    K[inner = 4 6 4]
+    L[row4 = 1 4 6 4 1]
+    J --> K
+    K --> L
+  end
+  A --> B
+  B --> C
+  C --> D
+  F --> G
+  I --> J
+  L --> M[Output triangle]
+```
+
+**主要な流れの説明：**
+
+- `Input → Row0`：最初の行 `[1]` は空の `triangle` に対して `row_index=0` で生成される
+- `Rowi → prev`：前の行がそのまま次の行の計算材料（`prev`）になる
+- `prev → inner`：隣り合う要素の和を内包表記で一括計算
+- `inner → rowi`：`[1] + inner + [1]` で両端を追加して行を完成させる
+
+---
+
+> 💡 **代表例でのトレース（`numRows = 5`）**
+
+```
+入力: numRows = 5
+
+── 入力検証 ──
+isinstance(5, bool) → False
+isinstance(5, int)  → True
+1 <= 5 <= 30        → 検証通過 ✅
+
+── ループ ──
+
+[row_index = 0]
+  → row_index == 0 なので [1] を即返す
+  triangle = [[1]]
+
+[row_index = 1]
+  → row_index == 1 なので [1, 1] を即返す
+  triangle = [[1], [1,1]]
+
+[row_index = 2]
+  prev = [1, 1]
+  inner: col=1 → prev[0]+prev[1] = 1+1 = 2
+  inner = [2]
+  row = [1] + [2] + [1] = [1, 2, 1]
+  triangle = [[1],[1,1],[1,2,1]]
+
+[row_index = 3]
+  prev = [1, 2, 1]
+  inner: col=1 → 1+2=3,  col=2 → 2+1=3
+  inner = [3, 3]
+  row = [1] + [3,3] + [1] = [1, 3, 3, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1]]
+
+[row_index = 4]
+  prev = [1, 3, 3, 1]
+  inner: col=1 → 1+3=4,  col=2 → 3+3=6,  col=3 → 3+1=4
+  inner = [4, 6, 4]
+  row = [1] + [4,6,4] + [1] = [1, 4, 6, 4, 1]
+  triangle = [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形=条件分岐、長方形=処理
+> - **データフロー図**：データがどのように変換・移動するかを示す図
+> - **サブグラフ**：フローチャートの中で関連する処理をグループ化した枠
+
+---
+
+<h2 id="correctness">正しさのスケッチ</h2>
+
+> 💡 **初学者向け補足**
+> 「正しさのスケッチ」とは、アルゴリズムが **常に正しい答えを返すことの根拠** を整理したものです。
+> 数学的な厳密な証明ではなく、「なぜ正しいと言えるか」の説明です。
+
+### 不変条件（＝アルゴリズムが正しく動くために、ループ中ずっと成り立ち続けるべき条件）
+
+> ループの各イテレーション（＝繰り返しの 1 回分）の開始時点で、
+> `triangle` には `row_index` 個の行が格納されており、それらはすべてパスカルの三角形のルールを満たしている。
+
+- `row_index = 0` のとき：`triangle = [[1]]`。行 0 は定義上 `[1]` なので成立 ✅
+- `row_index = k` で成立していると仮定すると：`_build_row` は `triangle[k-1]`（前行）から `prev[col-1] + prev[col]` を計算して行 `k` を正しく構築する。よって `row_index = k+1` でも成立 ✅
+
+### 網羅性（＝すべてのケースをもれなく処理できているという保証）
+
+- `row_index == 0`：`[1]` を返す。長さ 1 の行に内側の要素はなく、両端が `1` なのは定義通り
+- `row_index == 1`：`[1, 1]` を返す。長さ 2 の行に内側の要素はなく、両端が `1` なのは定義通り
+- `row_index >= 2`：`[1] + inner + [1]` で構築。`inner` は `prev[col-1] + prev[col]` のすべての `col` を計算するので抜け漏れなし
+
+### 基底条件（＝再帰やループの終了条件）
+
+- `row_index` は 0 始まりで `numRows` 未満の間だけ繰り返す
+- 各行の長さは `row_index + 1` なので必ず正の値。無限ループにはならない
+
+### 終了性（＝アルゴリズムが必ず有限ステップで終わるという保証）
+
+- `numRows ≤ 30` かつ各行の構築は O(k) で完了するため、全体は必ず有限ステップで終了する
+
+> 📖 **この章で登場した用語**
+>
+> - **不変条件**：アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件。「ループ不変条件」とも呼ぶ
+> - **網羅性**：すべてのケースをもれなく処理できているという保証
+> - **終了性**：アルゴリズムが必ず有限ステップで終わるという保証
+> - **イテレーション**：ループの 1 回分の繰り返し処理のこと
+
+---
+
+<h2 id="complexity">計算量</h2>
+
+> 💡 **Big-O 記法の読み方**
+
+| 記法         | 意味                   | 直感的なイメージ            |
+| ------------ | ---------------------- | --------------------------- |
+| `O(1)`       | 入力サイズによらず一定 | 辞書で直接ページを開く      |
+| `O(n)`       | 入力に比例して増加     | リストを端から順に読む      |
+| `O(n log n)` | n よりやや速く増加     | 辞書を二分探索で引く × n 回 |
+| `O(n²)`      | 入力の 2 乗で増加      | 全ペアを総当たりで確認する  |
+
+### この問題の計算量
+
+| 種類           | 計算量 | 理由                                                     |
+| -------------- | ------ | -------------------------------------------------------- |
+| **時間計算量** | O(n²)  | 全要素数 = 1+2+…+n = n(n+1)/2。各要素を 1 度だけ計算する |
+| **空間計算量** | O(n²)  | 生成した全行を `triangle` リストに保持して返すため       |
+
+### なぜ O(n²) を下回れないのか
+
+出力自体が `n(n+1)/2` 個の要素を持つため、それらを生成するだけで O(n²) の時間が必要です。
+どんなに賢いアルゴリズムを使っても、この下限（＝どうしても避けられない計算量の最低ライン）は超えられません。
+
+### Pure vs in-place の比較
+
+| 方式                   | 空間計算量 | 説明                                                         |
+| ---------------------- | ---------- | ------------------------------------------------------------ |
+| **Pure（今回の実装）** | O(n²)      | 全行を新しいリストとして返す。元のデータを変更しない         |
+| **in-place**           | -          | この問題は「全行を返す」のが仕様なので in-place の余地はない |
+
+> 📖 **この章で登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **下限**：どんなアルゴリズムを使っても越えられない計算量の最低ライン
+> - **Pure**：入力を変更せず新しいデータを返す操作。副作用がなく安全
+
+---
+
+<h2 id="impl">Python 実装</h2>
+
+> 💡 **実装の骨格（全体像の把握）**
+> コードを読む前に、処理の流れを箇条書きで確認しましょう。
+>
+> 1. 入力 `numRows` の **型チェック**（`bool` と `int` の区別に注意）と **範囲チェック**（1〜30 以外を弾く）
+> 2. 結果リスト `triangle` を空で用意する
+> 3. `for` ループで `row_index = 0` から `numRows - 1` まで繰り返す
+> 4. 各イテレーションで `_build_row()` を呼び、返ってきた行を `triangle` に追加する
+> 5. `_build_row()` 内：0 行目・1 行目は固定値を返す。2 行目以降は `prev` を参照してリスト内包表記で計算する
+> 6. ループ終了後に `triangle` を返す
+
+```python
+from __future__ import annotations
+
+# TYPE_CHECKING はpylance（静的型チェッカー）が型情報を解析するときだけ True になる。
+# 実行時には False なので、型ヒント専用のインポートは実行コストゼロ。
+from typing import TYPE_CHECKING, Any
+
+
+class Solution:
+    """
+    LeetCode 118: Pascal's Triangle
+
+    パスカルの三角形の最初の numRows 行を生成して返す。
+    各行は前の行だけを参照して O(k) で構築する（k = 行のインデックス）。
+    全体の時間計算量: O(n²)  /  空間計算量: O(n²)  （n = numRows）
+    """
+
+    def generate(self, numRows: int) -> list[list[int]]:
+        """
+        パスカルの三角形を生成して返す（業務開発版）。
+
+        Args:
+            numRows: 生成する行数。制約: 1 <= numRows <= 30
+
+        Returns:
+            各行を list[int] で表した 2 次元リスト
+
+        Raises:
+            TypeError:  numRows が int 型でない場合（bool を含む）
+            ValueError: numRows が 1 未満または 30 超の場合
+
+        Time Complexity:  O(n²)
+        Space Complexity: O(n²)
+        """
+        # ── 入力検証（型チェック） ──────────────────────────────────────
+        # Python では bool が int のサブクラスのため isinstance(True, int) → True になる。
+        # True/False が numRows として渡されても気づかないバグを防ぐため、先に bool を弾く。
+        if isinstance(numRows, bool) or not isinstance(numRows, int):
+            raise TypeError(
+                f"numRows must be an int, got: {type(numRows).__name__}"
+            )
+
+        # ── 入力検証（範囲チェック） ────────────────────────────────────
+        # 制約「1 <= numRows <= 30」の範囲外を弾く。
+        # ここで弾かないと後続のリストアクセスで意図しない動作が起きる可能性がある。
+        if numRows < 1 or numRows > 30:
+            raise ValueError(
+                f"numRows must be between 1 and 30, got: {numRows}"
+            )
+
+        # ── 結果格納用リスト ────────────────────────────────────────────
+        # list[list[int]] = 「整数のリスト」を要素とする 2 次元リスト（型注釈）。
+        # pylance がこの変数の型を正確に把握できるよう明示している。
+        triangle: list[list[int]] = []
+
+        # ── 行を 1 行ずつ積み上げる ─────────────────────────────────────
+        for row_index in range(numRows):
+            # _build_row() に「これまでの三角形」と「今作りたい行番号」を渡す。
+            # 前の行の参照は _build_row() 内で行うため、ここはシンプルに保てる。
+            current_row = self._build_row(triangle, row_index)
+            triangle.append(current_row)
+
+        return triangle
+
+    def _build_row(
+        self, triangle: list[list[int]], row_index: int
+    ) -> list[int]:
+        """
+        指定した行インデックスの行を構築して返すヘルパー関数。
+
+        Args:
+            triangle: これまでに構築した三角形。前行の参照に使う。
+            row_index: 今から構築する行のインデックス（0 始まり）
+
+        Returns:
+            新しく構築した行（list[int]）
+        """
+        # ── 基底条件 1：0 行目 ─────────────────────────────────────────
+        # パスカルの三角形の定義により、最初の行は [1] と決まっている。
+        # 前の行が存在しないためここで早期リターンする。
+        if row_index == 0:
+            return [1]
+
+        # ── 基底条件 2：1 行目 ─────────────────────────────────────────
+        # 1 行目も [1, 1] と決まっている。内側の要素が 1 つもないケース。
+        # （内側要素の計算式 prev[col-1]+prev[col] は col=1..0 → 範囲が空になる）
+        if row_index == 1:
+            return [1, 1]
+
+        # ── 2 行目以降：前の行を参照して内側を計算する ──────────────────
+        # triangle[row_index - 1] が前の行。
+        # list[int] と型注釈を付けることで pylance が prev への操作を型チェックできる。
+        prev: list[int] = triangle[row_index - 1]
+
+        # リスト内包表記（＝リストを 1 行で作る書き方）で内側の要素を一括計算する。
+        # 「なぜ for ループではなく内包表記か」：
+        #   CPython は内包表記専用の最適化されたバイトコード命令（LIST_APPEND）を使う。
+        #   素朴な for + append() より高速に動作するため。
+        # range(1, row_index) で先頭と末尾をスキップ（両端は必ず 1 なので後で追加）。
+        inner: list[int] = [
+            prev[col - 1] + prev[col]   # 真上の左 + 真上の右
+            for col in range(1, row_index)
+        ]
+
+        # [1] + inner + [1] でリストを結合して完成した行にする。
+        # Python のリスト結合は新しいリストを生成するが、行の長さは最大 30 なので問題ない。
+        return [1] + inner + [1]
+```
+
+---
+
+### 競技プログラミング版（LeetCode 提出用最短実装）
+
+```python
+class Solution:
+    def generate(self, numRows: int) -> list[list[int]]:
+        # 1 行目を直接入れて初期化する
+        tri: list[list[int]] = [[1]]
+
+        # 2 行目以降をループで積み上げる（0 行目は初期化済みなので range(1, ...) から）
+        for i in range(1, numRows):
+            # tri[-1] は「tri リストの末尾 = 直前の行」を O(1) で取得する Python の記法
+            p = tri[-1]
+
+            # 両端の [1] と内包表記で計算した内側を 1 行で結合する
+            tri.append([1] + [p[j - 1] + p[j] for j in range(1, i)] + [1])
+
+        return tri
+```
+
+---
+
+> 💡 **コードの動作トレース（`numRows = 5`）**
+
+```
+入力: numRows = 5
+
+── 業務開発版の流れ ──
+
+[入力検証]
+isinstance(5, bool) → False（bool チェック通過）
+isinstance(5, int)  → True（型チェック通過）
+1 <= 5 <= 30        → 範囲チェック通過 ✅
+triangle = []（空リストで初期化）
+
+[row_index = 0]
+_build_row([], 0) → row_index == 0 → return [1]
+triangle = [[1]]
+
+[row_index = 1]
+_build_row([[1]], 1) → row_index == 1 → return [1, 1]
+triangle = [[1], [1,1]]
+
+[row_index = 2]
+_build_row(triangle, 2):
+  prev = [1, 1]
+  inner = [prev[0]+prev[1]] = [1+1] = [2]  ← col=1 の 1 ステップのみ
+  return [1] + [2] + [1] = [1, 2, 1]
+triangle = [[1],[1,1],[1,2,1]]
+
+[row_index = 3]
+_build_row(triangle, 3):
+  prev = [1, 2, 1]
+  inner:
+    col=1 → prev[0]+prev[1] = 1+2 = 3
+    col=2 → prev[1]+prev[2] = 2+1 = 3
+  inner = [3, 3]
+  return [1] + [3,3] + [1] = [1, 3, 3, 1]
+triangle = [[1],[1,1],[1,2,1],[1,3,3,1]]
+
+[row_index = 4]
+_build_row(triangle, 4):
+  prev = [1, 3, 3, 1]
+  inner:
+    col=1 → prev[0]+prev[1] = 1+3 = 4
+    col=2 → prev[1]+prev[2] = 3+3 = 6
+    col=3 → prev[2]+prev[3] = 3+1 = 4
+  inner = [4, 6, 4]
+  return [1] + [4,6,4] + [1] = [1, 4, 6, 4, 1]
+triangle = [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+
+最終出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **`from __future__ import annotations`**：型ヒントを文字列として扱うようにする宣言。クラス自身を型ヒントに使う「前方参照」を解決できる
+> - **`TYPE_CHECKING`**：`from typing import TYPE_CHECKING` で使える定数。pylance が解析するときだけ `True` になり、実行時は `False`。型専用のインポートを実行コストゼロで書くためのテクニック
+> - **`isinstance()`**：変数がある型かどうかを調べる組み込み関数。C 言語実装のため高速
+> - **`bool` は `int` のサブクラス**：Python では `True` が `1`、`False` が `0` として扱われる。`isinstance(True, int)` が `True` を返すため、`bool` を先にチェックする順番が重要
+> - **リスト内包表記**：`[式 for 変数 in イテラブル]` という形でリストを 1 行で作る書き方。CPython 専用の最適化命令（`LIST_APPEND`）が使われるため `for + append()` より高速
+> - **`tri[-1]`**：Python 固有の負のインデックス記法。末尾要素を O(1) で取得できる
+
+---
+
+<h2 id="cpython">CPython 最適化ポイント</h2>
+
+> 💡 **この章では「同じ処理でも Python の書き方によって速さが変わる理由」を説明します。**
+> 最適化は「最適化前のコード → 最適化後のコード → なぜ速いか」の 3 点セットで説明します。
+
+### ポイント 1：リスト内包表記 vs for ループ
+
+内側の要素を計算する部分を比較します。
+
+```python
+# ── 最適化前：for ループで 1 要素ずつ追加 ──
+inner: list[int] = []
+for col in range(1, row_index):
+    inner.append(prev[col - 1] + prev[col])
+
+# ── 最適化後：リスト内包表記で一括生成 ──
+inner: list[int] = [
+    prev[col - 1] + prev[col]
+    for col in range(1, row_index)
+]
+# なぜ速いか：
+# CPython はリスト内包表記をコンパイルするとき、
+# ループ専用の最適化されたバイトコード命令「LIST_APPEND」を使う。
+# 一方の for + append() は毎回「self.inner.append」という
+# 属性アクセス（＝辞書検索）が発生するため、その分だけ遅くなる。
+```
+
+### ポイント 2：`tri[-1]` による末尾アクセス
+
+競技プログラミング版で使っているテクニックです。
+
+```python
+# ── 最適化前：インデックスを明示して前行を取得 ──
+prev = triangle[len(triangle) - 1]
+
+# ── 最適化後：Python の負のインデックスを使う ──
+prev = tri[-1]
+# なぜ速いか：
+# Python の list は末尾から数えるインデックス（負値）を O(1) でサポートしている。
+# len() の計算と引き算が不要になるため、コードが短く・速くなる。
+```
+
+### ポイント 3：`[1] + inner + [1]` によるリスト結合
+
+```python
+# ── 最適化前：先頭・末尾を insert/append で追加 ──
+inner.insert(0, 1)    # O(n)：先頭への挿入は全要素を右にシフトするため遅い
+inner.append(1)       # O(1)：末尾への追加は速い
+
+# ── 最適化後：リスト結合演算子 + を使う ──
+row = [1] + inner + [1]
+# なぜこちらが良いか：
+# list.insert(0, x) は先頭への挿入のため O(n) かかる（全要素を右に移動するから）。
+# [1] + inner + [1] は新しいリストを生成するが、行の長さは最大 30 なので
+# O(30) = O(1) とみなせる。また insert() の O(n) を回避できる。
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **バイトコード**：Python コードが CPython 内部で変換される中間表現。`LIST_APPEND` はリスト内包表記専用の高速命令
+> - **属性アクセス**：`obj.method` のようにオブジェクトのプロパティを参照する操作。CPython 内部では辞書（dict）を使って名前を検索するため、毎回コストが発生する
+> - **`list.insert(0, x)`**：リストの先頭に要素を挿入する操作。全要素を右にシフトするため O(n) になる
+> - **負のインデックス**：`list[-1]` のように末尾から数える Python 固有の記法。`list[len(list)-1]` と同じ意味
+
+---
+
+<h2 id="edgecases">エッジケースと検証観点</h2>
+
+> 💡 **初学者向け補足**
+> エッジケース（＝境界的な条件の入力）を見落とすと、普通のテストは通るのに
+> 特定の入力でだけバグが発生します。代表的なエッジケースを確認しましょう。
+
+| エッジケース              | 入力例       | 期待出力              | なぜ問題になりうるか                                                                                  |
+| ------------------------- | ------------ | --------------------- | ----------------------------------------------------------------------------------------------------- |
+| **最小値**                | `numRows=1`  | `[[1]]`               | ループが 1 回しか回らない。行 0 の特殊処理が正しく動くか確認が必要                                    |
+| **最大値**                | `numRows=30` | 30 行の三角形         | 最大 465 要素を生成する。タイムアウトや MemoryError が起きないか                                      |
+| **行 2 の最初の内側要素** | `numRows=3`  | `[[1],[1,1],[1,2,1]]` | `inner` の長さが 1 になる。範囲が `range(1, 2)` で正しく動くか確認                                    |
+| **型エラー（文字列）**    | `"5"`        | `TypeError`           | `isinstance()` チェックがなければ後続でクラッシュする                                                 |
+| **型エラー（bool）**      | `True`       | `TypeError`           | `bool` は `int` のサブクラスなので `isinstance(True, int)` が `True` を返す。先に bool チェックが必要 |
+| **範囲外（0 以下）**      | `numRows=0`  | `ValueError`          | ループが 0 回回り、空リストが返る。仕様上 `numRows >= 1` なのでエラーにすべき                         |
+| **範囲外（31 以上）**     | `numRows=31` | `ValueError`          | 制約上限を超えた入力。エラーにすべき                                                                  |
+| **浮動小数点数**          | `5.0`        | `TypeError`           | `isinstance(5.0, int)` は `False` なので型エラーになるが、意図が明確になるよう検証メッセージを出す    |
+
+```python
+from typing import Any
+
+sol = Solution()
+
+# 最小値
+assert sol.generate(1) == [[1]]
+
+# 2 行
+assert sol.generate(2) == [[1], [1, 1]]
+
+# 代表例
+assert sol.generate(5) == [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
+
+# 最大値：30 行生成できること・先頭行と最終行の両端が 1 であること
+result_30 = sol.generate(30)
+assert len(result_30) == 30
+assert result_30[0] == [1]
+assert result_30[-1][0] == 1
+assert result_30[-1][-1] == 1
+
+# 型エラー：文字列
+try:
+    sol.generate("5")  # type: ignore[arg-type]
+    assert False, "TypeError が発生するべき"
+except TypeError:
+    pass
+
+# 型エラー：bool（True は 1 として扱われるが仕様上エラーにする）
+try:
+    sol.generate(True)  # type: ignore[arg-type]
+    assert False, "TypeError が発生するべき"
+except TypeError:
+    pass
+
+# 範囲外：0 以下
+try:
+    sol.generate(0)
+    assert False, "ValueError が発生するべき"
+except ValueError:
+    pass
+
+# 範囲外：31 以上
+try:
+    sol.generate(31)
+    assert False, "ValueError が発生するべき"
+except ValueError:
+    pass
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **エッジケース**：空のリスト・最小値・最大値など、境界的な条件の入力
+> - **境界値**：制約の上限・下限にあたる値。例：`numRows=1` や `numRows=30`
+> - **`TypeError`**：型が不正な場合に投げるエラー。「整数を渡すべきところに文字列を渡した」など
+> - **`ValueError`**：型は正しいが値の範囲が不正な場合に投げるエラー。「1〜30 の範囲外の整数」など
+
+---
+
+<h2 id="faq">FAQ</h2>
+
+> 💡 **FAQ（Frequently Asked Questions）とは「よくある質問と回答」のことです。**
+> 初学者がつまずきやすいポイントを Q&A 形式でまとめました。
+> 各回答は「結論 → 理由 → 補足（具体例）」の順で書いています。
+
+---
+
+**Q1. なぜ `deque` を使わずに `list` を使うのですか？**
+
+**結論**：この問題では `list` の方が適切です。
+
+**理由**：`deque`（＝前後から出し入れできる両端キュー）が有効なのは「先頭への追加・削除が頻繁なとき」です。
+`list.pop(0)` や `list.insert(0, x)` は O(n) かかりますが、`deque.popleft()` や `deque.appendleft()` は O(1) です。
+しかしこの問題では先頭への挿入は `[1]` との結合で 1 回だけ行い、その後はインデックスアクセス（`prev[col]`）が中心です。
+`deque` のインデックスアクセスは O(n) なのに対し、`list` は O(1) です。そのため `list` が向いています。
+
+**補足**：`deque` を使うべき場面の例 → BFS（幅優先探索）での先頭からの取り出し、スライディングウィンドウでの先頭削除
+
+---
+
+**Q2. `bool` の型チェックを `isinstance(numRows, int)` の前に置く理由は何ですか？**
+
+**結論**：`bool` は Python の `int` のサブクラスなので、順番を間違えると `True/False` が整数として通過してしまいます。
+
+**理由**：Python では `True == 1`、`False == 0` です。そのため `isinstance(True, int)` は `True` を返します。
+もし `isinstance(numRows, int)` を先にチェックすると、`True` が 1 として扱われ検証を通過してしまいます。
+`bool` を先にチェックすることで「`True` は `int` ではなく `bool` だ」と正しく弾けます。
+
+```python
+# ❌ 間違った順番（bool が通過してしまう）
+if not isinstance(numRows, int):
+    raise TypeError(...)
+# → isinstance(True, int) == True なので True が通過する
+
+# ✅ 正しい順番（bool を先に弾く）
+if isinstance(numRows, bool) or not isinstance(numRows, int):
+    raise TypeError(...)
+# → isinstance(True, bool) == True なので True を弾ける
+```
+
+---
+
+**Q3. なぜ行 0 と行 1 を特殊ケースとして分けるのですか？**
+
+**結論**：行 0 と行 1 は「内側の要素」が存在せず、汎用ロジックを当てはめると計算が空振りするからです。
+
+**理由**：汎用ロジックである `[prev[col-1] + prev[col] for col in range(1, row_index)]` は
+`row_index = 0` のとき `range(1, 0)` → 空のイテラブル、`row_index = 1` のとき `range(1, 1)` → 空のイテラブルになります。
+空のイテラブルに `[1] + [] + [1] = [1, 1]` となり行 1 は正しく動きますが、行 0 は `triangle[-1]` へのアクセスで
+`IndexError`（インデックスエラー）が発生します（`triangle` がまだ空のため）。
+これを安全に処理するために早期リターンを設けています。
+
+```
+row_index=0: range(1, 0) → 空 → [1] + [] + [1] でも良さそうだが
+             前の行 triangle[-1] が存在しないので IndexError になる
+             → 早期リターンで [1] を返す
+row_index=1: range(1, 1) → 空 → [1] + [] + [1] = [1, 1] → 正しい
+             でも前の行 [1] を参照するのでロジック的には問題なし
+             → 明示的に特殊ケースにすることで意図を明確にする
+```
+
+---
+
+**Q4. `[1] + inner + [1]` でリストを結合するとき、毎回新しいリストが作られるのでは？**
+
+**結論**：はい、新しいリストが作られます。しかしこの問題では問題になりません。
+
+**理由**：Python の `+` 演算子はリストを結合した **新しいリスト** を返します（元のリストは変更しません）。
+行の長さは最大 `numRows + 1 = 31` 要素なので、1 回の結合コストは O(31) ≈ O(1) とみなせます。
+全行で合計しても O(n²) の定数倍に収まり、計算量に影響しません。
+
+**補足**：もし行の長さが非常に大きい場合（例：10 万要素）は `[1] + inner + [1]` が O(n) になるため、
+`inner.insert(0, 1)` と `inner.append(1)` を分けた方がメモリ効率が良くなります。
+ただしこの問題では `numRows ≤ 30` なので気にする必要はありません。
+
+---
+
+**Q5. 競技プログラミング版と業務開発版、どちらを選ぶべきですか？**
+
+**結論**：LeetCode への提出なら競技プログラミング版、チーム開発や長期メンテなら業務開発版を選びます。
+
+| 判断軸                             | 競技プログラミング版 | 業務開発版                  |
+| ---------------------------------- | -------------------- | --------------------------- |
+| **コードの短さ**                   | ◎                    | △                           |
+| **実行速度**                       | ◎                    | ○（同等だが検証コストあり） |
+| **型安全性**                       | △（最小限）          | ◎                           |
+| **エラーの分かりやすさ**           | ✗（省略）            | ◎                           |
+| **後から読んだときの理解しやすさ** | △                    | ◎                           |
+
+**補足**：LeetCode では入力が問題の制約を満たすことが保証されているため、型チェックや範囲チェックは省略できます。
+一方、実際のシステム開発では「誰が何を渡してくるか分からない」ため、検証が重要です。
+
+> 📖 **この章で登場した用語**
+>
+> - **FAQ**：Frequently Asked Questions の略。よくある質問と回答のこと
+> - **`IndexError`**：リストや文字列の範囲外の要素にアクセスしようとしたときのエラー。例：長さ 0 のリストに `list[0]` でアクセスする
+> - **イテラブル**：`for` ループで繰り返せるオブジェクトの総称。リスト・タプル・`range` など
+> - **早期リターン**：関数の先頭で特殊なケースを判定し、すぐに `return` することで後続の処理を単純に保つテクニック
diff --git a/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html
new file mode 100644
index 00000000..8bfe72ab
--- /dev/null
+++ b/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html	
@@ -0,0 +1,2001 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 118 — Pascal's Triangle</title>
+        <script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
+        <script
+            src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"
+            crossorigin
+        ></script>
+        <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
+        />
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"></script>
+        <link
+            href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Inter', sans-serif;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: #fff !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            .triangle-cell {
+                display: inline-flex;
+                align-items: center;
+                justify-content: center;
+                width: 36px;
+                height: 36px;
+                border-radius: 8px;
+                font-weight: 600;
+                font-size: 14px;
+                font-family: 'JetBrains Mono', monospace;
+                transition:
+                    background 0.3s,
+                    color 0.3s;
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4,#e0f2fe)] min-h-screen p-4 md:p-8">
+        <div class="max-w-5xl mx-auto">
+            <!-- ================================================================ HEADER -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-2">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 118</span
+                    >
+                    <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >Easy</span
+                    >
+                    <span class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >動的計画法</span
+                    >
+                </div>
+                <h1 class="text-[2.4rem] font-extrabold text-teal-900 mb-1">Pascal's Triangle</h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    行の積み上げ法（動的計画法）による O(n²) 実装
+                </p>
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡
+                    一言で言うと：「上の行だけを見て次の行を1行ずつ積み上げ、パスカルの三角形を作る問題」
+                </p>
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ================================================================ OVERVIEW -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「三角形の形に数値を並べ、上から1行ずつ積み上げて完成させる問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-7">
+                        各行の値は「真上の左と右の値を足すだけ」で決まります。この「局所ルールの積み重ね」は
+                        <strong>動的計画法</strong
+                        >（＝部分問題の答えを再利用して全体を解く技法）の最良な入門例です。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-1 list-disc list-inside leading-7">
+                        <li>
+                            各行は前の行の値がなければ計算できない。行をまたいだ依存関係がある。
+                        </li>
+                        <li>
+                            全行を保持して返す必要があるため、出力サイズ自体が O(n²)
+                            になる。これは避けられない下限。
+                        </li>
+                        <li>
+                            Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">bool</code> が
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">int</code>
+                            のサブクラスなので、型チェックの順番を誤るとバグになる（詳細は FAQ
+                            参照）。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">O(n²)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">O(n²)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            1&nbsp;≤&nbsp;n&nbsp;≤&nbsp;30
+                        </div>
+                        <div class="text-xs mt-1">numRows の範囲</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            list[list[int]]
+                        </div>
+                        <div class="text-xs mt-1">戻り値の型</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div>
+                        <p class="text-teal-800 font-semibold text-sm mb-3">
+                            📥 入力 / 📤 出力の例
+                        </p>
+                        <div
+                            class="bg-slate-50 rounded-xl p-4 border border-slate-200 font-mono text-xs leading-6"
+                        >
+                            <div class="text-slate-400 mb-1"># 入力</div>
+                            <div class="text-slate-700">numRows = 5</div>
+                            <div class="text-slate-400 mt-3 mb-1"># 出力</div>
+                            <div class="text-emerald-700">[[1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 2, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 3, 3, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 4, 6, 4, 1]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ✅ なぜこれが正解か：行2の
+                            <code class="bg-slate-100 px-1 rounded">2</code> は行1の
+                            <code class="bg-slate-100 px-1 rounded">1+1</code>、 行3の
+                            <code class="bg-slate-100 px-1 rounded">3</code> は行2の
+                            <code class="bg-slate-100 px-1 rounded">1+2</code> および
+                            <code class="bg-slate-100 px-1 rounded">2+1</code>。すべて定義通り。
+                        </p>
+                    </div>
+                    <div>
+                        <p class="text-teal-800 font-semibold text-sm mb-3">
+                            📐 パスカルの三角形のルール（2つだけ）
+                        </p>
+                        <div class="space-y-2 text-sm text-slate-700 leading-7">
+                            <div class="p-3 rounded-lg bg-emerald-50 border border-emerald-200">
+                                <span class="font-bold text-emerald-700">ルール 1：</span>
+                                各行の<strong>両端は必ず 1</strong>
+                            </div>
+                            <div class="p-3 rounded-lg bg-sky-50 border border-sky-200">
+                                <span class="font-bold text-sky-700">ルール 2：</span>
+                                内側の要素 = <strong>真上の左 + 真上の右</strong><br />
+                                例）行2の <code class="bg-white px-1 rounded font-mono">2</code> =
+                                行1の <code class="bg-white px-1 rounded font-mono">1 + 1</code>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ================================================================ STEPS (React mount point) -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    numRows = 5 を例に、アルゴリズムの各ステップを追います。
+                </p>
+                <div id="steps-app"></div>
+            </section>
+
+            <!-- ================================================================ CODE -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>入力の検証：型チェック（bool を先に弾く）と範囲チェック（1〜30）</li>
+                        <li>
+                            結果リスト
+                            <code class="bg-white px-1 rounded font-mono text-xs">triangle</code>
+                            を空で初期化し、<code class="bg-white px-1 rounded font-mono text-xs"
+                                >for</code
+                            >
+                            ループで行を積み上げる
+                        </li>
+                        <li>
+                            各行は
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >_build_row()</code
+                            >
+                            ヘルパーで構築：行0・行1は固定値を返す
+                        </li>
+                        <li>
+                            行2以降：前行を参照し、リスト内包表記で内側を計算して
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >[1]+inner+[1]</code
+                            >
+                            で完成
+                        </li>
+                    </ol>
+                </div>
+
+                <p class="text-teal-700 font-semibold text-sm mb-2">
+                    ▸ 業務開発版（型検証・コメント付き）
+                </p>
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+
+
+class Solution:
+    """LeetCode 118: Pascal's Triangle — 行の積み上げ法"""
+
+    def generate(self, numRows: int) -> list[list[int]]:
+        # ── 入力検証（型チェック） ────────────────────────────────────
+        # Python では bool が int のサブクラスなので先に bool を弾く
+        if isinstance(numRows, bool) or not isinstance(numRows, int):
+            raise TypeError(f"numRows must be int, got: {type(numRows).__name__}")
+
+        # ── 入力検証（範囲チェック） ──────────────────────────────────
+        if numRows < 1 or numRows > 30:
+            raise ValueError(f"numRows must be 1‒30, got: {numRows}")
+
+        # ── 結果格納用リスト ──────────────────────────────────────────
+        triangle: list[list[int]] = []
+
+        # ── 行を 1 行ずつ積み上げる ───────────────────────────────────
+        for row_index in range(numRows):
+            current_row = self._build_row(triangle, row_index)
+            triangle.append(current_row)
+
+        return triangle
+
+    def _build_row(self, triangle: list[list[int]], row_index: int) -> list[int]:
+        # 基底条件1：行0 は [1] 固定（前行が存在しないので早期リターン）
+        if row_index == 0:
+            return [1]
+
+        # 基底条件2：行1 は [1, 1] 固定（内側の要素が存在しない）
+        if row_index == 1:
+            return [1, 1]
+
+        # 行2以降：前の行を参照して内側の要素をリスト内包表記で計算
+        prev: list[int] = triangle[row_index - 1]
+
+        # CPython の LIST_APPEND 命令が効くため、for+append より高速
+        inner: list[int] = [
+            prev[col - 1] + prev[col]   # 真上の左 + 真上の右
+            for col in range(1, row_index)
+        ]
+
+        return [1] + inner + [1]
+</code></pre>
+
+                <div class="mt-2 mb-6 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 numRows = 5 での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+入力: numRows = 5
+
+[検証] isinstance(5, bool)→False, isinstance(5, int)→True, 1≤5≤30 ✅
+
+[row_index=0] _build_row([], 0)  → [1]             triangle=[[1]]
+[row_index=1] _build_row(.., 1)  → [1,1]            triangle=[[1],[1,1]]
+[row_index=2] prev=[1,1]
+              inner: col=1 → 1+1=2  →  inner=[2]
+              return [1]+[2]+[1] = [1,2,1]            triangle=[[1],[1,1],[1,2,1]]
+[row_index=3] prev=[1,2,1]
+              inner: col=1→1+2=3, col=2→2+1=3  →  inner=[3,3]
+              return [1,3,3,1]                        triangle=[..,[1,3,3,1]]
+[row_index=4] prev=[1,3,3,1]
+              inner: col=1→1+3=4, col=2→3+3=6, col=3→3+1=4  →  inner=[4,6,4]
+              return [1,4,6,4,1]                      triangle=[..,[1,4,6,4,1]]
+
+出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅</pre
+                    >
+                </div>
+
+                <p class="text-teal-700 font-semibold text-sm mb-2">
+                    ▸ 競技プログラミング版（LeetCode 提出用・最短実装）
+                </p>
+                <pre class="line-numbers"><code class="language-python">class Solution:
+    def generate(self, numRows: int) -> list[list[int]]:
+        tri: list[list[int]] = [[1]]
+        for i in range(1, numRows):
+            p = tri[-1]          # tri[-1] → 末尾行を O(1) で取得（Python の負インデックス）
+            tri.append([1] + [p[j-1] + p[j] for j in range(1, i)] + [1])
+        return tri
+</code></pre>
+            </section>
+
+            <!-- ================================================================ DIAGRAM -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <ellipse
+                                    cx="13"
+                                    cy="9"
+                                    rx="12"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="24"
+                                    height="12"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <polygon
+                                    points="13,1 25,9 13,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500"></span
+                            ><span class="mr-2">はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-500"></span
+                            ><span>いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto">
+                    <!--
+      viewBox="0 0 560 890"
+      Main flow: x=60, width=360, center x=240, height=44, rx=8
+      Diamonds: center x=240, half_w=180, half_h=30
+      Side boxes: x=430, width=125, center x=492
+      All text: text-anchor="middle", dominant-baseline="middle"
+      SVG attributes: kebab-case (static HTML context)
+    -->
+                    <svg
+                        viewBox="0 0 560 890"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Pascal's Triangle flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-green"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-red"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#dc2626" />
+                            </marker>
+                            <marker
+                                id="fc-purple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#7c3aed" />
+                            </marker>
+                        </defs>
+
+                        <!-- ── Node 1: 開始 (ellipse) cy=44 ── -->
+                        <ellipse
+                            cx="240"
+                            cy="44"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="44"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <!-- Arrow 1→2 -->
+                        <line
+                            x1="240"
+                            y1="70"
+                            x2="240"
+                            y2="93"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 2: 入力検証 (diamond) cy=125 ── -->
+                        <polygon
+                            points="240,95 420,125 240,155 60,125"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="118"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            入力検証
+                        </text>
+                        <text
+                            x="240"
+                            y="133"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (型・範囲チェック)
+                        </text>
+
+                        <!-- Side: TypeError/ValueError -->
+                        <rect
+                            x="430"
+                            y="107"
+                            width="125"
+                            height="36"
+                            rx="6"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="121"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            font-weight="600"
+                            fill="#991b1b"
+                        >
+                            TypeError /
+                        </text>
+                        <text
+                            x="492"
+                            y="134"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#991b1b"
+                        >
+                            ValueError
+                        </text>
+                        <!-- Arrow 2→Error (No) -->
+                        <line
+                            x1="420"
+                            y1="125"
+                            x2="430"
+                            y2="125"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-red)"
+                        />
+                        <text x="425" y="120" text-anchor="middle" font-size="10" fill="#dc2626">
+                            No
+                        </text>
+
+                        <!-- Arrow 2→3 (Yes) -->
+                        <line
+                            x1="240"
+                            y1="155"
+                            x2="240"
+                            y2="178"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="252" y="168" font-size="10" fill="#059669">Yes</text>
+
+                        <!-- ── Node 3: triangle 初期化 (rect) y=180 ── -->
+                        <rect
+                            x="60"
+                            y="180"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="197"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            triangle = [] を初期化
+                        </text>
+                        <text
+                            x="240"
+                            y="213"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (結果を格納する 2 次元リスト)
+                        </text>
+
+                        <!-- Arrow 3→4 -->
+                        <line
+                            x1="240"
+                            y1="224"
+                            x2="240"
+                            y2="263"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 4: ループ条件 (diamond) cy=297 ── -->
+                        <polygon
+                            points="240,265 420,297 240,329 60,297"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="290"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            row_index &lt; numRows ?
+                        </text>
+                        <text
+                            x="240"
+                            y="305"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (ループ継続の判定)
+                        </text>
+
+                        <!-- Side: 結果を返す -->
+                        <ellipse
+                            cx="492"
+                            cy="297"
+                            rx="63"
+                            ry="22"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="293"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            triangle
+                        </text>
+                        <text
+                            x="492"
+                            y="307"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#065f46"
+                        >
+                            を返す
+                        </text>
+                        <!-- Arrow 4→Return (No) -->
+                        <line
+                            x1="420"
+                            y1="297"
+                            x2="429"
+                            y2="297"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-red)"
+                        />
+                        <text x="424" y="291" text-anchor="middle" font-size="10" fill="#dc2626">
+                            No
+                        </text>
+
+                        <!-- Arrow 4→5 (Yes) -->
+                        <line
+                            x1="240"
+                            y1="329"
+                            x2="240"
+                            y2="352"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="252" y="342" font-size="10" fill="#059669">Yes</text>
+
+                        <!-- ── Node 5: _build_row() (rect) y=354 ── -->
+                        <rect
+                            x="60"
+                            y="354"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#ede9fe"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="371"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#3b0764"
+                        >
+                            _build_row() 呼び出し
+                        </text>
+                        <text
+                            x="240"
+                            y="387"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#6d28d9"
+                        >
+                            (現在の行番号を渡す)
+                        </text>
+
+                        <!-- Arrow 5→6 -->
+                        <line
+                            x1="240"
+                            y1="398"
+                            x2="240"
+                            y2="428"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 6: row_index ≤ 1? (diamond) cy=462 ── -->
+                        <polygon
+                            points="240,430 420,462 240,494 60,462"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="455"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            row_index ≤ 1 ?
+                        </text>
+                        <text
+                            x="240"
+                            y="470"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (基底条件の判定)
+                        </text>
+
+                        <!-- Side: 固定値を返す -->
+                        <rect
+                            x="430"
+                            y="444"
+                            width="125"
+                            height="36"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="458"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            [1] または
+                        </text>
+                        <text
+                            x="492"
+                            y="471"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#065f46"
+                        >
+                            [1, 1] を返す
+                        </text>
+                        <!-- Arrow 6→Fixed (Yes) -->
+                        <line
+                            x1="420"
+                            y1="462"
+                            x2="430"
+                            y2="462"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="424" y="456" text-anchor="middle" font-size="10" fill="#059669">
+                            Yes
+                        </text>
+
+                        <!-- Fixed → Append (arrow going down then left) -->
+                        <polyline
+                            points="492,480 492,747 420,747"
+                            fill="none"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            stroke-dasharray="5,3"
+                            marker-end="url(#fc-green)"
+                        />
+
+                        <!-- Arrow 6→7 (No) -->
+                        <line
+                            x1="240"
+                            y1="494"
+                            x2="240"
+                            y2="517"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+                        <text x="252" y="507" font-size="10" fill="#dc2626">No</text>
+
+                        <!-- ── Node 7: prev = triangle[row_index-1] (rect) y=519 ── -->
+                        <rect
+                            x="60"
+                            y="519"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="536"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            prev = triangle[row_index − 1]
+                        </text>
+                        <text
+                            x="240"
+                            y="552"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (前の行を参照する)
+                        </text>
+
+                        <!-- Arrow 7→8 -->
+                        <line
+                            x1="240"
+                            y1="563"
+                            x2="240"
+                            y2="589"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 8: inner 計算 (rect) y=591 ── -->
+                        <rect
+                            x="60"
+                            y="591"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="607"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            リスト内包表記で inner を計算
+                        </text>
+                        <text
+                            x="240"
+                            y="623"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            prev[c−1] + prev[c] の全ての c
+                        </text>
+
+                        <!-- Arrow 8→9 -->
+                        <line
+                            x1="240"
+                            y1="635"
+                            x2="240"
+                            y2="661"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 9: [1]+inner+[1] (rect) y=663 ── -->
+                        <rect
+                            x="60"
+                            y="663"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#dbeafe"
+                            stroke="#1d4ed8"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="679"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            row = [1] + inner + [1]
+                        </text>
+                        <text
+                            x="240"
+                            y="695"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (両端に 1 を付けて行を完成)
+                        </text>
+
+                        <!-- Arrow 9→10 -->
+                        <line
+                            x1="240"
+                            y1="707"
+                            x2="240"
+                            y2="729"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 10: triangle.append(row) (rect) y=731 ── -->
+                        <rect
+                            x="60"
+                            y="731"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#ede9fe"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="748"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#3b0764"
+                        >
+                            triangle.append(row)
+                        </text>
+                        <text
+                            x="240"
+                            y="764"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#6d28d9"
+                        >
+                            (完成した行を三角形に追加)
+                        </text>
+
+                        <!-- Arrow 10→11 -->
+                        <line
+                            x1="240"
+                            y1="775"
+                            x2="240"
+                            y2="801"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 11: row_index++ (rect) y=803 ── -->
+                        <rect
+                            x="60"
+                            y="803"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="820"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            row_index += 1
+                        </text>
+                        <text
+                            x="240"
+                            y="836"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (次の行へ進む)
+                        </text>
+
+                        <!-- Loop back arrow: 11 → 4 (left side) -->
+                        <polyline
+                            points="240,847 240,858 30,858 30,297 60,297"
+                            fill="none"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                            stroke-dasharray="5,3"
+                            marker-end="url(#fc-purple)"
+                        />
+                        <text x="110" y="854" font-size="10" fill="#7c3aed">繰り返す</text>
+                    </svg>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-2">
+                        🔎 入力例 numRows = 5 でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ 入力検証（<code
+                                class="bg-white px-1 rounded font-mono text-xs"
+                                >isinstance</code
+                            >
+                            で型と範囲を確認）→ 検証通過
+                        </li>
+                        <li>
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >triangle = []</code
+                            >
+                            を初期化。ループに入る。
+                        </li>
+                        <li>
+                            row_index=0: ループ条件 0&lt;5 → Yes →
+                            <code class="bg-white px-1 rounded font-mono text-xs">_build_row</code>
+                            → row_index≤1 → Yes →
+                            <code class="bg-white px-1 rounded font-mono text-xs">[1]</code> を
+                            append。
+                        </li>
+                        <li>
+                            row_index=1: 同様に
+                            <code class="bg-white px-1 rounded font-mono text-xs">[1,1]</code> を
+                            append。
+                        </li>
+                        <li>
+                            row_index=2〜4: row_index≤1 → No → prev 参照 → inner 計算 →
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >[1]+inner+[1]</code
+                            >
+                            → append → row_index++。
+                        </li>
+                        <li>
+                            row_index=5: ループ条件 5&lt;5 → No →
+                            <code class="bg-white px-1 rounded font-mono text-xs">triangle</code>
+                            を返す。
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ================================================================ COMPLEXITY -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力 n
+                        が大きくなるにつれ処理時間がどう変わるかの目安）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold font-mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：ソートアルゴリズム</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto mb-4">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-teal-50">
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    種類
+                                </th>
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    計算量
+                                </th>
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    理由
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-red-100 text-red-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(n²)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    全要素数 = 1+2+…+n = n(n+1)/2。各要素を1度だけ計算する。
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    空間計算量
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-red-100 text-red-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(n²)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    全行を
+                                    <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                        >triangle</code
+                                    >
+                                    に保持して返すため。
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    1行あたり
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-emerald-100 text-emerald-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(k)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    k 行目の構築は k 個の要素を計算するだけ（k は行インデックス）。
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜ O(n²) になるのか、そして下回れないのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        行 k の要素数は k+1 個なので、全要素数は 1+2+3+…+n = n(n+1)/2 ≈ n²/2
+                        です。これは Big-O 表記で <strong>O(n²)</strong> になります。
+                        重要なのは「出力自体が n²/2
+                        個の要素を持つ」という点です。どんなに賢いアルゴリズムを使っても、
+                        出力を生成するだけで O(n²) の時間が必要になります。この O(n²)
+                        は<strong>下限</strong>（どうしても下回れないコスト）であり、
+                        本実装はその下限を達成しています。
+                    </p>
+                </div>
+
+                <div class="mt-4 overflow-x-auto">
+                    <p class="text-teal-800 font-semibold text-sm mb-2">
+                        📊 numRows ごとの要素数の増え方
+                    </p>
+                    <table class="text-xs border-collapse">
+                        <thead>
+                            <tr class="bg-slate-50">
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">
+                                    numRows (n)
+                                </th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">1</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">5</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">10</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">20</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">30</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 font-semibold text-slate-700"
+                                >
+                                    全要素数
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-emerald-700 font-mono"
+                                >
+                                    1
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-emerald-700 font-mono"
+                                >
+                                    15
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-amber-700 font-mono"
+                                >
+                                    55
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-orange-700 font-mono"
+                                >
+                                    210
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-red-700 font-mono"
+                                >
+                                    465
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </section>
+
+            <!-- ================================================================ GLOSSARY -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。（五十音順）
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> イテラブル
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">for</code>
+                            ループで繰り返せるオブジェクトの総称。 リスト・タプル・<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >range()</code
+                            >
+                            など。 例：<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >range(1, 3)</code
+                            >
+                            は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">1, 2</code>
+                            を順に返すイテラブル。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> イテレーション
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            ループの1回分の繰り返し処理のこと。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for i in range(5)</code
+                            >
+                            は5回イテレーションする。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 下限（かげん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            どんなアルゴリズムを使っても越えられない計算量の最低ライン。
+                            この問題では出力自体が O(n²) 個の要素を持つため、O(n²) が下限になる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            基底条件（きていじょうけん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            再帰やループの終了条件、または特殊ケースを処理する最初の条件。
+                            この問題では行0（<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[1]</code
+                            >）と行1（<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[1,1]</code
+                            >）が基底条件。
+                            内側の要素が存在しないため、汎用ロジックとは別に処理する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            空間計算量（くうかんけいさんりょう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            処理中に使うメモリ量が入力 n に対してどう変化するかの目安。
+                            辞書に例えると「探偵がメモを取るためのノートの枚数」。
+                            この問題では全行を保存するため O(n²)。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            時間計算量（じかんけいさんりょう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            入力の大きさ n に対して処理にかかる手間がどう増えるかの目安。 「n
+                            が2倍になったら処理時間は何倍か」を表す Big-O 記法で表現する。 O(n²)
+                            は「n が2倍になると処理は4倍になる」という意味。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            動的計画法（どうてきけいかくほう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            問題を小さな部分問題に分割し、その結果を再利用しながら全体の答えを組み立てる手法。
+                            料理に例えると「昨日作ったスープのだしを今日の料理に使い回す」イメージ。
+                            この問題では「前の行（部分問題の答え）を使って次の行を作る」のが動的計画法に当たる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            不変条件（ふへんじょうけん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムが正しく動くために、ループ中ずっと成り立ち続けるべき条件（ループ不変条件とも言う）。
+                            この問題では「ループ開始時に
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >triangle</code
+                            >
+                            には正しいパスカルの行が入っている」が不変条件。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> バイトコード
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python のソースコードが実行前に変換される中間形式。 CPython
+                            はリスト内包表記を
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >LIST_APPEND</code
+                            >
+                            という専用の最適化命令にコンパイルするため、 通常の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for + append()</code
+                            >
+                            より高速に動作する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> リスト内包表記
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[式 for 変数 in イテラブル]</code
+                            >
+                            という形でリストを1行で作る書き方。 例：<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[x*2 for x in range(3)]</code
+                            >
+                            →
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[0, 2, 4]</code
+                            >。 CPython の最適化命令が使われるため、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for + append()</code
+                            >
+                            より高速。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            早期リターン（そうきりたーん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の先頭で特殊なケースを判定し、すぐに
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">return</code>
+                            することで後続の処理をシンプルに保つテクニック。
+                            「ネストを深くしない」コードスタイルの一つ。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> bool は int
+                            のサブクラス
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >True == 1</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >False == 0</code
+                            >
+                            として扱われる。 そのため
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >isinstance(True, int)</code
+                            >
+                            は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">True</code>
+                            を返す。 型チェックでは
+                            <strong>bool を先に弾く</strong>ことでこのバグを防げる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-xs pb-8">
+                LeetCode 118 — Pascal's Triangle | 行の積み上げ法 O(n²)
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- ================================================================ REACT APP -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const TRIANGLE_5 = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]];
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '入力の検証',
+                    shortDesc: '型チェックと範囲チェック',
+                    desc:
+                        'まず numRows が正しい型（int）と範囲（1〜30）かを確認します。' +
+                        'なぜなら、不正な入力をここで弾かなければ後続の処理で予期しないバグが起きるからです。' +
+                        '例）numRows=5 の場合：isinstance(5, bool)→False、isinstance(5, int)→True、1≤5≤30 → すべて通過 ✅',
+                    triangleState: [],
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        numRows: 5,
+                        check: 'isinstance(5,bool)→False, isinstance(5,int)→True, 1≤5≤30 ✅',
+                    },
+                },
+                {
+                    step: 2,
+                    title: '結果リストの初期化',
+                    shortDesc: 'triangle = [] を準備',
+                    desc:
+                        '結果を格納する空の2次元リスト triangle = [] を用意します。' +
+                        'なぜなら、行を1つずつ追加していくためのコンテナが必要だからです。' +
+                        '例）triangle = [] の状態でループに入ります。行は1行も入っていない初期状態です。',
+                    triangleState: [],
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: { numRows: 5, triangle: '[]', rowIndex: 0 },
+                },
+                {
+                    step: 3,
+                    title: '行 0 の生成（基底条件1）',
+                    shortDesc: 'row_index=0 → [1] を返す',
+                    desc:
+                        'row_index=0 のとき、前の行が存在しないため特別扱いし [1] を返します。' +
+                        'パスカルの三角形の定義により、最初の行は常に [1] と決まっています。' +
+                        '例）_build_row([], 0) → row_index==0 → return [1]。triangle = [[1]] になります。',
+                    triangleState: [[1]],
+                    currentRowIndex: 0,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: { rowIndex: 0, action: '基底条件: return [1]', triangle: '[[1]]' },
+                },
+                {
+                    step: 4,
+                    title: '行 1 の生成（基底条件2）',
+                    shortDesc: 'row_index=1 → [1,1] を返す',
+                    desc:
+                        'row_index=1 のとき、内側の要素が1つもないため [1,1] を返します。' +
+                        '内側要素の計算式 range(1, 1) は空のため、両端の 1 だけになります。' +
+                        '例）_build_row(.., 1) → row_index==1 → return [1,1]。triangle = [[1],[1,1]] になります。',
+                    triangleState: [[1], [1, 1]],
+                    currentRowIndex: 1,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        rowIndex: 1,
+                        action: '基底条件: return [1,1]',
+                        triangle: '[[1],[1,1]]',
+                    },
+                },
+                {
+                    step: 5,
+                    title: '前行参照 → 内側を計算（row 2）',
+                    shortDesc: 'prev=[1,1] → inner=[2] → [1,2,1]',
+                    desc:
+                        'row_index=2 から汎用ロジックが動きます。前の行 prev=[1,1] を参照し、' +
+                        'リスト内包表記で内側の要素を計算します（prev[c-1]+prev[c]）。' +
+                        '例）col=1: prev[0]+prev[1]=1+1=2 → inner=[2] → [1]+[2]+[1]=[1,2,1]。',
+                    triangleState: [[1], [1, 1], [1, 2, 1]],
+                    currentRowIndex: 2,
+                    prevRow: [1, 1],
+                    innerVals: [2],
+                    varState: {
+                        rowIndex: 2,
+                        prev: '[1,1]',
+                        inner: '[2]',
+                        row: '[1,2,1]',
+                        triangle: '3行まで完成',
+                    },
+                },
+                {
+                    step: 6,
+                    title: '完成（全5行）',
+                    shortDesc: 'triangle = 5行すべて完成',
+                    desc:
+                        '同じ手順を row_index=3,4 にも繰り返し、三角形が完成します。' +
+                        'row_index=5 でループ条件 5<5 が偽になり、triangle を返します。' +
+                        '例）最終出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅',
+                    triangleState: TRIANGLE_5,
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        rowIndex: 5,
+                        condition: '5 < 5 → False → 終了',
+                        result: '[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]',
+                    },
+                },
+            ];
+
+            function TriangleDisplay({ triangleState, currentRowIndex, prevRow, innerVals }) {
+                if (triangleState.length === 0) {
+                    return (
+                        <div className="mt-3 flex items-center justify-center h-20 rounded-xl bg-slate-50 border border-slate-200 text-slate-400 text-sm">
+                            triangle = [] （まだ行なし）
+                        </div>
+                    );
+                }
+
+                const maxCols = triangleState[triangleState.length - 1].length;
+
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200">
+                        <div className="text-slate-500 text-xs font-semibold mb-2">
+                            🔺 triangle の現在の状態
+                        </div>
+                        <div className="flex flex-col items-center gap-1">
+                            {triangleState.map((row, ri) => {
+                                const isPrev =
+                                    prevRow !== null &&
+                                    ri === triangleState.length - 2 &&
+                                    prevRow !== null;
+                                const isCurrent =
+                                    currentRowIndex !== null && ri === currentRowIndex;
+                                return (
+                                    <div key={ri} className="flex gap-1">
+                                        {row.map((val, ci) => {
+                                            let bg = 'bg-slate-200 text-slate-600';
+                                            if (isCurrent) bg = 'bg-emerald-400 text-white';
+                                            else if (isPrev) bg = 'bg-sky-300 text-white';
+                                            return (
+                                                <span
+                                                    key={ci}
+                                                    className={['triangle-cell', bg].join(' ')}
+                                                >
+                                                    {val}
+                                                </span>
+                                            );
+                                        })}
+                                    </div>
+                                );
+                            })}
+                        </div>
+                        {(prevRow || innerVals) && (
+                            <div className="mt-2 flex flex-wrap gap-3 text-xs text-center justify-center">
+                                {prevRow && (
+                                    <span className="px-2 py-1 rounded bg-sky-100 text-sky-700">
+                                        <span className="font-semibold">prev</span> = [
+                                        {prevRow.join(', ')}]
+                                    </span>
+                                )}
+                                {innerVals && (
+                                    <span className="px-2 py-1 rounded bg-amber-100 text-amber-700">
+                                        <span className="font-semibold">inner</span> = [
+                                        {innerVals.join(', ')}]
+                                    </span>
+                                )}
+                            </div>
+                        )}
+                    </div>
+                );
+            }
+
+            function VarPanel({ varState }) {
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-900 border border-slate-700 font-mono text-xs leading-6">
+                        <div className="text-slate-400 mb-1 font-sans text-xs font-semibold">
+                            🔍 現在の変数の状態
+                        </div>
+                        {Object.entries(varState).map(([k, v]) => (
+                            <div key={k}>
+                                <span className="text-sky-400">{k}</span>
+                                <span className="text-slate-400"> = </span>
+                                <span className="text-emerald-400">{String(v)}</span>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                const currentStepData = stepsData[activeStep - 1];
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* Step list */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-base font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const isActive = activeStep === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(s.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-xs mb-0.5',
+                                                    isActive ? 'text-emerald-800' : 'text-teal-700',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}
+                                            </div>
+                                            <div
+                                                className={[
+                                                    'font-semibold',
+                                                    isActive
+                                                        ? 'text-emerald-900'
+                                                        : 'text-slate-700',
+                                                ].join(' ')}
+                                            >
+                                                {s.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs mt-0.5">
+                                                {s.shortDesc}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* Detail panel */}
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← Step {activeStep - 1} では「{stepsData[activeStep - 2].title}
+                                    」を行いました
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <div className="text-xs font-bold text-emerald-600 mb-1">
+                                    Step {currentStepData.step}
+                                </div>
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
+                                    {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <TriangleDisplay
+                                triangleState={currentStepData.triangleState}
+                                currentRowIndex={currentStepData.currentRowIndex}
+                                prevRow={currentStepData.prevRow}
+                                innerVals={currentStepData.innerVals}
+                            />
+
+                            <VarPanel varState={currentStepData.varState} />
+
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-app')).render(<StepsApp />);
+
+            // Re-highlight after React renders
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 300);
+        </script>
+    </body>
+</html>
diff --git a/SQL/Leetcode/Basic delete/196. Delete Duplicate Emails/DeleteDuplicateEmails_pandas.md b/SQL/Leetcode/Basic delete/196. Delete Duplicate Emails/DeleteDuplicateEmails_pandas.md
index 624088cd..d222bbcd 100644
--- a/SQL/Leetcode/Basic delete/196. Delete Duplicate Emails/DeleteDuplicateEmails_pandas.md	
+++ b/SQL/Leetcode/Basic delete/196. Delete Duplicate Emails/DeleteDuplicateEmails_pandas.md	
@@ -328,7 +328,7 @@ person.drop_duplicates(subset='email', keep='first', inplace=True)
 - 伸びしろが小さいのは、**理論下限（O(N)）＋ Pandas C 実装の成熟度＋ in-place 削除の不可避コスト**が原因。
 - どうしても差を出すなら、**ルール緩和（安定ソート許容）**、**別エンジン（Polars）**、**事前カテゴリ化**など、土台を動かす必要があります。
 
-悔しいですが、今回は「世界トップクラスでも難しい」側のケースです。上の NumPy 版（A）は最後の一手として試せますが、**データ依存**で、常勝ではありません。
+上の NumPy 版（A）は最後の一手として試せますが、**データ依存**で、常勝ではありません。
 
 原因は **`np.minimum.reduceat` に空配列（長さ 0）の開始位置 `starts=[0]` を渡してしまった**ことです。
 `reduceat` は「インデックス `starts[i]` が入力配列の範囲内であること」を要求します。
diff --git a/generate_index.py b/generate_index.py
index 6d1080f4..dd914c5b 100644
--- a/generate_index.py
+++ b/generate_index.py
@@ -243,6 +243,8 @@ def generate_index(self) -> None:
 <html lang="ja">
 <head>
     <meta charset="UTF-8">
+    <meta name="generator" content="generate_index.py">
+    <!-- AUTO_GENERATED: DO NOT EDIT THIS FILE DIRECTLY. USE generate_index.py TO REGENERATE. -->
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Algorithm Study Lab</title>
     <link rel="preconnect" href="https://fonts.googleapis.com">
diff --git a/public/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html b/public/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html
new file mode 100644
index 00000000..86c2048d
--- /dev/null
+++ b/public/Algorithm/Other/leetcode/118. Pascal's Triangle/claude sonnet 4.6 adaptive/README_React.html	
@@ -0,0 +1,2001 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 118 — Pascal's Triangle</title>
+        <script src="/vendor/react/react.development.js" crossorigin></script>
+        <script
+            src="/vendor/react-dom/react-dom.development.js"
+            crossorigin
+        ></script>
+        <script src="/vendor/babel/babel.min.js"></script>
+        <script src="/vendor/tailwindcss/script.js"></script>
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+        />
+        <script src="/vendor/prismjs/prism.js"></script>
+        <script src="/vendor/prismjs/components/prism-python.min.js"></script>
+        <script src="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.js"></script>
+        <script src="/vendor/prismjs/plugins/toolbar/prism-toolbar.js"></script>
+        <script src="/vendor/prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard.js"></script>
+        <link
+            href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Inter', sans-serif;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: #fff !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            .triangle-cell {
+                display: inline-flex;
+                align-items: center;
+                justify-content: center;
+                width: 36px;
+                height: 36px;
+                border-radius: 8px;
+                font-weight: 600;
+                font-size: 14px;
+                font-family: 'JetBrains Mono', monospace;
+                transition:
+                    background 0.3s,
+                    color 0.3s;
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4,#e0f2fe)] min-h-screen p-4 md:p-8">
+        <div class="max-w-5xl mx-auto">
+            <!-- ================================================================ HEADER -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-2">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 118</span
+                    >
+                    <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >Easy</span
+                    >
+                    <span class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >動的計画法</span
+                    >
+                </div>
+                <h1 class="text-[2.4rem] font-extrabold text-teal-900 mb-1">Pascal's Triangle</h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    行の積み上げ法（動的計画法）による O(n²) 実装
+                </p>
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡
+                    一言で言うと：「上の行だけを見て次の行を1行ずつ積み上げ、パスカルの三角形を作る問題」
+                </p>
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ================================================================ OVERVIEW -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「三角形の形に数値を並べ、上から1行ずつ積み上げて完成させる問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-7">
+                        各行の値は「真上の左と右の値を足すだけ」で決まります。この「局所ルールの積み重ね」は
+                        <strong>動的計画法</strong
+                        >（＝部分問題の答えを再利用して全体を解く技法）の最良な入門例です。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-1 list-disc list-inside leading-7">
+                        <li>
+                            各行は前の行の値がなければ計算できない。行をまたいだ依存関係がある。
+                        </li>
+                        <li>
+                            全行を保持して返す必要があるため、出力サイズ自体が O(n²)
+                            になる。これは避けられない下限。
+                        </li>
+                        <li>
+                            Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">bool</code> が
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">int</code>
+                            のサブクラスなので、型チェックの順番を誤るとバグになる（詳細は FAQ
+                            参照）。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">O(n²)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">O(n²)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            1&nbsp;≤&nbsp;n&nbsp;≤&nbsp;30
+                        </div>
+                        <div class="text-xs mt-1">numRows の範囲</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            list[list[int]]
+                        </div>
+                        <div class="text-xs mt-1">戻り値の型</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div>
+                        <p class="text-teal-800 font-semibold text-sm mb-3">
+                            📥 入力 / 📤 出力の例
+                        </p>
+                        <div
+                            class="bg-slate-50 rounded-xl p-4 border border-slate-200 font-mono text-xs leading-6"
+                        >
+                            <div class="text-slate-400 mb-1"># 入力</div>
+                            <div class="text-slate-700">numRows = 5</div>
+                            <div class="text-slate-400 mt-3 mb-1"># 出力</div>
+                            <div class="text-emerald-700">[[1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 2, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 3, 3, 1],</div>
+                            <div class="text-emerald-700">&nbsp;[1, 4, 6, 4, 1]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ✅ なぜこれが正解か：行2の
+                            <code class="bg-slate-100 px-1 rounded">2</code> は行1の
+                            <code class="bg-slate-100 px-1 rounded">1+1</code>、 行3の
+                            <code class="bg-slate-100 px-1 rounded">3</code> は行2の
+                            <code class="bg-slate-100 px-1 rounded">1+2</code> および
+                            <code class="bg-slate-100 px-1 rounded">2+1</code>。すべて定義通り。
+                        </p>
+                    </div>
+                    <div>
+                        <p class="text-teal-800 font-semibold text-sm mb-3">
+                            📐 パスカルの三角形のルール（2つだけ）
+                        </p>
+                        <div class="space-y-2 text-sm text-slate-700 leading-7">
+                            <div class="p-3 rounded-lg bg-emerald-50 border border-emerald-200">
+                                <span class="font-bold text-emerald-700">ルール 1：</span>
+                                各行の<strong>両端は必ず 1</strong>
+                            </div>
+                            <div class="p-3 rounded-lg bg-sky-50 border border-sky-200">
+                                <span class="font-bold text-sky-700">ルール 2：</span>
+                                内側の要素 = <strong>真上の左 + 真上の右</strong><br />
+                                例）行2の <code class="bg-white px-1 rounded font-mono">2</code> =
+                                行1の <code class="bg-white px-1 rounded font-mono">1 + 1</code>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ================================================================ STEPS (React mount point) -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    numRows = 5 を例に、アルゴリズムの各ステップを追います。
+                </p>
+                <div id="steps-app"></div>
+            </section>
+
+            <!-- ================================================================ CODE -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>入力の検証：型チェック（bool を先に弾く）と範囲チェック（1〜30）</li>
+                        <li>
+                            結果リスト
+                            <code class="bg-white px-1 rounded font-mono text-xs">triangle</code>
+                            を空で初期化し、<code class="bg-white px-1 rounded font-mono text-xs"
+                                >for</code
+                            >
+                            ループで行を積み上げる
+                        </li>
+                        <li>
+                            各行は
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >_build_row()</code
+                            >
+                            ヘルパーで構築：行0・行1は固定値を返す
+                        </li>
+                        <li>
+                            行2以降：前行を参照し、リスト内包表記で内側を計算して
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >[1]+inner+[1]</code
+                            >
+                            で完成
+                        </li>
+                    </ol>
+                </div>
+
+                <p class="text-teal-700 font-semibold text-sm mb-2">
+                    ▸ 業務開発版（型検証・コメント付き）
+                </p>
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+
+
+class Solution:
+    """LeetCode 118: Pascal's Triangle — 行の積み上げ法"""
+
+    def generate(self, numRows: int) -> list[list[int]]:
+        # ── 入力検証（型チェック） ────────────────────────────────────
+        # Python では bool が int のサブクラスなので先に bool を弾く
+        if isinstance(numRows, bool) or not isinstance(numRows, int):
+            raise TypeError(f"numRows must be int, got: {type(numRows).__name__}")
+
+        # ── 入力検証（範囲チェック） ──────────────────────────────────
+        if numRows < 1 or numRows > 30:
+            raise ValueError(f"numRows must be 1‒30, got: {numRows}")
+
+        # ── 結果格納用リスト ──────────────────────────────────────────
+        triangle: list[list[int]] = []
+
+        # ── 行を 1 行ずつ積み上げる ───────────────────────────────────
+        for row_index in range(numRows):
+            current_row = self._build_row(triangle, row_index)
+            triangle.append(current_row)
+
+        return triangle
+
+    def _build_row(self, triangle: list[list[int]], row_index: int) -> list[int]:
+        # 基底条件1：行0 は [1] 固定（前行が存在しないので早期リターン）
+        if row_index == 0:
+            return [1]
+
+        # 基底条件2：行1 は [1, 1] 固定（内側の要素が存在しない）
+        if row_index == 1:
+            return [1, 1]
+
+        # 行2以降：前の行を参照して内側の要素をリスト内包表記で計算
+        prev: list[int] = triangle[row_index - 1]
+
+        # CPython の LIST_APPEND 命令が効くため、for+append より高速
+        inner: list[int] = [
+            prev[col - 1] + prev[col]   # 真上の左 + 真上の右
+            for col in range(1, row_index)
+        ]
+
+        return [1] + inner + [1]
+</code></pre>
+
+                <div class="mt-2 mb-6 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 numRows = 5 での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+入力: numRows = 5
+
+[検証] isinstance(5, bool)→False, isinstance(5, int)→True, 1≤5≤30 ✅
+
+[row_index=0] _build_row([], 0)  → [1]             triangle=[[1]]
+[row_index=1] _build_row(.., 1)  → [1,1]            triangle=[[1],[1,1]]
+[row_index=2] prev=[1,1]
+              inner: col=1 → 1+1=2  →  inner=[2]
+              return [1]+[2]+[1] = [1,2,1]            triangle=[[1],[1,1],[1,2,1]]
+[row_index=3] prev=[1,2,1]
+              inner: col=1→1+2=3, col=2→2+1=3  →  inner=[3,3]
+              return [1,3,3,1]                        triangle=[..,[1,3,3,1]]
+[row_index=4] prev=[1,3,3,1]
+              inner: col=1→1+3=4, col=2→3+3=6, col=3→3+1=4  →  inner=[4,6,4]
+              return [1,4,6,4,1]                      triangle=[..,[1,4,6,4,1]]
+
+出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅</pre
+                    >
+                </div>
+
+                <p class="text-teal-700 font-semibold text-sm mb-2">
+                    ▸ 競技プログラミング版（LeetCode 提出用・最短実装）
+                </p>
+                <pre class="line-numbers"><code class="language-python">class Solution:
+    def generate(self, numRows: int) -> list[list[int]]:
+        tri: list[list[int]] = [[1]]
+        for i in range(1, numRows):
+            p = tri[-1]          # tri[-1] → 末尾行を O(1) で取得（Python の負インデックス）
+            tri.append([1] + [p[j-1] + p[j] for j in range(1, i)] + [1])
+        return tri
+</code></pre>
+            </section>
+
+            <!-- ================================================================ DIAGRAM -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <ellipse
+                                    cx="13"
+                                    cy="9"
+                                    rx="12"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="24"
+                                    height="12"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="26" height="18">
+                                <polygon
+                                    points="13,1 25,9 13,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500"></span
+                            ><span class="mr-2">はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-500"></span
+                            ><span>いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto">
+                    <!--
+      viewBox="0 0 560 890"
+      Main flow: x=60, width=360, center x=240, height=44, rx=8
+      Diamonds: center x=240, half_w=180, half_h=30
+      Side boxes: x=430, width=125, center x=492
+      All text: text-anchor="middle", dominant-baseline="middle"
+      SVG attributes: kebab-case (static HTML context)
+    -->
+                    <svg
+                        viewBox="0 0 560 890"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Pascal's Triangle flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-green"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-red"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#dc2626" />
+                            </marker>
+                            <marker
+                                id="fc-purple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#7c3aed" />
+                            </marker>
+                        </defs>
+
+                        <!-- ── Node 1: 開始 (ellipse) cy=44 ── -->
+                        <ellipse
+                            cx="240"
+                            cy="44"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="44"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <!-- Arrow 1→2 -->
+                        <line
+                            x1="240"
+                            y1="70"
+                            x2="240"
+                            y2="93"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 2: 入力検証 (diamond) cy=125 ── -->
+                        <polygon
+                            points="240,95 420,125 240,155 60,125"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="118"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            入力検証
+                        </text>
+                        <text
+                            x="240"
+                            y="133"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (型・範囲チェック)
+                        </text>
+
+                        <!-- Side: TypeError/ValueError -->
+                        <rect
+                            x="430"
+                            y="107"
+                            width="125"
+                            height="36"
+                            rx="6"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="121"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            font-weight="600"
+                            fill="#991b1b"
+                        >
+                            TypeError /
+                        </text>
+                        <text
+                            x="492"
+                            y="134"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#991b1b"
+                        >
+                            ValueError
+                        </text>
+                        <!-- Arrow 2→Error (No) -->
+                        <line
+                            x1="420"
+                            y1="125"
+                            x2="430"
+                            y2="125"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-red)"
+                        />
+                        <text x="425" y="120" text-anchor="middle" font-size="10" fill="#dc2626">
+                            No
+                        </text>
+
+                        <!-- Arrow 2→3 (Yes) -->
+                        <line
+                            x1="240"
+                            y1="155"
+                            x2="240"
+                            y2="178"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="252" y="168" font-size="10" fill="#059669">Yes</text>
+
+                        <!-- ── Node 3: triangle 初期化 (rect) y=180 ── -->
+                        <rect
+                            x="60"
+                            y="180"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="197"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            triangle = [] を初期化
+                        </text>
+                        <text
+                            x="240"
+                            y="213"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (結果を格納する 2 次元リスト)
+                        </text>
+
+                        <!-- Arrow 3→4 -->
+                        <line
+                            x1="240"
+                            y1="224"
+                            x2="240"
+                            y2="263"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 4: ループ条件 (diamond) cy=297 ── -->
+                        <polygon
+                            points="240,265 420,297 240,329 60,297"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="290"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            row_index &lt; numRows ?
+                        </text>
+                        <text
+                            x="240"
+                            y="305"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (ループ継続の判定)
+                        </text>
+
+                        <!-- Side: 結果を返す -->
+                        <ellipse
+                            cx="492"
+                            cy="297"
+                            rx="63"
+                            ry="22"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="293"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            triangle
+                        </text>
+                        <text
+                            x="492"
+                            y="307"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#065f46"
+                        >
+                            を返す
+                        </text>
+                        <!-- Arrow 4→Return (No) -->
+                        <line
+                            x1="420"
+                            y1="297"
+                            x2="429"
+                            y2="297"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-red)"
+                        />
+                        <text x="424" y="291" text-anchor="middle" font-size="10" fill="#dc2626">
+                            No
+                        </text>
+
+                        <!-- Arrow 4→5 (Yes) -->
+                        <line
+                            x1="240"
+                            y1="329"
+                            x2="240"
+                            y2="352"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="252" y="342" font-size="10" fill="#059669">Yes</text>
+
+                        <!-- ── Node 5: _build_row() (rect) y=354 ── -->
+                        <rect
+                            x="60"
+                            y="354"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#ede9fe"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="371"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#3b0764"
+                        >
+                            _build_row() 呼び出し
+                        </text>
+                        <text
+                            x="240"
+                            y="387"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#6d28d9"
+                        >
+                            (現在の行番号を渡す)
+                        </text>
+
+                        <!-- Arrow 5→6 -->
+                        <line
+                            x1="240"
+                            y1="398"
+                            x2="240"
+                            y2="428"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 6: row_index ≤ 1? (diamond) cy=462 ── -->
+                        <polygon
+                            points="240,430 420,462 240,494 60,462"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.8"
+                        />
+                        <text
+                            x="240"
+                            y="455"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            row_index ≤ 1 ?
+                        </text>
+                        <text
+                            x="240"
+                            y="470"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            (基底条件の判定)
+                        </text>
+
+                        <!-- Side: 固定値を返す -->
+                        <rect
+                            x="430"
+                            y="444"
+                            width="125"
+                            height="36"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="492"
+                            y="458"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            [1] または
+                        </text>
+                        <text
+                            x="492"
+                            y="471"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#065f46"
+                        >
+                            [1, 1] を返す
+                        </text>
+                        <!-- Arrow 6→Fixed (Yes) -->
+                        <line
+                            x1="420"
+                            y1="462"
+                            x2="430"
+                            y2="462"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-green)"
+                        />
+                        <text x="424" y="456" text-anchor="middle" font-size="10" fill="#059669">
+                            Yes
+                        </text>
+
+                        <!-- Fixed → Append (arrow going down then left) -->
+                        <polyline
+                            points="492,480 492,747 420,747"
+                            fill="none"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            stroke-dasharray="5,3"
+                            marker-end="url(#fc-green)"
+                        />
+
+                        <!-- Arrow 6→7 (No) -->
+                        <line
+                            x1="240"
+                            y1="494"
+                            x2="240"
+                            y2="517"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+                        <text x="252" y="507" font-size="10" fill="#dc2626">No</text>
+
+                        <!-- ── Node 7: prev = triangle[row_index-1] (rect) y=519 ── -->
+                        <rect
+                            x="60"
+                            y="519"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="536"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            prev = triangle[row_index − 1]
+                        </text>
+                        <text
+                            x="240"
+                            y="552"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (前の行を参照する)
+                        </text>
+
+                        <!-- Arrow 7→8 -->
+                        <line
+                            x1="240"
+                            y1="563"
+                            x2="240"
+                            y2="589"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 8: inner 計算 (rect) y=591 ── -->
+                        <rect
+                            x="60"
+                            y="591"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="607"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            リスト内包表記で inner を計算
+                        </text>
+                        <text
+                            x="240"
+                            y="623"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            prev[c−1] + prev[c] の全ての c
+                        </text>
+
+                        <!-- Arrow 8→9 -->
+                        <line
+                            x1="240"
+                            y1="635"
+                            x2="240"
+                            y2="661"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 9: [1]+inner+[1] (rect) y=663 ── -->
+                        <rect
+                            x="60"
+                            y="663"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#dbeafe"
+                            stroke="#1d4ed8"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="679"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            row = [1] + inner + [1]
+                        </text>
+                        <text
+                            x="240"
+                            y="695"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (両端に 1 を付けて行を完成)
+                        </text>
+
+                        <!-- Arrow 9→10 -->
+                        <line
+                            x1="240"
+                            y1="707"
+                            x2="240"
+                            y2="729"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 10: triangle.append(row) (rect) y=731 ── -->
+                        <rect
+                            x="60"
+                            y="731"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#ede9fe"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="748"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#3b0764"
+                        >
+                            triangle.append(row)
+                        </text>
+                        <text
+                            x="240"
+                            y="764"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#6d28d9"
+                        >
+                            (完成した行を三角形に追加)
+                        </text>
+
+                        <!-- Arrow 10→11 -->
+                        <line
+                            x1="240"
+                            y1="775"
+                            x2="240"
+                            y2="801"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 11: row_index++ (rect) y=803 ── -->
+                        <rect
+                            x="60"
+                            y="803"
+                            width="360"
+                            height="44"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="240"
+                            y="820"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            row_index += 1
+                        </text>
+                        <text
+                            x="240"
+                            y="836"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                        >
+                            (次の行へ進む)
+                        </text>
+
+                        <!-- Loop back arrow: 11 → 4 (left side) -->
+                        <polyline
+                            points="240,847 240,858 30,858 30,297 60,297"
+                            fill="none"
+                            stroke="#7c3aed"
+                            stroke-width="1.5"
+                            stroke-dasharray="5,3"
+                            marker-end="url(#fc-purple)"
+                        />
+                        <text x="110" y="854" font-size="10" fill="#7c3aed">繰り返す</text>
+                    </svg>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-2">
+                        🔎 入力例 numRows = 5 でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ 入力検証（<code
+                                class="bg-white px-1 rounded font-mono text-xs"
+                                >isinstance</code
+                            >
+                            で型と範囲を確認）→ 検証通過
+                        </li>
+                        <li>
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >triangle = []</code
+                            >
+                            を初期化。ループに入る。
+                        </li>
+                        <li>
+                            row_index=0: ループ条件 0&lt;5 → Yes →
+                            <code class="bg-white px-1 rounded font-mono text-xs">_build_row</code>
+                            → row_index≤1 → Yes →
+                            <code class="bg-white px-1 rounded font-mono text-xs">[1]</code> を
+                            append。
+                        </li>
+                        <li>
+                            row_index=1: 同様に
+                            <code class="bg-white px-1 rounded font-mono text-xs">[1,1]</code> を
+                            append。
+                        </li>
+                        <li>
+                            row_index=2〜4: row_index≤1 → No → prev 参照 → inner 計算 →
+                            <code class="bg-white px-1 rounded font-mono text-xs"
+                                >[1]+inner+[1]</code
+                            >
+                            → append → row_index++。
+                        </li>
+                        <li>
+                            row_index=5: ループ条件 5&lt;5 → No →
+                            <code class="bg-white px-1 rounded font-mono text-xs">triangle</code>
+                            を返す。
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ================================================================ COMPLEXITY -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力 n
+                        が大きくなるにつれ処理時間がどう変わるかの目安）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold font-mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：ソートアルゴリズム</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto mb-4">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-teal-50">
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    種類
+                                </th>
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    計算量
+                                </th>
+                                <th
+                                    class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-semibold"
+                                >
+                                    理由
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-red-100 text-red-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(n²)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    全要素数 = 1+2+…+n = n(n+1)/2。各要素を1度だけ計算する。
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    空間計算量
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-red-100 text-red-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(n²)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    全行を
+                                    <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                        >triangle</code
+                                    >
+                                    に保持して返すため。
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="border border-slate-200 px-4 py-3 font-semibold text-slate-700"
+                                >
+                                    1行あたり
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3">
+                                    <span
+                                        class="bg-emerald-100 text-emerald-800 font-mono font-bold px-2 py-0.5 rounded"
+                                        >O(k)</span
+                                    >
+                                </td>
+                                <td class="border border-slate-200 px-4 py-3 text-slate-600">
+                                    k 行目の構築は k 個の要素を計算するだけ（k は行インデックス）。
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜ O(n²) になるのか、そして下回れないのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        行 k の要素数は k+1 個なので、全要素数は 1+2+3+…+n = n(n+1)/2 ≈ n²/2
+                        です。これは Big-O 表記で <strong>O(n²)</strong> になります。
+                        重要なのは「出力自体が n²/2
+                        個の要素を持つ」という点です。どんなに賢いアルゴリズムを使っても、
+                        出力を生成するだけで O(n²) の時間が必要になります。この O(n²)
+                        は<strong>下限</strong>（どうしても下回れないコスト）であり、
+                        本実装はその下限を達成しています。
+                    </p>
+                </div>
+
+                <div class="mt-4 overflow-x-auto">
+                    <p class="text-teal-800 font-semibold text-sm mb-2">
+                        📊 numRows ごとの要素数の増え方
+                    </p>
+                    <table class="text-xs border-collapse">
+                        <thead>
+                            <tr class="bg-slate-50">
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">
+                                    numRows (n)
+                                </th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">1</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">5</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">10</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">20</th>
+                                <th class="border border-slate-200 px-3 py-2 text-slate-600">30</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 font-semibold text-slate-700"
+                                >
+                                    全要素数
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-emerald-700 font-mono"
+                                >
+                                    1
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-emerald-700 font-mono"
+                                >
+                                    15
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-amber-700 font-mono"
+                                >
+                                    55
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-orange-700 font-mono"
+                                >
+                                    210
+                                </td>
+                                <td
+                                    class="border border-slate-200 px-3 py-2 text-center text-red-700 font-mono"
+                                >
+                                    465
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+            </section>
+
+            <!-- ================================================================ GLOSSARY -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。（五十音順）
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> イテラブル
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">for</code>
+                            ループで繰り返せるオブジェクトの総称。 リスト・タプル・<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >range()</code
+                            >
+                            など。 例：<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >range(1, 3)</code
+                            >
+                            は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">1, 2</code>
+                            を順に返すイテラブル。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> イテレーション
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            ループの1回分の繰り返し処理のこと。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for i in range(5)</code
+                            >
+                            は5回イテレーションする。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 下限（かげん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            どんなアルゴリズムを使っても越えられない計算量の最低ライン。
+                            この問題では出力自体が O(n²) 個の要素を持つため、O(n²) が下限になる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            基底条件（きていじょうけん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            再帰やループの終了条件、または特殊ケースを処理する最初の条件。
+                            この問題では行0（<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[1]</code
+                            >）と行1（<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[1,1]</code
+                            >）が基底条件。
+                            内側の要素が存在しないため、汎用ロジックとは別に処理する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            空間計算量（くうかんけいさんりょう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            処理中に使うメモリ量が入力 n に対してどう変化するかの目安。
+                            辞書に例えると「探偵がメモを取るためのノートの枚数」。
+                            この問題では全行を保存するため O(n²)。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            時間計算量（じかんけいさんりょう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            入力の大きさ n に対して処理にかかる手間がどう増えるかの目安。 「n
+                            が2倍になったら処理時間は何倍か」を表す Big-O 記法で表現する。 O(n²)
+                            は「n が2倍になると処理は4倍になる」という意味。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            動的計画法（どうてきけいかくほう）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            問題を小さな部分問題に分割し、その結果を再利用しながら全体の答えを組み立てる手法。
+                            料理に例えると「昨日作ったスープのだしを今日の料理に使い回す」イメージ。
+                            この問題では「前の行（部分問題の答え）を使って次の行を作る」のが動的計画法に当たる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            不変条件（ふへんじょうけん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムが正しく動くために、ループ中ずっと成り立ち続けるべき条件（ループ不変条件とも言う）。
+                            この問題では「ループ開始時に
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >triangle</code
+                            >
+                            には正しいパスカルの行が入っている」が不変条件。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> バイトコード
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python のソースコードが実行前に変換される中間形式。 CPython
+                            はリスト内包表記を
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >LIST_APPEND</code
+                            >
+                            という専用の最適化命令にコンパイルするため、 通常の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for + append()</code
+                            >
+                            より高速に動作する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> リスト内包表記
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[式 for 変数 in イテラブル]</code
+                            >
+                            という形でリストを1行で作る書き方。 例：<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[x*2 for x in range(3)]</code
+                            >
+                            →
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >[0, 2, 4]</code
+                            >。 CPython の最適化命令が使われるため、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >for + append()</code
+                            >
+                            より高速。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            早期リターン（そうきりたーん）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の先頭で特殊なケースを判定し、すぐに
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">return</code>
+                            することで後続の処理をシンプルに保つテクニック。
+                            「ネストを深くしない」コードスタイルの一つ。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> bool は int
+                            のサブクラス
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >True == 1</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >False == 0</code
+                            >
+                            として扱われる。 そのため
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >isinstance(True, int)</code
+                            >
+                            は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">True</code>
+                            を返す。 型チェックでは
+                            <strong>bool を先に弾く</strong>ことでこのバグを防げる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-xs pb-8">
+                LeetCode 118 — Pascal's Triangle | 行の積み上げ法 O(n²)
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- ================================================================ REACT APP -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const TRIANGLE_5 = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]];
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '入力の検証',
+                    shortDesc: '型チェックと範囲チェック',
+                    desc:
+                        'まず numRows が正しい型（int）と範囲（1〜30）かを確認します。' +
+                        'なぜなら、不正な入力をここで弾かなければ後続の処理で予期しないバグが起きるからです。' +
+                        '例）numRows=5 の場合：isinstance(5, bool)→False、isinstance(5, int)→True、1≤5≤30 → すべて通過 ✅',
+                    triangleState: [],
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        numRows: 5,
+                        check: 'isinstance(5,bool)→False, isinstance(5,int)→True, 1≤5≤30 ✅',
+                    },
+                },
+                {
+                    step: 2,
+                    title: '結果リストの初期化',
+                    shortDesc: 'triangle = [] を準備',
+                    desc:
+                        '結果を格納する空の2次元リスト triangle = [] を用意します。' +
+                        'なぜなら、行を1つずつ追加していくためのコンテナが必要だからです。' +
+                        '例）triangle = [] の状態でループに入ります。行は1行も入っていない初期状態です。',
+                    triangleState: [],
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: { numRows: 5, triangle: '[]', rowIndex: 0 },
+                },
+                {
+                    step: 3,
+                    title: '行 0 の生成（基底条件1）',
+                    shortDesc: 'row_index=0 → [1] を返す',
+                    desc:
+                        'row_index=0 のとき、前の行が存在しないため特別扱いし [1] を返します。' +
+                        'パスカルの三角形の定義により、最初の行は常に [1] と決まっています。' +
+                        '例）_build_row([], 0) → row_index==0 → return [1]。triangle = [[1]] になります。',
+                    triangleState: [[1]],
+                    currentRowIndex: 0,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: { rowIndex: 0, action: '基底条件: return [1]', triangle: '[[1]]' },
+                },
+                {
+                    step: 4,
+                    title: '行 1 の生成（基底条件2）',
+                    shortDesc: 'row_index=1 → [1,1] を返す',
+                    desc:
+                        'row_index=1 のとき、内側の要素が1つもないため [1,1] を返します。' +
+                        '内側要素の計算式 range(1, 1) は空のため、両端の 1 だけになります。' +
+                        '例）_build_row(.., 1) → row_index==1 → return [1,1]。triangle = [[1],[1,1]] になります。',
+                    triangleState: [[1], [1, 1]],
+                    currentRowIndex: 1,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        rowIndex: 1,
+                        action: '基底条件: return [1,1]',
+                        triangle: '[[1],[1,1]]',
+                    },
+                },
+                {
+                    step: 5,
+                    title: '前行参照 → 内側を計算（row 2）',
+                    shortDesc: 'prev=[1,1] → inner=[2] → [1,2,1]',
+                    desc:
+                        'row_index=2 から汎用ロジックが動きます。前の行 prev=[1,1] を参照し、' +
+                        'リスト内包表記で内側の要素を計算します（prev[c-1]+prev[c]）。' +
+                        '例）col=1: prev[0]+prev[1]=1+1=2 → inner=[2] → [1]+[2]+[1]=[1,2,1]。',
+                    triangleState: [[1], [1, 1], [1, 2, 1]],
+                    currentRowIndex: 2,
+                    prevRow: [1, 1],
+                    innerVals: [2],
+                    varState: {
+                        rowIndex: 2,
+                        prev: '[1,1]',
+                        inner: '[2]',
+                        row: '[1,2,1]',
+                        triangle: '3行まで完成',
+                    },
+                },
+                {
+                    step: 6,
+                    title: '完成（全5行）',
+                    shortDesc: 'triangle = 5行すべて完成',
+                    desc:
+                        '同じ手順を row_index=3,4 にも繰り返し、三角形が完成します。' +
+                        'row_index=5 でループ条件 5<5 が偽になり、triangle を返します。' +
+                        '例）最終出力: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] ✅',
+                    triangleState: TRIANGLE_5,
+                    currentRowIndex: null,
+                    prevRow: null,
+                    innerVals: null,
+                    varState: {
+                        rowIndex: 5,
+                        condition: '5 < 5 → False → 終了',
+                        result: '[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]',
+                    },
+                },
+            ];
+
+            function TriangleDisplay({ triangleState, currentRowIndex, prevRow, innerVals }) {
+                if (triangleState.length === 0) {
+                    return (
+                        <div className="mt-3 flex items-center justify-center h-20 rounded-xl bg-slate-50 border border-slate-200 text-slate-400 text-sm">
+                            triangle = [] （まだ行なし）
+                        </div>
+                    );
+                }
+
+                const maxCols = triangleState[triangleState.length - 1].length;
+
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200">
+                        <div className="text-slate-500 text-xs font-semibold mb-2">
+                            🔺 triangle の現在の状態
+                        </div>
+                        <div className="flex flex-col items-center gap-1">
+                            {triangleState.map((row, ri) => {
+                                const isPrev =
+                                    prevRow !== null &&
+                                    ri === triangleState.length - 2 &&
+                                    prevRow !== null;
+                                const isCurrent =
+                                    currentRowIndex !== null && ri === currentRowIndex;
+                                return (
+                                    <div key={ri} className="flex gap-1">
+                                        {row.map((val, ci) => {
+                                            let bg = 'bg-slate-200 text-slate-600';
+                                            if (isCurrent) bg = 'bg-emerald-400 text-white';
+                                            else if (isPrev) bg = 'bg-sky-300 text-white';
+                                            return (
+                                                <span
+                                                    key={ci}
+                                                    className={['triangle-cell', bg].join(' ')}
+                                                >
+                                                    {val}
+                                                </span>
+                                            );
+                                        })}
+                                    </div>
+                                );
+                            })}
+                        </div>
+                        {(prevRow || innerVals) && (
+                            <div className="mt-2 flex flex-wrap gap-3 text-xs text-center justify-center">
+                                {prevRow && (
+                                    <span className="px-2 py-1 rounded bg-sky-100 text-sky-700">
+                                        <span className="font-semibold">prev</span> = [
+                                        {prevRow.join(', ')}]
+                                    </span>
+                                )}
+                                {innerVals && (
+                                    <span className="px-2 py-1 rounded bg-amber-100 text-amber-700">
+                                        <span className="font-semibold">inner</span> = [
+                                        {innerVals.join(', ')}]
+                                    </span>
+                                )}
+                            </div>
+                        )}
+                    </div>
+                );
+            }
+
+            function VarPanel({ varState }) {
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-900 border border-slate-700 font-mono text-xs leading-6">
+                        <div className="text-slate-400 mb-1 font-sans text-xs font-semibold">
+                            🔍 現在の変数の状態
+                        </div>
+                        {Object.entries(varState).map(([k, v]) => (
+                            <div key={k}>
+                                <span className="text-sky-400">{k}</span>
+                                <span className="text-slate-400"> = </span>
+                                <span className="text-emerald-400">{String(v)}</span>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                const currentStepData = stepsData[activeStep - 1];
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* Step list */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-base font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const isActive = activeStep === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(s.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-xs mb-0.5',
+                                                    isActive ? 'text-emerald-800' : 'text-teal-700',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}
+                                            </div>
+                                            <div
+                                                className={[
+                                                    'font-semibold',
+                                                    isActive
+                                                        ? 'text-emerald-900'
+                                                        : 'text-slate-700',
+                                                ].join(' ')}
+                                            >
+                                                {s.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs mt-0.5">
+                                                {s.shortDesc}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* Detail panel */}
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← Step {activeStep - 1} では「{stepsData[activeStep - 2].title}
+                                    」を行いました
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <div className="text-xs font-bold text-emerald-600 mb-1">
+                                    Step {currentStepData.step}
+                                </div>
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
+                                    {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <TriangleDisplay
+                                triangleState={currentStepData.triangleState}
+                                currentRowIndex={currentStepData.currentRowIndex}
+                                prevRow={currentStepData.prevRow}
+                                innerVals={currentStepData.innerVals}
+                            />
+
+                            <VarPanel varState={currentStepData.varState} />
+
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-50 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-app')).render(<StepsApp />);
+
+            // Re-highlight after React renders
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 300);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index d9702332..51546df8 100644
--- a/public/index.html
+++ b/public/index.html
@@ -2,6 +2,8 @@
 <html lang="ja">
 <head>
     <meta charset="UTF-8">
+    <meta name="generator" content="generate_index.py">
+    <!-- AUTO_GENERATED: DO NOT EDIT THIS FILE DIRECTLY. USE generate_index.py TO REGENERATE. -->
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Algorithm Study Lab</title>
     <link rel="preconnect" href="https://fonts.googleapis.com">
@@ -416,7 +418,7 @@ <h1 class="site-title">
             🧪 Algorithm Study
             <span class="title-accent">Index</span>
         </h1>
-        <p class="site-subtitle">177 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">178 interactive lessons across 6 domains</p>
     </header>
 
     <div class="search-container">
@@ -431,9 +433,9 @@ <h1 class="site-title">
 
     <div class="tabs" id="categoryTabs">
         <button class="tab-button active" data-category="all" data-tab-target="All">
-            <span class="tab-icon">🌍</span> All <span class="tab-count">177</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">178</span>
         </button>
-        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">99</span></button>
+        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">100</span></button>
 <button type="button" class="tab-button" data-category="concurrency" data-tab-target="Concurrency"><span class="tab-icon">⚡</span> Concurrency <span class="tab-count">6</span></button>
 <button type="button" class="tab-button" data-category="datastructures" data-tab-target="DataStructures"><span class="tab-icon">🏗️</span> DataStructures <span class="tab-count">36</span></button>
 <button type="button" class="tab-button" data-category="javascript" data-tab-target="JavaScript"><span class="tab-icon">📜</span> JavaScript <span class="tab-count">14</span></button>
@@ -476,6 +478,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/110.%20Balanced%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 110 · Balanced Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/111.%20Minimum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/112.%20Path%20Sum/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 112 – Path Sum | 再帰DFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/112. Path Sum/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/118.%20Pascal%27s%20Triangle/claude%20sonnet%204.6%20adaptive/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 118 — Pascal&#x27;s Triangle</span></span><span class="file-path">Algorithm/Other/leetcode/118. Pascal&#x27;s Triangle/claude sonnet 4.6 adaptive/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -660,6 +663,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/110.%20Balanced%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 110 · Balanced Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/111.%20Minimum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/112.%20Path%20Sum/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 112 – Path Sum | 再帰DFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/112. Path Sum/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/118.%20Pascal%27s%20Triangle/claude%20sonnet%204.6%20adaptive/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 118 — Pascal&#x27;s Triangle</span></span><span class="file-path">Algorithm/Other/leetcode/118. Pascal&#x27;s Triangle/claude sonnet 4.6 adaptive/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -837,7 +841,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-05-12
+        Generated on 2026-05-13
     </footer>
 
     <script>