From deeaaabc08d6199056518b78d5f32b1c7033dd86 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 14 Mar 2026 20:16:22 +0900
Subject: [PATCH 1/4] Add LeetCode 88. Merge Sorted Array (Claude 4.6 Sonnet)
 implementations in Rust, Python, and TypeScript

---
 .../Merge_Sorted_Array_Python.md              |  129 ++
 .../Merge_Sorted_Array_Rust.md                |   98 ++
 .../Merge_Sorted_Array_TypeScript.md          |  102 ++
 .../88. Merge Sorted Array/README.md          |  338 ++++
 .../88. Merge Sorted Array/README_React.html  | 1433 +++++++++++++++++
 .../88. Merge Sorted Array/README_React.html  | 1433 +++++++++++++++++
 public/index.html                             |   10 +-
 7 files changed, 3539 insertions(+), 4 deletions(-)
 create mode 100644 Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md
 create mode 100644 Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md
 create mode 100644 Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md
 create mode 100644 Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md
 create mode 100644 Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
 create mode 100644 public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html

diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md
new file mode 100644
index 00000000..404b7b40
--- /dev/null
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
@@ -0,0 +1,129 @@
+## 1. 問題分析結果
+
+### 競技プログラミング視点
+
+`nums1` の末尾から逆順に埋める3ポインタ法が最適。CPython では `list` のインデックスアクセスは O(1) の C 実装であり、追加リスト生成ゼロ・ヒープアロケーションゼロで O(m+n) を達成できます。
+
+### 業務開発視点
+
+LeetCode のシグネチャは `None` 返却の破壊的操作。Pylance 対応のため `List[int]` 型ヒントを厳密に付与し、`m`/`n` は `int` として明示します。エッジケース（`n == 0`）は早期リターンで明示的に処理します。
+
+### Python特有分析
+
+- `list.__setitem__` は C レイヤーで動作し、純粋な Python ループでも高速
+- `nums1[k], i, j, k` のローカル変数参照はグローバル参照より高速（LOAD_FAST）
+- 競技版では `while` + インデックス直接操作が最速（イテレータ生成コスト不要）
+- `nums1[:j+1] = nums2[:j+1]` のスライス代入は C の `memmove` 相当で残余コピーを一括処理可能
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+| アプローチ             | 時間計算量       | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用 | CPython最適化       | 備考                      |
+| ---------------------- | ---------------- | ---------- | ---------------- | ------ | ------------------ | ------------------- | ------------------------- |
+| 後ろから3ポインタ      | O(m+n)           | O(1)       | 低               | ★★★    | なし               | 適                  | 追加アロケーションなし ✅ |
+| コピー後 `list.sort()` | O((m+n)log(m+n)) | O(1)       | 最低             | ★★★    | なし               | 適（Timsort C実装） | 競技次善策                |
+| `heapq.merge` + 展開   | O(m+n)           | O(m+n)     | 低               | ★★☆    | heapq              | 適                  | 一時リスト生成が発生      |
+
+---
+
+## 3. 採用アルゴリズムと根拠
+
+- **選択**: 後ろからの3ポインタマージ（業務版・競技版ともに同一戦略）
+- **Python最適化戦略**: 残余コピーをスライス代入 `nums1[:j+1] = nums2[:j+1]` に置換することで、CPython 内部の `memmove` が発動し逐次代入より高速
+- **トレードオフ**: スライス代入は一時オブジェクトを1個生成するが定数サイズであり実質 O(1) の追加コスト
+
+---
+
+## 4. 実装パターン
+
+```python
+# Runtime 0 ms
+# Beats 100.00%
+# Memory 19.42 MB
+# Beats 35.99%
+from typing import List
+
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        """
+        2つのソート済み配列を nums1 にインプレースでマージする。
+        後ろから走査する3ポインタ法により O(m+n) 時間・O(1) 追加空間を実現。
+
+        不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない。
+            初期値 k - i = n >= 0 が各イテレーションで保持される。
+
+        Args:
+            nums1: マージ先リスト（長さ m+n、末尾 n 要素は 0 で埋められている）
+            m:     nums1 の有効要素数
+            nums2: マージ元リスト（長さ n）
+            n:     nums2 の要素数
+
+        Time Complexity:  O(m + n)
+        Space Complexity: O(1)  ※スライス代入の一時オブジェクト除く
+        """
+        # ── 業務開発版 ─────────────────────────────────────────────
+        # n == 0 のとき nums1 は既に完成しているため早期リターン
+        if n == 0:
+            return
+
+        i: int = m - 1      # nums1 有効末尾ポインタ
+        j: int = n - 1      # nums2 末尾ポインタ
+        k: int = m + n - 1  # 書き込み位置ポインタ
+
+        # どちらかが尽きるまで大きい方を末尾に書き込む
+        while i >= 0 and j >= 0:
+            if nums1[i] >= nums2[j]:
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                nums1[k] = nums2[j]
+                j -= 1
+            k -= 1
+
+        # nums2 の残余要素を一括スライス代入（CPython の memmove 相当で高速）
+        # nums1 の残余は既に正しい位置にあるため操作不要
+        if j >= 0:
+            nums1[: j + 1] = nums2[: j + 1]
+
+    def merge_competitive(
+        self, nums1: List[int], m: int, nums2: List[int], n: int
+    ) -> None:
+        """
+        競技プログラミング向け最適化実装。
+        ローカル変数へのキャッシュで LOAD_FAST を最大活用。
+
+        Time Complexity:  O(m + n)
+        Space Complexity: O(1)
+        """
+        # ローカル変数へのバインドで属性ルックアップを排除
+        i, j, k = m - 1, n - 1, m + n - 1
+
+        while i >= 0 and j >= 0:
+            if nums1[i] >= nums2[j]:
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                nums1[k] = nums2[j]
+                j -= 1
+            k -= 1
+
+        if j >= 0:
+            nums1[: j + 1] = nums2[: j + 1]
+```
+
+---
+
+## Python特有の追加考慮事項
+
+**スライス代入 `nums1[:j+1] = nums2[:j+1]` の内部動作**
+
+CPython の `list_ass_slice` は `memmove` で連続メモリを一括コピーします。逐次 `while` ループに比べてインタープリタのディスパッチコストを排除でき、残余要素が多いほど効果的です。
+
+**`LOAD_FAST` 最適化（競技版）**
+
+Python のバイトコードにおいて、メソッド内のローカル変数アクセス (`LOAD_FAST`) はグローバル変数アクセス (`LOAD_GLOBAL`) より約2倍高速です。`nums1`, `nums2` は引数として自動的にローカルスコープに入るため、競技版では追加のキャッシュは不要。カウンタ変数 `i`, `j`, `k` も同様です。
+
+**Pylance 型安全性**
+
+`List[int]` を `from typing import List` で明示し、戻り値を `None` と宣言することで Pylance の strict モードでも警告ゼロを維持します。Python 3.9 以降では `list[int]` の組み込み記法も使用可能ですが、LeetCode の CPython 3.11 環境では `from typing import List` が最も互換性の高い記述です。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md
new file mode 100644
index 00000000..91bb171f
--- /dev/null
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
@@ -0,0 +1,98 @@
+## 1. 問題の分析
+
+**競技プログラミング視点での分析**
+
+`nums1`の末尾から逆順に埋めていく「後ろからマージ」戦略が最適です。追加アロケーションなしでインプレース処理でき、時間 O(m+n)・空間 O(1) が実現できます。前から埋めると上書きが発生するため、後ろからスキャンするのが核心です。
+
+**業務開発視点での分析**
+
+LeetCode の関数シグネチャは `&mut Vec<i32>` の受け渡しを強制しますが、内部では `usize` インデックスと `saturating_sub` を活用し、符号なし整数のアンダーフローをコンパイル時に潰します。`i32 → usize` の変換は `as usize` で確実に行います。
+
+**Rust特有の考慮点**
+
+- `i32` 引数 `m`, `n` は LeetCode の制約上 `0..=200` に収まるため、`as usize` キャストは安全
+- `checked_sub` や `saturating_sub` でインデックス計算のパニックを防止
+- 借用は `&mut Vec<i32>` のスライス操作に集約し、ライフタイムを単純化
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+| アプローチ                  | 時間計算量       | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                      |
+| --------------------------- | ---------------- | ---------- | -------------- | ------ | ------ | ------------------------- |
+| 後ろからマージ（3ポインタ） | O(m+n)           | O(1)       | 低             | 高     | 高     | 追加アロケーションなし ✅ |
+| 前からコピー後ソート        | O((m+n)log(m+n)) | O(1)       | 低             | 高     | 高     | 標準の `.sort()` 利用可   |
+| 一時バッファにコピー        | O(m+n)           | O(m)       | 低             | 高     | 中     | Vec への clone が発生     |
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択**: 後ろからの 3 ポインタマージ
+- **理由**: O(m+n) の時間・O(1) の追加空間。末尾から書き込むことで`nums1`の有効領域を上書きせずマージできる。Rustの所有権モデルと完全に親和的（`split_at_mut` 不要、単純なインデックスアクセス）。
+- **最適化ポイント**: `usize` 算術のみでスタック完結、ヒープアロケーションゼロ、ループ本体は比較1回＋代入1回のみ
+
+---
+
+以下に図解でアルゴリズムの動作を示します：
+
+![alt text](image.png)
+
+## 4. 実装コード
+
+```rust
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.29 MB
+// Beats 25.52%
+impl Solution {
+    pub fn merge(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) {
+        // i32 → usize への安全なキャスト（制約: 0 <= m, n <= 200）
+        let mut i = m as usize; // nums1 の有効要素末尾（排他）
+        let mut j = n as usize; // nums2 の末尾（排他）
+        let mut k = (m + n) as usize; // 書き込み位置末尾（排他）
+
+        // 3ポインタを後ろから前へ動かしながらマージ
+        //
+        // 不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない
+        //
+        // # Complexity
+        // - Time:  O(m + n) — 各要素をちょうど1回だけ参照・書き込み
+        // - Space: O(1)     — 追加ヒープアロケーションなし
+        while i > 0 && j > 0 {
+            k -= 1;
+            if nums1[i - 1] >= nums2[j - 1] {
+                nums1[k] = nums1[i - 1];
+                i -= 1;
+            } else {
+                nums1[k] = nums2[j - 1];
+                j -= 1;
+            }
+        }
+
+        // nums2 の残余要素を nums1 の先頭へコピー
+        // （nums1 の残余は既に正しい位置にあるのでコピー不要）
+        while j > 0 {
+            k -= 1;
+            nums1[k] = nums2[j - 1];
+            j -= 1;
+        }
+    }
+}
+```
+
+---
+
+## Rust 固有の最適化観点
+
+**`usize` 算術によるゼロコスト安全性**
+
+LeetCode の引数は `i32` ですが、配列インデックスは `usize` が必要です。制約上 `0 <= m, n <= 200` かつ `1 <= m + n <= 200` が保証されるため `as usize` キャストは常に安全。`i -= 1` 等のデクリメントは `i > 0` ガード後にのみ実行されるため、`usize` アンダーフロー（パニック）は構造的に排除されています。
+
+**借用規則との親和性**
+
+`nums1` と `nums2` を同時に `&mut` で保持しますが、それぞれ独立した `Vec` への借用であるため借用チェッカーを通過します。`split_at_mut` 等の特別な操作は不要です。
+
+**ループ本体の最小化**
+
+比較1回・代入1回・デクリメント1回のみ。イテレータ抽象化より命令型ループが適切なケースで、コンパイラは確実にインライン展開・SIMD 最適化を適用できます。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md
new file mode 100644
index 00000000..db82ecf2
--- /dev/null
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
@@ -0,0 +1,102 @@
+## 1. 問題の分析
+
+**競技プログラミング視点での分析**
+
+Rustの回答と同様に、後ろからの3ポインタマージが最適解です。TypeScriptでは `number` 型が IEEE 754 倍精度浮動小数点のため整数演算に余分なオーバーヘッドはなく、インデックス操作はV8エンジンがSMI（Small Integer）最適化を適用します。
+
+**業務開発視点での分析**
+
+LeetCode のシグネチャは `void` 返却の破壊的操作ですが、TypeScript の `strict` モードと `readonly` による境界を意識した実装で保守性を担保します。インデックス境界違反は実行時ではなくロジック上で構造的に防止します。
+
+**TypeScript特有の考慮点**
+
+- `number` 型インデックスの減算は `0` ガード後にのみ実行し、負数インデックスアクセスを防止
+- `as const` は不要（可変配列操作のため）
+- V8 の Packed SMI Arrays 最適化を維持するため、配列の型を混在させない
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+| アプローチ                  | 時間計算量       | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                       |
+| --------------------------- | ---------------- | ---------- | ------------ | -------- | ------ | -------------------------- |
+| 後ろからマージ（3ポインタ） | O(m+n)           | O(1)       | 低           | 高       | 高     | 追加アロケーションなし ✅  |
+| コピー後 `.sort()`          | O((m+n)log(m+n)) | O(1)       | 最低         | 高       | 最高   | 比較関数必須・競技では次善 |
+| 一時バッファにコピー        | O(m+n)           | O(m)       | 低           | 高       | 中     | スプレッド構文でヒープ確保 |
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択**: 後ろからの3ポインタマージ
+- **理由**: O(m+n) 時間・O(1) 追加空間。末尾書き込みにより有効要素の上書きが構造的に不可能。TypeScript の `number` 型インデックスは整数として扱われ、V8 の SMI 最適化が全体に適用される
+- **TypeScript特有の最適化ポイント**: 変数を `let` で宣言し型推論に委ねることでコンパイラの最適化ヒントを最大化。`const` で宣言すると再代入不可になるため、カウンタ変数は `let` が適切
+
+---
+
+## 4. 実装コード
+
+```typescript
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 54.72 MB
+// Beats 93.68%
+
+/**
+ * 2つのソート済み配列を nums1 にインプレースでマージする。
+ * 後ろから走査する3ポインタ法により、追加アロケーションなしで O(m+n) を実現。
+ *
+ * @param nums1 - マージ先配列（長さ m+n、末尾 n 要素は 0 で埋められている）
+ * @param m     - nums1 の有効要素数
+ * @param nums2 - マージ元配列（長さ n）
+ * @param n     - nums2 の要素数
+ *
+ * @complexity Time: O(m + n), Space: O(1)
+ *
+ * 不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない
+ *   証明: 各イテレーションで k と (i または j) が同時に 1 減少する。
+ *         初期値 k = m + n - 1, i = m - 1 より k - i = n >= 0 が保持される。
+ */
+function merge(nums1: number[], m: number, nums2: number[], n: number): void {
+    // 各ポインタは「次に参照すべき要素のインデックス」を表す（0-based）
+    let i: number = m - 1; // nums1 有効末尾
+    let j: number = n - 1; // nums2 末尾
+    let k: number = m + n - 1; // 書き込み位置末尾
+
+    // どちらかの配列が空になるまで大きい方を末尾から書き込む
+    while (i >= 0 && j >= 0) {
+        if (nums1[i] >= nums2[j]) {
+            nums1[k] = nums1[i];
+            i--;
+        } else {
+            nums1[k] = nums2[j];
+            j--;
+        }
+        k--;
+    }
+
+    // nums2 の残余要素をコピー
+    // （nums1 の残余は既に正しい位置にあるため操作不要）
+    while (j >= 0) {
+        nums1[k] = nums2[j];
+        j--;
+        k--;
+    }
+}
+```
+
+---
+
+## TypeScript固有の最適化観点
+
+**V8 エンジンと配列最適化**
+
+`nums1` は `number[]` として渡されるため、V8 は内部的に `PACKED_SMI_ELEMENTS` または `PACKED_DOUBLE_ELEMENTS` として最適化されます。要素の書き込みを `nums1[k] = value` の単純代入に統一することで、この最適化が維持され `HOLEY_ELEMENTS` への降格を防ぎます。
+
+**型安全インデックス管理**
+
+`i >= 0` / `j >= 0` のガードにより、TypeScript の `strict: true` 環境でも `number` 型のインデックスが負にならないことが実行フロー上保証されます。`noUncheckedIndexedAccess` を有効にした場合でも、ガード後の `nums1[i]` は `number` として安全にアクセスできます。
+
+**`while` vs イテレータ**
+
+`.reduce()` や `.forEach()` はコールバック関数のクロージャ生成コストが発生します。本問題のようなインプレース操作かつ複数ポインタを連動させるケースでは、命令型 `while` ループが最も直接的で V8 の JIT 最適化が効きやすい選択です。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md
new file mode 100644
index 00000000..44ea522f
--- /dev/null
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
@@ -0,0 +1,338 @@
+# Merge Sorted Array - In-place 3-Pointer Merge from the Right
+
+---
+
+## 目次（Table of Contents）
+
+- [概要](#overview)
+- [アルゴリズム要点 TL;DR](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython 最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">概要</h2>
+
+### 問題要約
+
+**LeetCode 88 – Merge Sorted Array**
+
+非減少順にソートされた 2 つの整数配列 `nums1`（有効要素数 `m`）と `nums2`（長さ `n`）を、
+`nums1` の末尾 `n` 要素のゼロ領域を利用して **インプレース** にマージし、
+結果を `nums1` に非減少順で格納する。
+
+### 要件
+
+| 項目   | 内容                                                                                                                   |
+| ------ | ---------------------------------------------------------------------------------------------------------------------- |
+| 戻り値 | `None`（`nums1` を破壊的に変更）                                                                                       |
+| 正当性 | 全要素が非減少順に並ぶこと                                                                                             |
+| 安定性 | 等値要素の相対順序は問わない（仕様上要求なし）                                                                         |
+| 制約   | `nums1.length == m + n`, `nums2.length == n`, `0 ≤ m, n ≤ 200`, `1 ≤ m + n ≤ 200`, `-10^9 ≤ nums1[i], nums2[j] ≤ 10^9` |
+
+---
+
+<h2 id="tldr">アルゴリズム要点 TL;DR</h2>
+
+- **戦略**: `nums1` の末尾から走査する **3 ポインタ法**（後ろからマージ）
+- **データ構造**: 追加配列不要。`nums1` 自体をバッファとして再利用
+- **時間計算量**: O(m + n) — 各要素をちょうど 1 回参照・書き込み
+- **空間計算量**: O(1) — 追加ヒープアロケーションなし
+  （残余コピーのスライス代入は定数サイズの一時オブジェクト 1 個のみ）
+- **核心の不変条件**: 書き込みポインタ `k` は常に読み取りポインタ `i` 以上
+  → 未処理の `nums1` 要素を上書きしない
+- **後ろから書く理由**: 前から比較すると `nums1` の有効要素を上書きしてしまうため逆順が安全
+
+---
+
+<h2 id="figures">図解</h2>
+
+### フローチャート
+
+```mermaid
+flowchart TD
+  Start[Start merge] --> Init[Set i = m-1, j = n-1, k = m+n-1]
+  Init --> EarlyExit{n == 0}
+  EarlyExit -- Yes --> Done[Return immediately]
+  EarlyExit -- No --> Loop{i &ge; 0 and j &ge; 0}
+  Loop -- No --> Remain{j &ge; 0}
+  Loop -- Yes --> Cmp{nums1 i &ge; nums2 j}
+  Cmp -- Yes --> WriteN1[nums1 k = nums1 i, i -= 1]
+  Cmp -- No --> WriteN2[nums1 k = nums2 j, j -= 1]
+  WriteN1 --> DecK1[k -= 1]
+  WriteN2 --> DecK2[k -= 1]
+  DecK1 --> Loop
+  DecK2 --> Loop
+  Remain -- Yes --> Slice[nums1 0..j+1 = nums2 0..j+1]
+  Remain -- No --> Done2[Return]
+  Slice --> Done2
+```
+
+> 後ろから比較して大きい方を末尾（`k`）に書き込む。どちらかが尽きたら `nums2` の残余を先頭スライスへ一括コピー。
+
+---
+
+### データフロー図（ステップ別状態遷移）
+
+```mermaid
+graph LR
+  subgraph Initial_State
+    N1A["nums1: [1, 2, 3, 0, 0, 0]  m=3"]
+    N2A["nums2: [2, 5, 6]  n=3"]
+  end
+  subgraph Step1
+    S1["k=5: compare nums1[2]=3 vs nums2[2]=6  write 6"]
+  end
+  subgraph Step2
+    S2["k=4: compare nums1[2]=3 vs nums2[1]=5  write 5"]
+  end
+  subgraph Step3
+    S3["k=3: compare nums1[2]=3 vs nums2[0]=2  write 3"]
+  end
+  subgraph Step4
+    S4["k=2: compare nums1[1]=2 vs nums2[0]=2  write 2 from nums1"]
+  end
+  subgraph Step5
+    S5["k=1: compare nums1[0]=1 vs nums2[0]=2  write 2 from nums2"]
+  end
+  subgraph Step6
+    S6["j=-1 exhausted  copy nums1 remaining in place"]
+  end
+  subgraph Result
+    R["nums1: [1, 2, 2, 3, 5, 6]"]
+  end
+  N1A --> S1
+  N2A --> S1
+  S1 --> S2 --> S3 --> S4 --> S5 --> S6 --> R
+```
+
+> 各ステップで大きい方の値が `k` の位置に書き込まれ、対応するポインタと `k` が 1 ずつ減少する。
+
+---
+
+<h2 id="correctness">正しさのスケッチ</h2>
+
+### 不変条件
+
+書き込みポインタ `k` と `nums1` の読み取りポインタ `i` について、以下が常に成立する：
+
+```
+k - i = (m + n - 1 - step_count) - (m - 1 - i_decrements)
+      = n - j_decrements ≥ 0
+```
+
+各イテレーションで `k` は必ず 1 減少し、`i` か `j` のどちらかも 1 減少する。
+`i` が減少するとき `k - i` は変わらず、`j` が減少するとき `k - i` は 1 増加する。
+よって `k ≥ i` が保持され、**未処理の `nums1` 要素を上書きしない**。
+
+### 網羅性
+
+- `while` ループ終了後、`i < 0` または `j < 0` のどちらかが成立
+- `j < 0` の場合：`nums2` は全て書き込み済み、`nums1` の残余は正しい位置にある（移動不要）
+- `j ≥ 0` の場合：`nums2[:j+1]` を `nums1[:j+1]` にスライス代入して完了
+
+### 基底条件（エッジケース）
+
+| 条件     | 処理                                          |
+| -------- | --------------------------------------------- |
+| `n == 0` | 早期リターン、`nums1` はそのまま              |
+| `m == 0` | `while` の `i >= 0` が即 False → 残余コピーへ |
+
+### 終了性
+
+`i` と `j` はループごとに必ず 1 以上減少し、非負整数であるため有限ステップで終了する。
+
+---
+
+<h2 id="complexity">計算量</h2>
+
+| 観点       | 計算量   | 説明                                       |
+| ---------- | -------- | ------------------------------------------ |
+| 時間計算量 | O(m + n) | 各要素を最大 1 回比較・書き込み            |
+| 空間計算量 | O(1)     | スライス代入の一時オブジェクトは定数サイズ |
+
+### In-place vs Pure 比較
+
+| 実装方針                      | 時間              | 空間     | 備考                                    |
+| ----------------------------- | ----------------- | -------- | --------------------------------------- |
+| 本実装（後ろから 3 ポインタ） | O(m+n)            | **O(1)** | ✅ 最適                                 |
+| 前から + 一時バッファ         | O(m+n)            | O(m)     | `nums1[:m]` を `list()` でコピー        |
+| `nums1 + nums2` 後 `.sort()`  | O((m+n) log(m+n)) | O(1)     | Timsort は C 実装で高速だが計算量は劣る |
+| `heapq.merge` + スライス代入  | O(m+n)            | O(m+n)   | 一時リストが発生                        |
+
+---
+
+<h2 id="impl">Python 実装</h2>
+
+```python
+from __future__ import annotations
+
+from typing import List
+
+
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        """
+        2 つのソート済み配列を nums1 にインプレースでマージする。
+
+        後ろから走査する 3 ポインタ法により O(m+n) 時間・O(1) 追加空間を実現。
+
+        不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない。
+            初期値 k - i = n >= 0 が各イテレーションで保持される。
+
+        Args:
+            nums1: マージ先リスト（長さ m+n、末尾 n 要素は 0 で埋め済み）
+            m:     nums1 の有効要素数
+            nums2: マージ元リスト（長さ n）
+            n:     nums2 の要素数
+
+        Returns:
+            None（nums1 を破壊的に変更）
+
+        Time Complexity:  O(m + n)
+        Space Complexity: O(1)
+        """
+        # ── エッジケース: nums2 が空なら nums1 はそのまま ──────────────────
+        if n == 0:
+            return
+
+        # ── 3 ポインタ初期化 ────────────────────────────────────────────────
+        i: int = m - 1      # nums1 有効末尾ポインタ（読み取り）
+        j: int = n - 1      # nums2 末尾ポインタ（読み取り）
+        k: int = m + n - 1  # 書き込み位置ポインタ（後ろから前へ）
+
+        # ── メインループ: 両配列が残っている間、大きい方を末尾へ書き込む ──
+        while i >= 0 and j >= 0:
+            if nums1[i] >= nums2[j]:
+                # nums1 の要素が大きい（または等しい）→ nums1[i] を書き込み
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                # nums2 の要素が大きい → nums2[j] を書き込み
+                nums1[k] = nums2[j]
+                j -= 1
+            k -= 1
+
+        # ── 残余処理: nums2 が残っている場合のみスライス代入で一括コピー ──
+        # nums1 の残余は既に正しい位置にあるため移動不要
+        if j >= 0:
+            # CPython の list_ass_slice は memmove 相当で逐次代入より高速
+            nums1[: j + 1] = nums2[: j + 1]
+```
+
+---
+
+<h2 id="cpython">CPython 最適化ポイント</h2>
+
+### 1. スライス代入による残余コピーの高速化
+
+```python
+nums1[: j + 1] = nums2[: j + 1]
+```
+
+CPython の `list.__setitem__` スライス版は内部で `list_ass_slice` を呼び出し、
+`memmove` 相当の C レイヤーのメモリコピーが走る。
+逐次 `while j >= 0: nums1[k] = nums2[j]; j -= 1; k -= 1` より
+**インタープリタのバイトコードディスパッチ回数を大幅に削減**できる。
+
+### 2. LOAD_FAST によるローカル変数の高速アクセス
+
+| アクセス種別                                    | バイトコード  | 速度                 |
+| ----------------------------------------------- | ------------- | -------------------- |
+| ローカル変数（`i`, `j`, `k`, `nums1`, `nums2`） | `LOAD_FAST`   | 高速（辞書探索なし） |
+| グローバル変数                                  | `LOAD_GLOBAL` | やや低速             |
+| 属性アクセス（`self.xxx`）                      | `LOAD_ATTR`   | 最も低速             |
+
+本実装では全カウンタがメソッドのローカルスコープに収まるため、
+`LOAD_FAST` が全アクセスに適用される。
+
+### 3. 早期リターンによる不要な処理の排除
+
+```python
+if n == 0:
+    return
+```
+
+`n == 0` の場合はループに入らず即リターン。
+条件チェックのオーバーヘッドが極めて小さい。
+
+### 4. 型ヒントとランタイムの分離
+
+`from __future__ import annotations` を使用することで、
+型アノテーションの評価が **遅延評価（文字列化）** になり、
+実行時のインポートオーバーヘッドを最小化する。
+
+---
+
+<h2 id="edgecases">エッジケースと検証観点</h2>
+
+| ケース                                | 入力例                                      | 期待出力       | 対応箇所                               |
+| ------------------------------------- | ------------------------------------------- | -------------- | -------------------------------------- |
+| `nums2` が空（`n=0`）                 | `nums1=[1], m=1, nums2=[], n=0`             | `[1]`          | 早期 `return`                          |
+| `nums1` が空（`m=0`）                 | `nums1=[0], m=0, nums2=[1], n=1`            | `[1]`          | `while i>=0` が即 False → 残余コピー   |
+| 全要素が同値                          | `nums1=[2,2,0,0], m=2, nums2=[2,2], n=2`    | `[2,2,2,2]`    | `>=` の分岐で正しく処理                |
+| `nums2` の全要素が `nums1` より大きい | `nums1=[1,2,0,0], m=2, nums2=[3,4], n=2`    | `[1,2,3,4]`    | `while` 終了後 `j < 0` → 何もしない    |
+| `nums1` の全要素が `nums2` より大きい | `nums1=[3,4,0,0], m=2, nums2=[1,2], n=2`    | `[1,2,3,4]`    | `while` 終了後 `j >= 0` → スライス代入 |
+| 負の数を含む                          | `nums1=[-3,-1,0,0], m=2, nums2=[-2,0], n=2` | `[-3,-2,-1,0]` | 整数比較なので問題なし                 |
+| 最大制約                              | `m=n=100`                                   | 正しくマージ   | O(m+n) で余裕                          |
+
+### 静的解析観点（Pylance strict mode）
+
+- `List[int]` 型ヒントにより `nums1[k]` への `int` 代入が型安全
+- `-> None` 明示により暗黙的な `None` 返却が警告なし
+- `from __future__ import annotations` で前方参照の問題を回避
+
+---
+
+<h2 id="faq">FAQ</h2>
+
+**Q1. なぜ前からではなく後ろからマージするのか？**
+
+前からマージすると、`nums1` の有効要素（インデックス `0..m-1`）を上書きしてしまう。
+後ろからマージすれば書き込み位置 `k` が常に `i` 以上になるため、
+未処理の要素を破壊することなくインプレース操作が成立する。
+
+**Q2. `nums1` の残余（`i >= 0`）もコピーが必要では？**
+
+不要。`nums1` の残余要素は既に正しい位置（`nums1[0..i]`）にあり、
+後ろからマージ済みの要素と連続しているため、移動の必要がない。
+
+**Q3. スライス代入 `nums1[:j+1] = nums2[:j+1]` で一時オブジェクトは発生しないのか？**
+
+右辺 `nums2[:j+1]` がリストスライスとして一時的に生成される（O(j) サイズ）。
+ただし `j` は最大でも `n-1` であり定数スケールのため、実質 O(1) の追加コスト。
+逐次代入に比べてバイトコードのオーバーヘッドを削減できるため、実用上は高速。
+
+**Q4. `.sort()` を使う方法ではダメなのか？**
+
+```python
+# 次善策: O((m+n) log(m+n)) だが実装が最短
+nums1[m:] = nums2[:n]
+nums1.sort()
+```
+
+正しく動作するが、時間計算量が O((m+n) log(m+n)) に劣化する。
+フォローアップ要件「O(m+n) で解け」を満たさない。
+競技では時間制限に収まるケースが多いが、最適解ではない。
+
+**Q5. `heapq.merge` を使う方法は？**
+
+```python
+import heapq
+nums1[m:] = nums2  # 末尾をコピー
+merged = list(heapq.merge(nums1[:m], nums2))
+nums1[:] = merged
+```
+
+O(m+n) だが一時リストが O(m+n) の追加空間を消費する。
+空間計算量の観点で本実装（O(1)）に劣る。
+
+**Q6. 等値要素の扱いはどうなるか？**
+
+`nums1[i] >= nums2[j]` の条件により、等値の場合は `nums1` 側が優先される。
+問題仕様上、安定性（相対順序の保持）は要求されていないため、どちらでも正解。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
new file mode 100644
index 00000000..05c3723f
--- /dev/null
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -0,0 +1,1433 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 88 – Merge Sorted Array</title>
+        <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
+        <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></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"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-typescript.min.js"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-rust.min.js"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"
+            defer
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"
+            defer
+        ></script>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;600&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Outfit', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .code-toolbar > .toolbar {
+                top: 0.6em;
+                right: 0.8em;
+                opacity: 1 !important;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+                box-shadow: none !important;
+                text-shadow: none !important;
+            }
+            .code-toolbar > .toolbar .toolbar-item button:hover,
+            .code-toolbar > .toolbar .toolbar-item a:hover {
+                background: #059669 !important;
+                color: white !important;
+            }
+            pre[class*='language-'] {
+                border-radius: 12px;
+                font-size: 13px;
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen p-4 md:p-8">
+        <div class="max-w-6xl mx-auto">
+            <!-- ═══ HEADER ═══ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.14)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-3">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 88</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"
+                        >Two Pointers</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.5rem] font-black text-teal-900 mb-1 leading-tight">
+                    Merge Sorted Array
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    後ろからの 3 ポインタマージ &mdash; O(m+n) インプレース実装
+                </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
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══ OVERVIEW ═══ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-7">
+                    <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(m+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(1)</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">
+                            3 Pointers
+                        </div>
+                        <div class="text-xs mt-1">使用ポインタ数</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">
+                            In-place
+                        </div>
+                        <div class="text-xs mt-1">操作種別</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div>
+                        <h3 class="text-teal-800 font-bold text-lg mb-3">問題設定</h3>
+                        <p class="text-slate-600 text-sm leading-7">
+                            ソート済み配列
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono"
+                                >nums1</code
+                            >（有効要素
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono">m</code>
+                            個、末尾
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono">n</code>
+                            個はゼロ埋め）と
+                            <code class="bg-sky-50 text-sky-800 px-1 rounded mono">nums2</code
+                            >（<code class="bg-sky-50 text-sky-800 px-1 rounded mono">n</code>
+                            個）を
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono"
+                                >nums1</code
+                            >
+                            にインプレースでマージし、非減少順に並べる。
+                        </p>
+                        <div
+                            class="mt-4 rounded-xl p-4 bg-slate-50 border border-slate-200 mono text-sm"
+                        >
+                            <p class="text-xs text-slate-400 mb-1">入力</p>
+                            <p class="text-slate-700">
+                                nums1 = [1,2,3,<span class="text-slate-400">0,0,0</span>], m = 3
+                            </p>
+                            <p class="text-slate-700">nums2 = [2,5,6], n = 3</p>
+                            <p class="text-xs text-slate-400 mt-3 mb-1">出力</p>
+                            <p class="font-bold text-emerald-700">[1, 2, 2, 3, 5, 6]</p>
+                        </div>
+                    </div>
+                    <div>
+                        <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
+                        <ul class="space-y-3 text-sm text-slate-600">
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">後ろから書く</strong
+                                    >：前から書くと有効要素を上書きするため、末尾
+                                    <span class="mono bg-amber-50 text-amber-700 px-1 rounded"
+                                        >k = m+n-1</span
+                                    >
+                                    から書き込む</span
+                                >
+                            </li>
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">不変条件 k ≥ i</strong
+                                    >：書き込みポインタが読み取りポインタを常に追い越さないため、未処理要素を上書きしない</span
+                                >
+                            </li>
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">残余は nums2 のみ</strong
+                                    >：nums1 の残余は既に正しい位置にある。nums2
+                                    の残りのみスライス代入で処理</span
+                                >
+                            </li>
+                        </ul>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ═══ STEPS (React mount point) ═══ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="react-steps"></div>
+            </section>
+
+            <!-- ═══ CODE (React mount point) ═══ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    実装コード
+                </h2>
+                <div id="react-code"></div>
+            </section>
+
+            <!-- ═══ DIAGRAM (static HTML SVG, kebab-case attributes) ═══ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+                <div class="mt-4 overflow-x-auto">
+                    <!--
+        viewBox設計:
+        幅: 560px (center x=280)
+        全ボックス: x=60, width=440 (right edge x=500)
+        全テキスト: x=280, text-anchor="middle"
+        SVG属性: ケバブケース統一
+        最終要素下端: cy=587+ry=28=615 → viewBox高さ=660
+      -->
+                    <svg
+                        viewBox="0 0 560 682"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Merge Sorted Array algorithm 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-arrowGreen"
+                                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-arrowRed"
+                                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-arrowPurple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#a855f7" />
+                            </marker>
+                        </defs>
+
+                        <!-- 1. 開始 (ellipse) cy=50, ry=28, bottom=78 -->
+                        <ellipse
+                            cx="280"
+                            cy="50"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="50"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="16"
+                            font-weight="bold"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="78"
+                            x2="280"
+                            y2="95"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 2. 初期化 rect: y=95, h=60, bottom=155 -->
+                        <rect
+                            x="60"
+                            y="95"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="117"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#0c4a6e"
+                        >
+                            ポインタを初期化
+                        </text>
+                        <text
+                            x="280"
+                            y="141"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#0369a1"
+                        >
+                            i = m-1 | j = n-1 | k = m+n-1
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="155"
+                            x2="280"
+                            y2="178"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 3. ループ条件 diamond: cy=203, half-w=140, half-h=27, top=176, bottom=230 -->
+                        <polygon
+                            points="280,176 420,203 280,230 140,203"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="199"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="bold"
+                            fill="#78350f"
+                        >
+                            i &ge; 0 かつ j &ge; 0 ?
+                        </text>
+
+                        <!-- YES label + arrow down -->
+                        <text
+                            x="292"
+                            y="246"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#059669"
+                            font-weight="bold"
+                        >
+                            YES
+                        </text>
+                        <line
+                            x1="280"
+                            y1="230"
+                            x2="280"
+                            y2="255"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- NO branch: right (420,203) → (530,203) → (530,522) → (502,522) -->
+                        <text
+                            x="428"
+                            y="196"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-weight="bold"
+                        >
+                            NO
+                        </text>
+                        <line
+                            x1="420"
+                            y1="203"
+                            x2="530"
+                            y2="203"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="530"
+                            y1="203"
+                            x2="530"
+                            y2="522"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="530"
+                            y1="522"
+                            x2="502"
+                            y2="522"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- 4. 比較・書き込み rect: y=255, h=115, bottom=370 (+20px で最終行に余白確保) -->
+                        <rect
+                            x="60"
+                            y="255"
+                            width="440"
+                            height="115"
+                            rx="10"
+                            fill="#f1f5f9"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="277"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#1e293b"
+                        >
+                            比較・書き込み
+                        </text>
+                        <line
+                            x1="80"
+                            y1="291"
+                            x2="480"
+                            y2="291"
+                            stroke="#cbd5e1"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="313"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            if nums1[i] &ge; nums2[j]:
+                        </text>
+                        <text
+                            x="280"
+                            y="334"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#059669"
+                        >
+                            nums1[k] = nums1[i]; i--
+                        </text>
+                        <text
+                            x="280"
+                            y="355"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#475569"
+                        >
+                            else: nums1[k] = nums2[j]; j--
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="370"
+                            x2="280"
+                            y2="388"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 5. k-- rect: y=388, h=44, bottom=432 -->
+                        <rect
+                            x="60"
+                            y="388"
+                            width="440"
+                            height="44"
+                            rx="10"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="410"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#0c4a6e"
+                        >
+                            k--
+                        </text>
+
+                        <!-- Loop back: (280,432) → (280,455) → (35,455) → (35,203) → (140,203) -->
+                        <path
+                            d="M 280,432 L 280,455 L 35,455 L 35,203 L 140,203"
+                            fill="none"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                            stroke-dasharray="6,3"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="17"
+                            y="350"
+                            text-anchor="middle"
+                            font-size="10"
+                            fill="#a855f7"
+                            font-weight="bold"
+                            transform="rotate(-90 17 350)"
+                        >
+                            ループバック
+                        </text>
+
+                        <!-- 6. nums2 残余スライスコピー rect: y=492, h=60, bottom=552 -->
+                        <rect
+                            x="60"
+                            y="492"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#f1f5f9"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="514"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#1e293b"
+                        >
+                            nums2 残余スライスコピー
+                        </text>
+                        <text
+                            x="280"
+                            y="537"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#475569"
+                        >
+                            nums1[:j+1] = nums2[:j+1]
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="552"
+                            x2="280"
+                            y2="578"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- 7. 終了 ellipse: cy=607, ry=28, bottom=635 → viewBox 682 で余白47px -->
+                        <ellipse
+                            cx="280"
+                            cy="607"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="607"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="16"
+                            font-weight="bold"
+                            fill="#065f46"
+                        >
+                            終了
+                        </text>
+                    </svg>
+                </div>
+                <div
+                    class="mt-6 p-5 rounded-xl bg-slate-50 border border-slate-200 text-sm text-slate-700 leading-8"
+                >
+                    <strong class="text-teal-800 text-base">フロー説明</strong><br />
+                    1. <strong>初期化</strong>：i = m-1（nums1 有効末尾）、j = n-1（nums2 末尾）、k
+                    = m+n-1（書き込み末尾）<br />
+                    2. <strong>ループ判定</strong>（黄ダイヤ）：i≥0 かつ j≥0
+                    の間ループ。どちらかが尽きたら
+                    <span class="text-red-600 font-bold">NO</span> で残余処理へ<br />
+                    3. <strong>比較・書き込み</strong>：nums1[i] と nums2[j] を比較し大きい方を
+                    nums1[k] に書き込み、対応するポインタを減算<br />
+                    4. <strong>k-- 後に紫破線でループ条件へ戻る</strong>（不変条件 k ≥ i を維持）<br />
+                    5. <strong>残余コピー</strong>：nums2 が残っていれば CPython の memmove
+                    相当のスライス代入で高速一括コピー
+                </div>
+            </section>
+
+            <!-- ═══ COMPLEXITY ═══ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+                <div class="overflow-x-auto">
+                    <table class="w-full text-sm text-left border-collapse">
+                        <thead>
+                            <tr class="bg-emerald-50">
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200 rounded-tr-lg"
+                                >
+                                    備考
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50/60 border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-emerald-700">
+                                    後ろから 3 ポインタ ✅
+                                </td>
+                                <td class="px-4 py-3 mono font-bold text-emerald-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono font-bold text-emerald-600">O(1)</td>
+                                <td class="px-4 py-3 text-slate-600">
+                                    最適解。追加アロケーションなし
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-slate-700">
+                                    コピー後 .sort()
+                                </td>
+                                <td class="px-4 py-3 mono text-slate-600">O((m+n) log(m+n))</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(1)</td>
+                                <td class="px-4 py-3 text-slate-600">実装最短だが計算量で劣る</td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-slate-700">
+                                    一時バッファ使用
+                                </td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m)</td>
+                                <td class="px-4 py-3 text-slate-600">
+                                    前からマージ可能だが空間を消費
+                                </td>
+                            </tr>
+                            <tr>
+                                <td class="px-4 py-3 font-semibold text-slate-700">heapq.merge</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 text-slate-600">一時リスト生成あり</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+                <div
+                    class="mt-5 p-5 rounded-xl bg-emerald-50 border border-emerald-200 text-sm text-slate-700 leading-7"
+                >
+                    <strong class="text-teal-800">不変条件の証明：</strong>
+                    初期値
+                    <code class="bg-white mono px-1 rounded text-emerald-700">k - i = n &ge; 0</code
+                    >。 各イテレーションで k は必ず 1 減少し、i か j のどちらかも 1 減少する。 i
+                    減少時は k - i が不変、j 減少時は k - i が 1 増加。
+                    <strong
+                        >よって k &ge; i が常に成立し、未処理の nums1 要素を上書きしない。</strong
+                    >
+                </div>
+            </section>
+        </div>
+        <!-- /max-w -->
+
+        <!-- ═══ REACT COMPONENTS ═══ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            // ─── Steps data ───────────────────────────────────────────────────────────
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '初期状態を確認',
+                    desc: 'nums1 = [1,2,3,0,0,0]（m=3）と nums2 = [2,5,6]（n=3）が入力。nums1 の末尾 3 要素（0）がマージ先バッファ。i=2, j=2, k=5 を設定する。',
+                    nums1: [1, 2, 3, 0, 0, 0],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 2,
+                    k: 5,
+                    lastK: -1,
+                    phase: 'init',
+                },
+                {
+                    step: 2,
+                    title: '比較: nums1[2]=3 vs nums2[2]=6',
+                    desc: '3 < 6 なので nums2[2]=6 を nums1[5] に書き込む。j-- → j=1, k-- → k=4。',
+                    nums1: [1, 2, 3, 0, 0, 6],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 1,
+                    k: 4,
+                    lastK: 5,
+                    phase: 'write_j',
+                },
+                {
+                    step: 3,
+                    title: '比較: nums1[2]=3 vs nums2[1]=5',
+                    desc: '3 < 5 なので nums2[1]=5 を nums1[4] に書き込む。j-- → j=0, k-- → k=3。',
+                    nums1: [1, 2, 3, 0, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 0,
+                    k: 3,
+                    lastK: 4,
+                    phase: 'write_j',
+                },
+                {
+                    step: 4,
+                    title: '比較: nums1[2]=3 vs nums2[0]=2',
+                    desc: '3 &ge; 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
+                    nums1: [1, 2, 3, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 1,
+                    j: 0,
+                    k: 2,
+                    lastK: 3,
+                    phase: 'write_i',
+                },
+                {
+                    step: 5,
+                    title: '比較: nums1[1]=2 vs nums2[0]=2',
+                    desc: '2 &ge; 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: 0,
+                    k: 1,
+                    lastK: 2,
+                    phase: 'write_i',
+                },
+                {
+                    step: 6,
+                    title: '比較: nums1[0]=1 vs nums2[0]=2',
+                    desc: '1 < 2 なので nums2[0]=2 を nums1[1] に書き込む。j-- → j=-1 でループ終了。',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: -1,
+                    k: 0,
+                    lastK: 1,
+                    phase: 'write_j',
+                },
+                {
+                    step: 7,
+                    title: '完了: nums1 の残余はそのまま',
+                    desc: 'j = -1（nums2 は空）なので残余コピーは不要。nums1[0]=1 は既に正しい位置。マージ完了 → [1,2,2,3,5,6]',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: -1,
+                    k: 0,
+                    lastK: -1,
+                    phase: 'done',
+                },
+            ];
+
+            // ─── Array visualizer ─────────────────────────────────────────────────────
+            function ArrayViz({ nums1, nums2, i, j, k, lastK, phase }) {
+                const CW = 52,
+                    CH = 38,
+                    GAP = 4;
+                const N1 = nums1.length,
+                    N2 = nums2.length;
+                const startX = (560 - N1 * (CW + GAP) + GAP) / 2;
+
+                const cellFill1 = (idx) => {
+                    if (phase === 'done') return '#d1fae5';
+                    if (idx === lastK) return '#fef9c3';
+                    if (idx === k) return '#fde68a';
+                    if (idx <= i) return '#bfdbfe';
+                    return '#f1f5f9';
+                };
+                const cellStroke1 = (idx) => {
+                    if (phase === 'done') return '#10b981';
+                    if (idx === k) return '#f59e0b';
+                    if (idx <= i) return '#0284c7';
+                    return '#cbd5e1';
+                };
+                const cellFill2 = (idx) => {
+                    if (idx <= j) return '#bbf7d0';
+                    return '#f1f5f9';
+                };
+
+                return (
+                    <svg viewBox="0 0 560 230" style={{ width: '100%', height: 'auto' }}>
+                        {/* nums1 label */}
+                        <text
+                            x="20"
+                            y="60"
+                            textAnchor="start"
+                            dominantBaseline="middle"
+                            fontSize="13"
+                            fontWeight="bold"
+                            fill="#0c4a6e"
+                        >
+                            nums1
+                        </text>
+
+                        {/* nums1 cells */}
+                        {nums1.map((val, idx) => {
+                            const x = startX + idx * (CW + GAP);
+                            return (
+                                <g key={'n1' + idx}>
+                                    <rect
+                                        x={x}
+                                        y={40}
+                                        width={CW}
+                                        height={CH}
+                                        rx={6}
+                                        fill={cellFill1(idx)}
+                                        stroke={cellStroke1(idx)}
+                                        strokeWidth={idx === k && phase !== 'done' ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={x + CW / 2}
+                                        y={40 + CH / 2}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="15"
+                                        fontWeight="bold"
+                                        fill={
+                                            phase === 'done'
+                                                ? '#065f46'
+                                                : idx <= i
+                                                  ? '#1e3a5f'
+                                                  : '#94a3b8'
+                                        }
+                                    >
+                                        {val}
+                                    </text>
+                                    <text
+                                        x={x + CW / 2}
+                                        y={88}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="10"
+                                        fill="#94a3b8"
+                                    >
+                                        [{idx}]
+                                    </text>
+                                </g>
+                            );
+                        })}
+
+                        {/* i pointer */}
+                        {i >= 0 && i < 6 && phase !== 'done' && (
+                            <g>
+                                <line
+                                    x1={startX + i * (CW + GAP) + CW / 2}
+                                    y1={38}
+                                    x2={startX + i * (CW + GAP) + CW / 2}
+                                    y2={26}
+                                    stroke="#0284c7"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + i * (CW + GAP) + CW / 2}
+                                    y={20}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#0284c7"
+                                >
+                                    i={i}
+                                </text>
+                            </g>
+                        )}
+                        {/* k pointer */}
+                        {k >= 0 && k < 6 && phase !== 'done' && (
+                            <g>
+                                <line
+                                    x1={startX + k * (CW + GAP) + CW / 2}
+                                    y1={78}
+                                    x2={startX + k * (CW + GAP) + CW / 2}
+                                    y2={98}
+                                    stroke="#d97706"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + k * (CW + GAP) + CW / 2}
+                                    y={108}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#d97706"
+                                >
+                                    k={k}
+                                </text>
+                            </g>
+                        )}
+
+                        {/* nums2 label */}
+                        <text
+                            x="20"
+                            y="160"
+                            textAnchor="start"
+                            dominantBaseline="middle"
+                            fontSize="13"
+                            fontWeight="bold"
+                            fill="#065f46"
+                        >
+                            nums2
+                        </text>
+
+                        {/* nums2 cells */}
+                        {nums2.map((val, idx) => {
+                            const x = startX + idx * (CW + GAP);
+                            return (
+                                <g key={'n2' + idx}>
+                                    <rect
+                                        x={x}
+                                        y={140}
+                                        width={CW}
+                                        height={CH}
+                                        rx={6}
+                                        fill={cellFill2(idx)}
+                                        stroke={idx === j ? '#059669' : '#cbd5e1'}
+                                        strokeWidth={idx === j ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={x + CW / 2}
+                                        y={140 + CH / 2}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="15"
+                                        fontWeight="bold"
+                                        fill={idx <= j ? '#065f46' : '#94a3b8'}
+                                    >
+                                        {val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+
+                        {/* j pointer */}
+                        {j >= 0 && j < 3 && (
+                            <g>
+                                <line
+                                    x1={startX + j * (CW + GAP) + CW / 2}
+                                    y1={138}
+                                    x2={startX + j * (CW + GAP) + CW / 2}
+                                    y2={124}
+                                    stroke="#059669"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + j * (CW + GAP) + CW / 2}
+                                    y={116}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#059669"
+                                >
+                                    j={j}
+                                </text>
+                            </g>
+                        )}
+
+                        {/* Legend */}
+                        <rect
+                            x="10"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#bfdbfe"
+                            stroke="#0284c7"
+                            strokeWidth="1"
+                        />
+                        <text x="26" y="210" fontSize="10" fill="#475569" dominantBaseline="middle">
+                            nums1 有効
+                        </text>
+                        <rect
+                            x="120"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#bbf7d0"
+                            stroke="#059669"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="136"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            nums2 残余
+                        </text>
+                        <rect
+                            x="220"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#fde68a"
+                            stroke="#f59e0b"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="236"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            書き込み位置 k
+                        </text>
+                        <rect
+                            x="360"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="376"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            マージ完了
+                        </text>
+                    </svg>
+                );
+            }
+
+            // ─── Steps component ──────────────────────────────────────────────────────
+            function StepsComponent() {
+                const [active, setActive] = useState(1);
+                const [playing, setPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const cur = stepsData[active - 1];
+
+                useEffect(() => {
+                    if (playing) {
+                        timerRef.current = setTimeout(() => {
+                            if (active === stepsData.length) {
+                                setPlaying(false);
+                                setActive(1);
+                            } else setActive((p) => p + 1);
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [playing, active]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8">
+                        {/* Step list */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const on = active === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                on
+                                                    ? '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={() => {
+                                                setActive(s.step);
+                                                setPlaying(false);
+                                            }}
+                                        >
+                                            <span
+                                                className={[
+                                                    'font-bold text-sm',
+                                                    on ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}: {s.title}
+                                            </span>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* Detail */}
+                        <div>
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)] mb-4">
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
+                                    Step {cur.step}: {cur.title}
+                                </h3>
+                                <p
+                                    className="text-slate-600 leading-7 text-sm"
+                                    dangerouslySetInnerHTML={{ __html: cur.desc }}
+                                />
+                            </div>
+
+                            <ArrayViz
+                                nums1={cur.nums1}
+                                nums2={cur.nums2}
+                                i={cur.i}
+                                j={cur.j}
+                                k={cur.k}
+                                lastK={cur.lastK}
+                                phase={cur.phase}
+                            />
+
+                            <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={() => setPlaying(true)}
+                                    disabled={playing}
+                                >
+                                    ▶ 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={() => {
+                                        setActive((s) => Math.max(1, s - 1));
+                                        setPlaying(false);
+                                    }}
+                                    disabled={active === 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={() => {
+                                        setActive((s) => Math.min(stepsData.length, s + 1));
+                                        setPlaying(false);
+                                    }}
+                                    disabled={active === 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={() => {
+                                        setActive(1);
+                                        setPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            // ─── Code tabs ────────────────────────────────────────────────────────────
+            const CODE = {
+                python: `from __future__ import annotations
+from typing import List
+
+class Solution:
+    def merge(self, nums1: List[int], m: int,
+              nums2: List[int], n: int) -> None:
+        """O(m+n) time, O(1) space — 後ろからの3ポインタマージ"""
+        if n == 0:
+            return  # エッジケース: nums2 が空
+
+        i: int = m - 1      # nums1 有効末尾ポインタ
+        j: int = n - 1      # nums2 末尾ポインタ
+        k: int = m + n - 1  # 書き込み位置ポインタ (常に k >= i)
+
+        while i >= 0 and j >= 0:
+            if nums1[i] >= nums2[j]:
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                nums1[k] = nums2[j]
+                j -= 1
+            k -= 1
+
+        # nums2 残余: CPython の memmove 相当でスライス一括コピー
+        if j >= 0:
+            nums1[: j + 1] = nums2[: j + 1]`,
+
+                typescript: `function merge(
+    nums1: number[], m: number,
+    nums2: number[], n: number
+): void {
+    // O(m+n) time, O(1) space — 後ろからの3ポインタマージ
+    let i: number = m - 1;      // nums1 有効末尾ポインタ
+    let j: number = n - 1;      // nums2 末尾ポインタ
+    let k: number = m + n - 1;  // 書き込み位置ポインタ (k >= i が常に成立)
+
+    while (i >= 0 && j >= 0) {
+        if (nums1[i] >= nums2[j]) {
+            nums1[k] = nums1[i];
+            i--;
+        } else {
+            nums1[k] = nums2[j];
+            j--;
+        }
+        k--;
+    }
+
+    // nums2 の残余コピー (nums1 の残余は移動不要)
+    while (j >= 0) {
+        nums1[k--] = nums2[j--];
+    }
+}`,
+
+                rust: `impl Solution {
+    pub fn merge(
+        nums1: &mut Vec<i32>, m: i32,
+        nums2: &mut Vec<i32>, n: i32,
+    ) {
+        // O(m+n) time, O(1) space — 後ろからの3ポインタマージ
+        // 不変条件: k >= i が常に成立 → 未処理要素を上書きしない
+        let mut i = m as usize;
+        let mut j = n as usize;
+        let mut k = (m + n) as usize;
+
+        while i > 0 && j > 0 {
+            k -= 1;
+            if nums1[i - 1] >= nums2[j - 1] {
+                nums1[k] = nums1[i - 1];
+                i -= 1;
+            } else {
+                nums1[k] = nums2[j - 1];
+                j -= 1;
+            }
+        }
+
+        // nums2 の残余コピー (usize アンダーフローを while j>0 で防止)
+        while j > 0 {
+            k -= 1;
+            nums1[k] = nums2[j - 1];
+            j -= 1;
+        }
+    }
+}`,
+            };
+
+            const TABS = [
+                { id: 'python', label: 'Python', lang: 'language-python' },
+                { id: 'typescript', label: 'TypeScript', lang: 'language-typescript' },
+                { id: 'rust', label: 'Rust', lang: 'language-rust' },
+            ];
+
+            function CodeTabs() {
+                const [tab, setTab] = useState('python');
+
+                useEffect(() => {
+                    setTimeout(() => {
+                        if (window.Prism) window.Prism.highlightAll();
+                    }, 50);
+                }, [tab]);
+
+                return (
+                    <div>
+                        <div className="flex gap-2 mb-4 flex-wrap">
+                            {TABS.map((t) => (
+                                <button
+                                    key={t.id}
+                                    type="button"
+                                    className={[
+                                        'px-4 py-2 rounded-lg font-semibold text-sm transition border-2',
+                                        tab === t.id
+                                            ? 'bg-emerald-600 text-white border-emerald-600'
+                                            : 'bg-white text-slate-600 border-slate-200 hover:border-emerald-400',
+                                    ].join(' ')}
+                                    onClick={() => setTab(t.id)}
+                                >
+                                    {t.label}
+                                </button>
+                            ))}
+                        </div>
+                        {TABS.map((t) => (
+                            <div key={t.id} style={{ display: tab === t.id ? 'block' : 'none' }}>
+                                <pre
+                                    className="line-numbers rounded-xl overflow-auto"
+                                    style={{ margin: 0, fontSize: '13px' }}
+                                >
+                                    <code className={t.lang}>{CODE[t.id]}</code>
+                                </pre>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            // ─── Mount ────────────────────────────────────────────────────────────────
+            ReactDOM.createRoot(document.getElementById('react-steps')).render(<StepsComponent />);
+            ReactDOM.createRoot(document.getElementById('react-code')).render(<CodeTabs />);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
new file mode 100644
index 00000000..b7d35ac0
--- /dev/null
+++ b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -0,0 +1,1433 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 88 – Merge Sorted Array</title>
+        <script src="/vendor/react/react.development.js"></script>
+        <script src="/vendor/react-dom/react-dom.development.js"></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"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/components/prism-python.min.js"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/components/prism-typescript.min.js"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/components/prism-rust.min.js"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.js"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/plugins/toolbar/prism-toolbar.js"
+            defer
+        ></script>
+        <script
+            src="/vendor/prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard.js"
+            defer
+        ></script>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;600&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Outfit', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .code-toolbar > .toolbar {
+                top: 0.6em;
+                right: 0.8em;
+                opacity: 1 !important;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+                box-shadow: none !important;
+                text-shadow: none !important;
+            }
+            .code-toolbar > .toolbar .toolbar-item button:hover,
+            .code-toolbar > .toolbar .toolbar-item a:hover {
+                background: #059669 !important;
+                color: white !important;
+            }
+            pre[class*='language-'] {
+                border-radius: 12px;
+                font-size: 13px;
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen p-4 md:p-8">
+        <div class="max-w-6xl mx-auto">
+            <!-- ═══ HEADER ═══ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.14)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-3">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 88</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"
+                        >Two Pointers</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.5rem] font-black text-teal-900 mb-1 leading-tight">
+                    Merge Sorted Array
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    後ろからの 3 ポインタマージ &mdash; O(m+n) インプレース実装
+                </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
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══ OVERVIEW ═══ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-7">
+                    <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(m+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(1)</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">
+                            3 Pointers
+                        </div>
+                        <div class="text-xs mt-1">使用ポインタ数</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">
+                            In-place
+                        </div>
+                        <div class="text-xs mt-1">操作種別</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div>
+                        <h3 class="text-teal-800 font-bold text-lg mb-3">問題設定</h3>
+                        <p class="text-slate-600 text-sm leading-7">
+                            ソート済み配列
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono"
+                                >nums1</code
+                            >（有効要素
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono">m</code>
+                            個、末尾
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono">n</code>
+                            個はゼロ埋め）と
+                            <code class="bg-sky-50 text-sky-800 px-1 rounded mono">nums2</code
+                            >（<code class="bg-sky-50 text-sky-800 px-1 rounded mono">n</code>
+                            個）を
+                            <code class="bg-emerald-50 text-emerald-800 px-1 rounded mono"
+                                >nums1</code
+                            >
+                            にインプレースでマージし、非減少順に並べる。
+                        </p>
+                        <div
+                            class="mt-4 rounded-xl p-4 bg-slate-50 border border-slate-200 mono text-sm"
+                        >
+                            <p class="text-xs text-slate-400 mb-1">入力</p>
+                            <p class="text-slate-700">
+                                nums1 = [1,2,3,<span class="text-slate-400">0,0,0</span>], m = 3
+                            </p>
+                            <p class="text-slate-700">nums2 = [2,5,6], n = 3</p>
+                            <p class="text-xs text-slate-400 mt-3 mb-1">出力</p>
+                            <p class="font-bold text-emerald-700">[1, 2, 2, 3, 5, 6]</p>
+                        </div>
+                    </div>
+                    <div>
+                        <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
+                        <ul class="space-y-3 text-sm text-slate-600">
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">後ろから書く</strong
+                                    >：前から書くと有効要素を上書きするため、末尾
+                                    <span class="mono bg-amber-50 text-amber-700 px-1 rounded"
+                                        >k = m+n-1</span
+                                    >
+                                    から書き込む</span
+                                >
+                            </li>
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">不変条件 k ≥ i</strong
+                                    >：書き込みポインタが読み取りポインタを常に追い越さないため、未処理要素を上書きしない</span
+                                >
+                            </li>
+                            <li class="flex gap-2 items-start">
+                                <span class="text-emerald-500 font-bold mt-0.5 text-base">✓</span>
+                                <span
+                                    ><strong class="text-slate-700">残余は nums2 のみ</strong
+                                    >：nums1 の残余は既に正しい位置にある。nums2
+                                    の残りのみスライス代入で処理</span
+                                >
+                            </li>
+                        </ul>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ═══ STEPS (React mount point) ═══ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="react-steps"></div>
+            </section>
+
+            <!-- ═══ CODE (React mount point) ═══ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    実装コード
+                </h2>
+                <div id="react-code"></div>
+            </section>
+
+            <!-- ═══ DIAGRAM (static HTML SVG, kebab-case attributes) ═══ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+                <div class="mt-4 overflow-x-auto">
+                    <!--
+        viewBox設計:
+        幅: 560px (center x=280)
+        全ボックス: x=60, width=440 (right edge x=500)
+        全テキスト: x=280, text-anchor="middle"
+        SVG属性: ケバブケース統一
+        最終要素下端: cy=587+ry=28=615 → viewBox高さ=660
+      -->
+                    <svg
+                        viewBox="0 0 560 682"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Merge Sorted Array algorithm 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-arrowGreen"
+                                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-arrowRed"
+                                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-arrowPurple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#a855f7" />
+                            </marker>
+                        </defs>
+
+                        <!-- 1. 開始 (ellipse) cy=50, ry=28, bottom=78 -->
+                        <ellipse
+                            cx="280"
+                            cy="50"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="50"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="16"
+                            font-weight="bold"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="78"
+                            x2="280"
+                            y2="95"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 2. 初期化 rect: y=95, h=60, bottom=155 -->
+                        <rect
+                            x="60"
+                            y="95"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="117"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#0c4a6e"
+                        >
+                            ポインタを初期化
+                        </text>
+                        <text
+                            x="280"
+                            y="141"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#0369a1"
+                        >
+                            i = m-1 | j = n-1 | k = m+n-1
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="155"
+                            x2="280"
+                            y2="178"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 3. ループ条件 diamond: cy=203, half-w=140, half-h=27, top=176, bottom=230 -->
+                        <polygon
+                            points="280,176 420,203 280,230 140,203"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="199"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="bold"
+                            fill="#78350f"
+                        >
+                            i &ge; 0 かつ j &ge; 0 ?
+                        </text>
+
+                        <!-- YES label + arrow down -->
+                        <text
+                            x="292"
+                            y="246"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#059669"
+                            font-weight="bold"
+                        >
+                            YES
+                        </text>
+                        <line
+                            x1="280"
+                            y1="230"
+                            x2="280"
+                            y2="255"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- NO branch: right (420,203) → (530,203) → (530,522) → (502,522) -->
+                        <text
+                            x="428"
+                            y="196"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-weight="bold"
+                        >
+                            NO
+                        </text>
+                        <line
+                            x1="420"
+                            y1="203"
+                            x2="530"
+                            y2="203"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="530"
+                            y1="203"
+                            x2="530"
+                            y2="522"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="530"
+                            y1="522"
+                            x2="502"
+                            y2="522"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- 4. 比較・書き込み rect: y=255, h=115, bottom=370 (+20px で最終行に余白確保) -->
+                        <rect
+                            x="60"
+                            y="255"
+                            width="440"
+                            height="115"
+                            rx="10"
+                            fill="#f1f5f9"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="277"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#1e293b"
+                        >
+                            比較・書き込み
+                        </text>
+                        <line
+                            x1="80"
+                            y1="291"
+                            x2="480"
+                            y2="291"
+                            stroke="#cbd5e1"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="313"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            if nums1[i] &ge; nums2[j]:
+                        </text>
+                        <text
+                            x="280"
+                            y="334"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#059669"
+                        >
+                            nums1[k] = nums1[i]; i--
+                        </text>
+                        <text
+                            x="280"
+                            y="355"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#475569"
+                        >
+                            else: nums1[k] = nums2[j]; j--
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="370"
+                            x2="280"
+                            y2="388"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 5. k-- rect: y=388, h=44, bottom=432 -->
+                        <rect
+                            x="60"
+                            y="388"
+                            width="440"
+                            height="44"
+                            rx="10"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="410"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#0c4a6e"
+                        >
+                            k--
+                        </text>
+
+                        <!-- Loop back: (280,432) → (280,455) → (35,455) → (35,203) → (140,203) -->
+                        <path
+                            d="M 280,432 L 280,455 L 35,455 L 35,203 L 140,203"
+                            fill="none"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                            stroke-dasharray="6,3"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="17"
+                            y="350"
+                            text-anchor="middle"
+                            font-size="10"
+                            fill="#a855f7"
+                            font-weight="bold"
+                            transform="rotate(-90 17 350)"
+                        >
+                            ループバック
+                        </text>
+
+                        <!-- 6. nums2 残余スライスコピー rect: y=492, h=60, bottom=552 -->
+                        <rect
+                            x="60"
+                            y="492"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#f1f5f9"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="514"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#1e293b"
+                        >
+                            nums2 残余スライスコピー
+                        </text>
+                        <text
+                            x="280"
+                            y="537"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#475569"
+                        >
+                            nums1[:j+1] = nums2[:j+1]
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="552"
+                            x2="280"
+                            y2="578"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- 7. 終了 ellipse: cy=607, ry=28, bottom=635 → viewBox 682 で余白47px -->
+                        <ellipse
+                            cx="280"
+                            cy="607"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="607"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="16"
+                            font-weight="bold"
+                            fill="#065f46"
+                        >
+                            終了
+                        </text>
+                    </svg>
+                </div>
+                <div
+                    class="mt-6 p-5 rounded-xl bg-slate-50 border border-slate-200 text-sm text-slate-700 leading-8"
+                >
+                    <strong class="text-teal-800 text-base">フロー説明</strong><br />
+                    1. <strong>初期化</strong>：i = m-1（nums1 有効末尾）、j = n-1（nums2 末尾）、k
+                    = m+n-1（書き込み末尾）<br />
+                    2. <strong>ループ判定</strong>（黄ダイヤ）：i≥0 かつ j≥0
+                    の間ループ。どちらかが尽きたら
+                    <span class="text-red-600 font-bold">NO</span> で残余処理へ<br />
+                    3. <strong>比較・書き込み</strong>：nums1[i] と nums2[j] を比較し大きい方を
+                    nums1[k] に書き込み、対応するポインタを減算<br />
+                    4. <strong>k-- 後に紫破線でループ条件へ戻る</strong>（不変条件 k ≥ i を維持）<br />
+                    5. <strong>残余コピー</strong>：nums2 が残っていれば CPython の memmove
+                    相当のスライス代入で高速一括コピー
+                </div>
+            </section>
+
+            <!-- ═══ COMPLEXITY ═══ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+                <div class="overflow-x-auto">
+                    <table class="w-full text-sm text-left border-collapse">
+                        <thead>
+                            <tr class="bg-emerald-50">
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="px-4 py-3 font-bold text-teal-800 border-b-2 border-emerald-200 rounded-tr-lg"
+                                >
+                                    備考
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50/60 border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-emerald-700">
+                                    後ろから 3 ポインタ ✅
+                                </td>
+                                <td class="px-4 py-3 mono font-bold text-emerald-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono font-bold text-emerald-600">O(1)</td>
+                                <td class="px-4 py-3 text-slate-600">
+                                    最適解。追加アロケーションなし
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-slate-700">
+                                    コピー後 .sort()
+                                </td>
+                                <td class="px-4 py-3 mono text-slate-600">O((m+n) log(m+n))</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(1)</td>
+                                <td class="px-4 py-3 text-slate-600">実装最短だが計算量で劣る</td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-slate-700">
+                                    一時バッファ使用
+                                </td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m)</td>
+                                <td class="px-4 py-3 text-slate-600">
+                                    前からマージ可能だが空間を消費
+                                </td>
+                            </tr>
+                            <tr>
+                                <td class="px-4 py-3 font-semibold text-slate-700">heapq.merge</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
+                                <td class="px-4 py-3 text-slate-600">一時リスト生成あり</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+                <div
+                    class="mt-5 p-5 rounded-xl bg-emerald-50 border border-emerald-200 text-sm text-slate-700 leading-7"
+                >
+                    <strong class="text-teal-800">不変条件の証明：</strong>
+                    初期値
+                    <code class="bg-white mono px-1 rounded text-emerald-700">k - i = n &ge; 0</code
+                    >。 各イテレーションで k は必ず 1 減少し、i か j のどちらかも 1 減少する。 i
+                    減少時は k - i が不変、j 減少時は k - i が 1 増加。
+                    <strong
+                        >よって k &ge; i が常に成立し、未処理の nums1 要素を上書きしない。</strong
+                    >
+                </div>
+            </section>
+        </div>
+        <!-- /max-w -->
+
+        <!-- ═══ REACT COMPONENTS ═══ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            // ─── Steps data ───────────────────────────────────────────────────────────
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '初期状態を確認',
+                    desc: 'nums1 = [1,2,3,0,0,0]（m=3）と nums2 = [2,5,6]（n=3）が入力。nums1 の末尾 3 要素（0）がマージ先バッファ。i=2, j=2, k=5 を設定する。',
+                    nums1: [1, 2, 3, 0, 0, 0],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 2,
+                    k: 5,
+                    lastK: -1,
+                    phase: 'init',
+                },
+                {
+                    step: 2,
+                    title: '比較: nums1[2]=3 vs nums2[2]=6',
+                    desc: '3 < 6 なので nums2[2]=6 を nums1[5] に書き込む。j-- → j=1, k-- → k=4。',
+                    nums1: [1, 2, 3, 0, 0, 6],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 1,
+                    k: 4,
+                    lastK: 5,
+                    phase: 'write_j',
+                },
+                {
+                    step: 3,
+                    title: '比較: nums1[2]=3 vs nums2[1]=5',
+                    desc: '3 < 5 なので nums2[1]=5 を nums1[4] に書き込む。j-- → j=0, k-- → k=3。',
+                    nums1: [1, 2, 3, 0, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 2,
+                    j: 0,
+                    k: 3,
+                    lastK: 4,
+                    phase: 'write_j',
+                },
+                {
+                    step: 4,
+                    title: '比較: nums1[2]=3 vs nums2[0]=2',
+                    desc: '3 &ge; 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
+                    nums1: [1, 2, 3, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 1,
+                    j: 0,
+                    k: 2,
+                    lastK: 3,
+                    phase: 'write_i',
+                },
+                {
+                    step: 5,
+                    title: '比較: nums1[1]=2 vs nums2[0]=2',
+                    desc: '2 &ge; 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: 0,
+                    k: 1,
+                    lastK: 2,
+                    phase: 'write_i',
+                },
+                {
+                    step: 6,
+                    title: '比較: nums1[0]=1 vs nums2[0]=2',
+                    desc: '1 < 2 なので nums2[0]=2 を nums1[1] に書き込む。j-- → j=-1 でループ終了。',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: -1,
+                    k: 0,
+                    lastK: 1,
+                    phase: 'write_j',
+                },
+                {
+                    step: 7,
+                    title: '完了: nums1 の残余はそのまま',
+                    desc: 'j = -1（nums2 は空）なので残余コピーは不要。nums1[0]=1 は既に正しい位置。マージ完了 → [1,2,2,3,5,6]',
+                    nums1: [1, 2, 2, 3, 5, 6],
+                    nums2: [2, 5, 6],
+                    i: 0,
+                    j: -1,
+                    k: 0,
+                    lastK: -1,
+                    phase: 'done',
+                },
+            ];
+
+            // ─── Array visualizer ─────────────────────────────────────────────────────
+            function ArrayViz({ nums1, nums2, i, j, k, lastK, phase }) {
+                const CW = 52,
+                    CH = 38,
+                    GAP = 4;
+                const N1 = nums1.length,
+                    N2 = nums2.length;
+                const startX = (560 - N1 * (CW + GAP) + GAP) / 2;
+
+                const cellFill1 = (idx) => {
+                    if (phase === 'done') return '#d1fae5';
+                    if (idx === lastK) return '#fef9c3';
+                    if (idx === k) return '#fde68a';
+                    if (idx <= i) return '#bfdbfe';
+                    return '#f1f5f9';
+                };
+                const cellStroke1 = (idx) => {
+                    if (phase === 'done') return '#10b981';
+                    if (idx === k) return '#f59e0b';
+                    if (idx <= i) return '#0284c7';
+                    return '#cbd5e1';
+                };
+                const cellFill2 = (idx) => {
+                    if (idx <= j) return '#bbf7d0';
+                    return '#f1f5f9';
+                };
+
+                return (
+                    <svg viewBox="0 0 560 230" style={{ width: '100%', height: 'auto' }}>
+                        {/* nums1 label */}
+                        <text
+                            x="20"
+                            y="60"
+                            textAnchor="start"
+                            dominantBaseline="middle"
+                            fontSize="13"
+                            fontWeight="bold"
+                            fill="#0c4a6e"
+                        >
+                            nums1
+                        </text>
+
+                        {/* nums1 cells */}
+                        {nums1.map((val, idx) => {
+                            const x = startX + idx * (CW + GAP);
+                            return (
+                                <g key={'n1' + idx}>
+                                    <rect
+                                        x={x}
+                                        y={40}
+                                        width={CW}
+                                        height={CH}
+                                        rx={6}
+                                        fill={cellFill1(idx)}
+                                        stroke={cellStroke1(idx)}
+                                        strokeWidth={idx === k && phase !== 'done' ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={x + CW / 2}
+                                        y={40 + CH / 2}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="15"
+                                        fontWeight="bold"
+                                        fill={
+                                            phase === 'done'
+                                                ? '#065f46'
+                                                : idx <= i
+                                                  ? '#1e3a5f'
+                                                  : '#94a3b8'
+                                        }
+                                    >
+                                        {val}
+                                    </text>
+                                    <text
+                                        x={x + CW / 2}
+                                        y={88}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="10"
+                                        fill="#94a3b8"
+                                    >
+                                        [{idx}]
+                                    </text>
+                                </g>
+                            );
+                        })}
+
+                        {/* i pointer */}
+                        {i >= 0 && i < 6 && phase !== 'done' && (
+                            <g>
+                                <line
+                                    x1={startX + i * (CW + GAP) + CW / 2}
+                                    y1={38}
+                                    x2={startX + i * (CW + GAP) + CW / 2}
+                                    y2={26}
+                                    stroke="#0284c7"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + i * (CW + GAP) + CW / 2}
+                                    y={20}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#0284c7"
+                                >
+                                    i={i}
+                                </text>
+                            </g>
+                        )}
+                        {/* k pointer */}
+                        {k >= 0 && k < 6 && phase !== 'done' && (
+                            <g>
+                                <line
+                                    x1={startX + k * (CW + GAP) + CW / 2}
+                                    y1={78}
+                                    x2={startX + k * (CW + GAP) + CW / 2}
+                                    y2={98}
+                                    stroke="#d97706"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + k * (CW + GAP) + CW / 2}
+                                    y={108}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#d97706"
+                                >
+                                    k={k}
+                                </text>
+                            </g>
+                        )}
+
+                        {/* nums2 label */}
+                        <text
+                            x="20"
+                            y="160"
+                            textAnchor="start"
+                            dominantBaseline="middle"
+                            fontSize="13"
+                            fontWeight="bold"
+                            fill="#065f46"
+                        >
+                            nums2
+                        </text>
+
+                        {/* nums2 cells */}
+                        {nums2.map((val, idx) => {
+                            const x = startX + idx * (CW + GAP);
+                            return (
+                                <g key={'n2' + idx}>
+                                    <rect
+                                        x={x}
+                                        y={140}
+                                        width={CW}
+                                        height={CH}
+                                        rx={6}
+                                        fill={cellFill2(idx)}
+                                        stroke={idx === j ? '#059669' : '#cbd5e1'}
+                                        strokeWidth={idx === j ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={x + CW / 2}
+                                        y={140 + CH / 2}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="15"
+                                        fontWeight="bold"
+                                        fill={idx <= j ? '#065f46' : '#94a3b8'}
+                                    >
+                                        {val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+
+                        {/* j pointer */}
+                        {j >= 0 && j < 3 && (
+                            <g>
+                                <line
+                                    x1={startX + j * (CW + GAP) + CW / 2}
+                                    y1={138}
+                                    x2={startX + j * (CW + GAP) + CW / 2}
+                                    y2={124}
+                                    stroke="#059669"
+                                    strokeWidth={1.5}
+                                />
+                                <text
+                                    x={startX + j * (CW + GAP) + CW / 2}
+                                    y={116}
+                                    textAnchor="middle"
+                                    fontSize="11"
+                                    fontWeight="bold"
+                                    fill="#059669"
+                                >
+                                    j={j}
+                                </text>
+                            </g>
+                        )}
+
+                        {/* Legend */}
+                        <rect
+                            x="10"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#bfdbfe"
+                            stroke="#0284c7"
+                            strokeWidth="1"
+                        />
+                        <text x="26" y="210" fontSize="10" fill="#475569" dominantBaseline="middle">
+                            nums1 有効
+                        </text>
+                        <rect
+                            x="120"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#bbf7d0"
+                            stroke="#059669"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="136"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            nums2 残余
+                        </text>
+                        <rect
+                            x="220"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#fde68a"
+                            stroke="#f59e0b"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="236"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            書き込み位置 k
+                        </text>
+                        <rect
+                            x="360"
+                            y="200"
+                            width="12"
+                            height="12"
+                            rx="2"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            strokeWidth="1"
+                        />
+                        <text
+                            x="376"
+                            y="210"
+                            fontSize="10"
+                            fill="#475569"
+                            dominantBaseline="middle"
+                        >
+                            マージ完了
+                        </text>
+                    </svg>
+                );
+            }
+
+            // ─── Steps component ──────────────────────────────────────────────────────
+            function StepsComponent() {
+                const [active, setActive] = useState(1);
+                const [playing, setPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const cur = stepsData[active - 1];
+
+                useEffect(() => {
+                    if (playing) {
+                        timerRef.current = setTimeout(() => {
+                            if (active === stepsData.length) {
+                                setPlaying(false);
+                                setActive(1);
+                            } else setActive((p) => p + 1);
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [playing, active]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8">
+                        {/* Step list */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const on = active === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                on
+                                                    ? '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={() => {
+                                                setActive(s.step);
+                                                setPlaying(false);
+                                            }}
+                                        >
+                                            <span
+                                                className={[
+                                                    'font-bold text-sm',
+                                                    on ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}: {s.title}
+                                            </span>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* Detail */}
+                        <div>
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)] mb-4">
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
+                                    Step {cur.step}: {cur.title}
+                                </h3>
+                                <p
+                                    className="text-slate-600 leading-7 text-sm"
+                                    dangerouslySetInnerHTML={{ __html: cur.desc }}
+                                />
+                            </div>
+
+                            <ArrayViz
+                                nums1={cur.nums1}
+                                nums2={cur.nums2}
+                                i={cur.i}
+                                j={cur.j}
+                                k={cur.k}
+                                lastK={cur.lastK}
+                                phase={cur.phase}
+                            />
+
+                            <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={() => setPlaying(true)}
+                                    disabled={playing}
+                                >
+                                    ▶ 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={() => {
+                                        setActive((s) => Math.max(1, s - 1));
+                                        setPlaying(false);
+                                    }}
+                                    disabled={active === 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={() => {
+                                        setActive((s) => Math.min(stepsData.length, s + 1));
+                                        setPlaying(false);
+                                    }}
+                                    disabled={active === 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={() => {
+                                        setActive(1);
+                                        setPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            // ─── Code tabs ────────────────────────────────────────────────────────────
+            const CODE = {
+                python: `from __future__ import annotations
+from typing import List
+
+class Solution:
+    def merge(self, nums1: List[int], m: int,
+              nums2: List[int], n: int) -> None:
+        """O(m+n) time, O(1) space — 後ろからの3ポインタマージ"""
+        if n == 0:
+            return  # エッジケース: nums2 が空
+
+        i: int = m - 1      # nums1 有効末尾ポインタ
+        j: int = n - 1      # nums2 末尾ポインタ
+        k: int = m + n - 1  # 書き込み位置ポインタ (常に k >= i)
+
+        while i >= 0 and j >= 0:
+            if nums1[i] >= nums2[j]:
+                nums1[k] = nums1[i]
+                i -= 1
+            else:
+                nums1[k] = nums2[j]
+                j -= 1
+            k -= 1
+
+        # nums2 残余: CPython の memmove 相当でスライス一括コピー
+        if j >= 0:
+            nums1[: j + 1] = nums2[: j + 1]`,
+
+                typescript: `function merge(
+    nums1: number[], m: number,
+    nums2: number[], n: number
+): void {
+    // O(m+n) time, O(1) space — 後ろからの3ポインタマージ
+    let i: number = m - 1;      // nums1 有効末尾ポインタ
+    let j: number = n - 1;      // nums2 末尾ポインタ
+    let k: number = m + n - 1;  // 書き込み位置ポインタ (k >= i が常に成立)
+
+    while (i >= 0 && j >= 0) {
+        if (nums1[i] >= nums2[j]) {
+            nums1[k] = nums1[i];
+            i--;
+        } else {
+            nums1[k] = nums2[j];
+            j--;
+        }
+        k--;
+    }
+
+    // nums2 の残余コピー (nums1 の残余は移動不要)
+    while (j >= 0) {
+        nums1[k--] = nums2[j--];
+    }
+}`,
+
+                rust: `impl Solution {
+    pub fn merge(
+        nums1: &mut Vec<i32>, m: i32,
+        nums2: &mut Vec<i32>, n: i32,
+    ) {
+        // O(m+n) time, O(1) space — 後ろからの3ポインタマージ
+        // 不変条件: k >= i が常に成立 → 未処理要素を上書きしない
+        let mut i = m as usize;
+        let mut j = n as usize;
+        let mut k = (m + n) as usize;
+
+        while i > 0 && j > 0 {
+            k -= 1;
+            if nums1[i - 1] >= nums2[j - 1] {
+                nums1[k] = nums1[i - 1];
+                i -= 1;
+            } else {
+                nums1[k] = nums2[j - 1];
+                j -= 1;
+            }
+        }
+
+        // nums2 の残余コピー (usize アンダーフローを while j>0 で防止)
+        while j > 0 {
+            k -= 1;
+            nums1[k] = nums2[j - 1];
+            j -= 1;
+        }
+    }
+}`,
+            };
+
+            const TABS = [
+                { id: 'python', label: 'Python', lang: 'language-python' },
+                { id: 'typescript', label: 'TypeScript', lang: 'language-typescript' },
+                { id: 'rust', label: 'Rust', lang: 'language-rust' },
+            ];
+
+            function CodeTabs() {
+                const [tab, setTab] = useState('python');
+
+                useEffect(() => {
+                    setTimeout(() => {
+                        if (window.Prism) window.Prism.highlightAll();
+                    }, 50);
+                }, [tab]);
+
+                return (
+                    <div>
+                        <div className="flex gap-2 mb-4 flex-wrap">
+                            {TABS.map((t) => (
+                                <button
+                                    key={t.id}
+                                    type="button"
+                                    className={[
+                                        'px-4 py-2 rounded-lg font-semibold text-sm transition border-2',
+                                        tab === t.id
+                                            ? 'bg-emerald-600 text-white border-emerald-600'
+                                            : 'bg-white text-slate-600 border-slate-200 hover:border-emerald-400',
+                                    ].join(' ')}
+                                    onClick={() => setTab(t.id)}
+                                >
+                                    {t.label}
+                                </button>
+                            ))}
+                        </div>
+                        {TABS.map((t) => (
+                            <div key={t.id} style={{ display: tab === t.id ? 'block' : 'none' }}>
+                                <pre
+                                    className="line-numbers rounded-xl overflow-auto"
+                                    style={{ margin: 0, fontSize: '13px' }}
+                                >
+                                    <code className={t.lang}>{CODE[t.id]}</code>
+                                </pre>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            // ─── Mount ────────────────────────────────────────────────────────────────
+            ReactDOM.createRoot(document.getElementById('react-steps')).render(<StepsComponent />);
+            ReactDOM.createRoot(document.getElementById('react-code')).render(<CodeTabs />);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index 464fb782..ef6224d4 100644
--- a/public/index.html
+++ b/public/index.html
@@ -416,7 +416,7 @@ <h1 class="site-title">
             🧪 Algorithm Study
             <span class="title-accent">Index</span>
         </h1>
-        <p class="site-subtitle">164 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">165 interactive lessons across 6 domains</p>
     </header>
 
     <div class="search-container">
@@ -431,9 +431,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">164</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">165</span>
         </button>
-        <button class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">87</span></button>
+        <button class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">88</span></button>
 <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 class="tab-button" data-category="datastructures" data-tab-target="DataStructures"><span class="tab-icon">🏗️</span> DataStructures <span class="tab-count">35</span></button>
 <button class="tab-button" data-category="javascript" data-tab-target="JavaScript"><span class="tab-icon">📜</span> JavaScript <span class="tab-count">14</span></button>
@@ -473,6 +473,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/6.%20Zigzag%20Conversion/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 6: Zigzag Conversion - 周期式による行別直接抽出</span></span><span class="file-path">Algorithm/Other/leetcode/6. Zigzag Conversion/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/70.%20Climbing%20Stairs/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 70 - Climbing Stairs | フィボナッチDP</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/70. Climbing Stairs/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/7.%20Reverse%20Integer/claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 7: Reverse Integer - 文字列反転法</span></span><span class="file-path">Algorithm/Other/leetcode/7. Reverse Integer/claude/README.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Sort/MergeSort/leetcode/claude%204.6%20sonnet%20extended/88.%20Merge%20Sorted%20Array/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 88 – Merge Sorted Array</span></span><span class="file-path">Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Backtracking/leetcode/93.%20Restore%20IP%20Addresses/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 93: Restore IP Addresses - DFS + 枝刈り解説</span></span><span class="file-path">Algorithm/Backtracking/leetcode/93. Restore IP Addresses/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/96.%20Unique%20Binary%20Search%20Trees/claude%204.5%20sonnet/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 96: Unique Binary Search Trees - カタラン数解説</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/96. Unique Binary Search Trees/claude 4.5 sonnet/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/97.%20Interleaving%20String/Claude%20Sonnet%204.5/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 97: Interleaving String - 1D DP解説</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/97. Interleaving String/Claude Sonnet 4.5/README_React.html</span></a></li>
@@ -644,6 +645,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/6.%20Zigzag%20Conversion/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 6: Zigzag Conversion - 周期式による行別直接抽出</span></span><span class="file-path">Algorithm/Other/leetcode/6. Zigzag Conversion/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/70.%20Climbing%20Stairs/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 70 - Climbing Stairs | フィボナッチDP</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/70. Climbing Stairs/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/7.%20Reverse%20Integer/claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 7: Reverse Integer - 文字列反転法</span></span><span class="file-path">Algorithm/Other/leetcode/7. Reverse Integer/claude/README.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Sort/MergeSort/leetcode/claude%204.6%20sonnet%20extended/88.%20Merge%20Sorted%20Array/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 88 – Merge Sorted Array</span></span><span class="file-path">Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Backtracking/leetcode/93.%20Restore%20IP%20Addresses/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 93: Restore IP Addresses - DFS + 枝刈り解説</span></span><span class="file-path">Algorithm/Backtracking/leetcode/93. Restore IP Addresses/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/96.%20Unique%20Binary%20Search%20Trees/claude%204.5%20sonnet/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 96: Unique Binary Search Trees - カタラン数解説</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/96. Unique Binary Search Trees/claude 4.5 sonnet/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/97.%20Interleaving%20String/Claude%20Sonnet%204.5/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 97: Interleaving String - 1D DP解説</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/97. Interleaving String/Claude Sonnet 4.5/README_React.html</span></a></li>
@@ -811,7 +813,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-03-11
+        Generated on 2026-03-14
     </footer>
 
     <script>

From 3285bec7bfc503674bb7c43e2748102730bb9b32 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 14 Mar 2026 21:02:54 +0900
Subject: [PATCH 2/4] Refine LeetCode 88 implementations: Update complexity
 notes, Rust index safety, TS non-null assertions, and React UI pointer
 rendering

---
 .../Merge_Sorted_Array_Python.md              |   4 +-
 .../Merge_Sorted_Array_Rust.md                |   4 +-
 .../Merge_Sorted_Array_TypeScript.md          |   8 +-
 .../88. Merge Sorted Array/README.md          | 159 +++++++++---------
 .../88. Merge Sorted Array/README_React.html  |  15 +-
 .../88. Merge Sorted Array/README_React.html  |  15 +-
 6 files changed, 99 insertions(+), 106 deletions(-)

diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md
index 404b7b40..db1e037b 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
@@ -31,7 +31,7 @@ LeetCode のシグネチャは `None` 返却の破壊的操作。Pylance 対応
 
 - **選択**: 後ろからの3ポインタマージ（業務版・競技版ともに同一戦略）
 - **Python最適化戦略**: 残余コピーをスライス代入 `nums1[:j+1] = nums2[:j+1]` に置換することで、CPython 内部の `memmove` が発動し逐次代入より高速
-- **トレードオフ**: スライス代入は一時オブジェクトを1個生成するが定数サイズであり実質 O(1) の追加コスト
+- **トレードオフ**: スライス代入は最大 O(n) サイズの一時リストオブジェクトを生成するため、厳密な O(1) 空間計算量が必要な場合は while ループで要素ごとにコピーする手法が適している
 
 ---
 
@@ -60,7 +60,7 @@ class Solution:
             n:     nums2 の要素数
 
         Time Complexity:  O(m + n)
-        Space Complexity: O(1)  ※スライス代入の一時オブジェクト除く
+        Space Complexity: O(n)  ※スライス代入の一時オブジェクトによる最悪ケース
         """
         # ── 業務開発版 ─────────────────────────────────────────────
         # n == 0 のとき nums1 は既に完成しているため早期リターン
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md
index 91bb171f..588af6ce 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
@@ -6,12 +6,12 @@
 
 **業務開発視点での分析**
 
-LeetCode の関数シグネチャは `&mut Vec<i32>` の受け渡しを強制しますが、内部では `usize` インデックスと `saturating_sub` を活用し、符号なし整数のアンダーフローをコンパイル時に潰します。`i32 → usize` の変換は `as usize` で確実に行います。
+LeetCode の関数シグネチャは `&mut Vec<i32>` の受け渡しを強制しますが、内部では `while i > 0 && j > 0` のような実行時のガード条件と構造的な順序付けにより、符号なし整数のアンダーフローを防止します。`i32 → usize` の変換は `as usize` で確実に行います。
 
 **Rust特有の考慮点**
 
 - `i32` 引数 `m`, `n` は LeetCode の制約上 `0..=200` に収まるため、`as usize` キャストは安全
-- `checked_sub` や `saturating_sub` でインデックス計算のパニックを防止
+- ランタイムのガードループ（`while i > 0 && j > 0` や `while j > 0`）によりインデックス計算のパニックを防止
 - 借用は `&mut Vec<i32>` のスライス操作に集約し、ライフタイムを単純化
 
 ---
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md
index db82ecf2..0410e13f 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
@@ -65,11 +65,11 @@ function merge(nums1: number[], m: number, nums2: number[], n: number): void {
 
     // どちらかの配列が空になるまで大きい方を末尾から書き込む
     while (i >= 0 && j >= 0) {
-        if (nums1[i] >= nums2[j]) {
-            nums1[k] = nums1[i];
+        if (nums1[i]! >= nums2[j]!) {
+            nums1[k] = nums1[i]!;
             i--;
         } else {
-            nums1[k] = nums2[j];
+            nums1[k] = nums2[j]!;
             j--;
         }
         k--;
@@ -95,7 +95,7 @@ function merge(nums1: number[], m: number, nums2: number[], n: number): void {
 
 **型安全インデックス管理**
 
-`i >= 0` / `j >= 0` のガードにより、TypeScript の `strict: true` 環境でも `number` 型のインデックスが負にならないことが実行フロー上保証されます。`noUncheckedIndexedAccess` を有効にした場合でも、ガード後の `nums1[i]` は `number` として安全にアクセスできます。
+`i >= 0` / `j >= 0` のガードにより、TypeScript の `strict: true` 環境でも `number` 型のインデックスが負にならないことが実行フロー上保証されます。ただし `noUncheckedIndexedAccess` を有効にした場合、ガードだけでは `number | undefined` のままになるため、`nums1[i]!` のように非 null アサーションを用いるか、`if (i in nums1)` 等で存在チェックを行い型を明示的に狭める必要があります。
 
 **`while` vs イテレータ**
 
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md
index 44ea522f..9f2b2512 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
@@ -4,19 +4,15 @@
 
 ## 目次（Table of Contents）
 
-- [概要](#overview)
-- [アルゴリズム要点 TL;DR](#tldr)
-- [図解](#figures)
-- [正しさのスケッチ](#correctness)
-- [計算量](#complexity)
-- [Python 実装](#impl)
-- [CPython 最適化ポイント](#cpython)
-- [エッジケースと検証観点](#edgecases)
-- [FAQ](#faq)
+- [Overview](#overview)
+- [Algorithm](#algorithm)
+- [Complexity](#complexity)
+- [Implementation](#implementation)
+- [Optimization](#optimization)
 
 ---
 
-<h2 id="overview">概要</h2>
+## Overview
 
 ### 問題要約
 
@@ -37,22 +33,21 @@
 
 ---
 
-<h2 id="tldr">アルゴリズム要点 TL;DR</h2>
+## Algorithm
+
+### アルゴリズム要点 TL;DR
 
 - **戦略**: `nums1` の末尾から走査する **3 ポインタ法**（後ろからマージ）
 - **データ構造**: 追加配列不要。`nums1` 自体をバッファとして再利用
 - **時間計算量**: O(m + n) — 各要素をちょうど 1 回参照・書き込み
-- **空間計算量**: O(1) — 追加ヒープアロケーションなし
-  （残余コピーのスライス代入は定数サイズの一時オブジェクト 1 個のみ）
+- **空間計算量**: O(n) — スライス代入による一時オブジェクト生成の最悪ケース
 - **核心の不変条件**: 書き込みポインタ `k` は常に読み取りポインタ `i` 以上
   → 未処理の `nums1` 要素を上書きしない
 - **後ろから書く理由**: 前から比較すると `nums1` の有効要素を上書きしてしまうため逆順が安全
 
----
-
-<h2 id="figures">図解</h2>
+### 図解
 
-### フローチャート
+#### フローチャート
 
 ```mermaid
 flowchart TD
@@ -75,9 +70,7 @@ flowchart TD
 
 > 後ろから比較して大きい方を末尾（`k`）に書き込む。どちらかが尽きたら `nums2` の残余を先頭スライスへ一括コピー。
 
----
-
-### データフロー図（ステップ別状態遷移）
+#### データフロー図（ステップ別状態遷移）
 
 ```mermaid
 graph LR
@@ -113,11 +106,9 @@ graph LR
 
 > 各ステップで大きい方の値が `k` の位置に書き込まれ、対応するポインタと `k` が 1 ずつ減少する。
 
----
+### 正しさのスケッチ
 
-<h2 id="correctness">正しさのスケッチ</h2>
-
-### 不変条件
+#### 不変条件
 
 書き込みポインタ `k` と `nums1` の読み取りポインタ `i` について、以下が常に成立する：
 
@@ -130,44 +121,46 @@ k - i = (m + n - 1 - step_count) - (m - 1 - i_decrements)
 `i` が減少するとき `k - i` は変わらず、`j` が減少するとき `k - i` は 1 増加する。
 よって `k ≥ i` が保持され、**未処理の `nums1` 要素を上書きしない**。
 
-### 網羅性
+#### 網羅性
 
 - `while` ループ終了後、`i < 0` または `j < 0` のどちらかが成立
 - `j < 0` の場合：`nums2` は全て書き込み済み、`nums1` の残余は正しい位置にある（移動不要）
 - `j ≥ 0` の場合：`nums2[:j+1]` を `nums1[:j+1]` にスライス代入して完了
 
-### 基底条件（エッジケース）
+#### 基底条件（エッジケース）
 
 | 条件     | 処理                                          |
 | -------- | --------------------------------------------- |
 | `n == 0` | 早期リターン、`nums1` はそのまま              |
 | `m == 0` | `while` の `i >= 0` が即 False → 残余コピーへ |
 
-### 終了性
+#### 終了性
 
 `i` と `j` はループごとに必ず 1 以上減少し、非負整数であるため有限ステップで終了する。
 
 ---
 
-<h2 id="complexity">計算量</h2>
+## Complexity
 
 | 観点       | 計算量   | 説明                                       |
 | ---------- | -------- | ------------------------------------------ |
 | 時間計算量 | O(m + n) | 各要素を最大 1 回比較・書き込み            |
-| 空間計算量 | O(1)     | スライス代入の一時オブジェクトは定数サイズ |
+| 空間計算量 | O(n)     | スライス代入による一時オブジェクト生成による最悪ケース |
 
 ### In-place vs Pure 比較
 
 | 実装方針                      | 時間              | 空間     | 備考                                    |
 | ----------------------------- | ----------------- | -------- | --------------------------------------- |
-| 本実装（後ろから 3 ポインタ） | O(m+n)            | **O(1)** | ✅ 最適                                 |
+| 本実装（後ろから 3 ポインタ） | O(m+n)            | **O(n)** | スライス代入の空間コストを含む            |
 | 前から + 一時バッファ         | O(m+n)            | O(m)     | `nums1[:m]` を `list()` でコピー        |
 | `nums1 + nums2` 後 `.sort()`  | O((m+n) log(m+n)) | O(1)     | Timsort は C 実装で高速だが計算量は劣る |
 | `heapq.merge` + スライス代入  | O(m+n)            | O(m+n)   | 一時リストが発生                        |
 
 ---
 
-<h2 id="impl">Python 実装</h2>
+## Implementation
+
+### Python 実装
 
 ```python
 from __future__ import annotations
@@ -180,7 +173,7 @@ class Solution:
         """
         2 つのソート済み配列を nums1 にインプレースでマージする。
 
-        後ろから走査する 3 ポインタ法により O(m+n) 時間・O(1) 追加空間を実現。
+        後ろから走査する 3 ポインタ法により O(m+n) 時間・O(n) 空間（スライス代入による最悪ケース）を実現。
 
         不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない。
             初期値 k - i = n >= 0 が各イテレーションで保持される。
@@ -195,7 +188,7 @@ class Solution:
             None（nums1 を破壊的に変更）
 
         Time Complexity:  O(m + n)
-        Space Complexity: O(1)
+        Space Complexity: O(n)
         """
         # ── エッジケース: nums2 が空なら nums1 はそのまま ──────────────────
         if n == 0:
@@ -225,51 +218,7 @@ class Solution:
             nums1[: j + 1] = nums2[: j + 1]
 ```
 
----
-
-<h2 id="cpython">CPython 最適化ポイント</h2>
-
-### 1. スライス代入による残余コピーの高速化
-
-```python
-nums1[: j + 1] = nums2[: j + 1]
-```
-
-CPython の `list.__setitem__` スライス版は内部で `list_ass_slice` を呼び出し、
-`memmove` 相当の C レイヤーのメモリコピーが走る。
-逐次 `while j >= 0: nums1[k] = nums2[j]; j -= 1; k -= 1` より
-**インタープリタのバイトコードディスパッチ回数を大幅に削減**できる。
-
-### 2. LOAD_FAST によるローカル変数の高速アクセス
-
-| アクセス種別                                    | バイトコード  | 速度                 |
-| ----------------------------------------------- | ------------- | -------------------- |
-| ローカル変数（`i`, `j`, `k`, `nums1`, `nums2`） | `LOAD_FAST`   | 高速（辞書探索なし） |
-| グローバル変数                                  | `LOAD_GLOBAL` | やや低速             |
-| 属性アクセス（`self.xxx`）                      | `LOAD_ATTR`   | 最も低速             |
-
-本実装では全カウンタがメソッドのローカルスコープに収まるため、
-`LOAD_FAST` が全アクセスに適用される。
-
-### 3. 早期リターンによる不要な処理の排除
-
-```python
-if n == 0:
-    return
-```
-
-`n == 0` の場合はループに入らず即リターン。
-条件チェックのオーバーヘッドが極めて小さい。
-
-### 4. 型ヒントとランタイムの分離
-
-`from __future__ import annotations` を使用することで、
-型アノテーションの評価が **遅延評価（文字列化）** になり、
-実行時のインポートオーバーヘッドを最小化する。
-
----
-
-<h2 id="edgecases">エッジケースと検証観点</h2>
+### エッジケースと検証観点
 
 | ケース                                | 入力例                                      | 期待出力       | 対応箇所                               |
 | ------------------------------------- | ------------------------------------------- | -------------- | -------------------------------------- |
@@ -281,15 +230,13 @@ if n == 0:
 | 負の数を含む                          | `nums1=[-3,-1,0,0], m=2, nums2=[-2,0], n=2` | `[-3,-2,-1,0]` | 整数比較なので問題なし                 |
 | 最大制約                              | `m=n=100`                                   | 正しくマージ   | O(m+n) で余裕                          |
 
-### 静的解析観点（Pylance strict mode）
+#### 静的解析観点（Pylance strict mode）
 
 - `List[int]` 型ヒントにより `nums1[k]` への `int` 代入が型安全
 - `-> None` 明示により暗黙的な `None` 返却が警告なし
 - `from __future__ import annotations` で前方参照の問題を回避
 
----
-
-<h2 id="faq">FAQ</h2>
+### FAQ
 
 **Q1. なぜ前からではなく後ろからマージするのか？**
 
@@ -305,8 +252,8 @@ if n == 0:
 **Q3. スライス代入 `nums1[:j+1] = nums2[:j+1]` で一時オブジェクトは発生しないのか？**
 
 右辺 `nums2[:j+1]` がリストスライスとして一時的に生成される（O(j) サイズ）。
-ただし `j` は最大でも `n-1` であり定数スケールのため、実質 O(1) の追加コスト。
-逐次代入に比べてバイトコードのオーバーヘッドを削減できるため、実用上は高速。
+`j` は最大で `n-1` となるため、最悪ケースでは O(n) の追加空間を消費する。
+厳密な O(1) が必要な場合は while ループによる各要素コピーが推奨されるが、逐次代入に比べてバイトコードのオーバーヘッドを削減できるため、Python 実用上はスライスが高速。
 
 **Q4. `.sort()` を使う方法ではダメなのか？**
 
@@ -336,3 +283,47 @@ O(m+n) だが一時リストが O(m+n) の追加空間を消費する。
 
 `nums1[i] >= nums2[j]` の条件により、等値の場合は `nums1` 側が優先される。
 問題仕様上、安定性（相対順序の保持）は要求されていないため、どちらでも正解。
+
+---
+
+## Optimization
+
+### CPython 最適化ポイント
+
+#### 1. スライス代入による残余コピーの高速化
+
+```python
+nums1[: j + 1] = nums2[: j + 1]
+```
+
+CPython の `list.__setitem__` スライス版は内部で `list_ass_slice` を呼び出し、
+`memmove` 相当の C レイヤーのメモリコピーが走る。
+逐次 `while j >= 0: nums1[k] = nums2[j]; j -= 1; k -= 1` より
+**インタープリタのバイトコードディスパッチ回数を大幅に削減**できる。
+
+#### 2. LOAD_FAST によるローカル変数の高速アクセス
+
+| アクセス種別                                    | バイトコード  | 速度                 |
+| ----------------------------------------------- | ------------- | -------------------- |
+| ローカル変数（`i`, `j`, `k`, `nums1`, `nums2`） | `LOAD_FAST`   | 高速（辞書探索なし） |
+| グローバル変数                                  | `LOAD_GLOBAL` | やや低速             |
+| 属性アクセス（`self.xxx`）                      | `LOAD_ATTR`   | 最も低速             |
+
+本実装では全カウンタがメソッドのローカルスコープに収まるため、
+`LOAD_FAST` が全アクセスに適用される。
+
+#### 3. 早期リターンによる不要な処理の排除
+
+```python
+if n == 0:
+    return
+```
+
+`n == 0` の場合はループに入らず即リターン。
+条件チェックのオーバーヘッドが極めて小さい。
+
+#### 4. 型ヒントとランタイムの分離
+
+`from __future__ import annotations` を使用することで、
+型アノテーションの評価が **遅延評価（文字列化）** になり、
+実行時のインポートオーバーヘッドを最小化する。
\ No newline at end of file
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index 05c3723f..db78df05 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -837,7 +837,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                 {
                     step: 4,
                     title: '比較: nums1[2]=3 vs nums2[0]=2',
-                    desc: '3 &ge; 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
+                    desc: '3 ≥ 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
                     nums1: [1, 2, 3, 3, 5, 6],
                     nums2: [2, 5, 6],
                     i: 1,
@@ -849,7 +849,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                 {
                     step: 5,
                     title: '比較: nums1[1]=2 vs nums2[0]=2',
-                    desc: '2 &ge; 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
+                    desc: '2 ≥ 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
                     nums1: [1, 2, 2, 3, 5, 6],
                     nums2: [2, 5, 6],
                     i: 0,
@@ -973,7 +973,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                         })}
 
                         {/* i pointer */}
-                        {i >= 0 && i < 6 && phase !== 'done' && (
+                        {i >= 0 && i < N1 && phase !== 'done' && (
                             <g>
                                 <line
                                     x1={startX + i * (CW + GAP) + CW / 2}
@@ -996,7 +996,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             </g>
                         )}
                         {/* k pointer */}
-                        {k >= 0 && k < 6 && phase !== 'done' && (
+                        {k >= 0 && k < N1 && phase !== 'done' && (
                             <g>
                                 <line
                                     x1={startX + k * (CW + GAP) + CW / 2}
@@ -1063,7 +1063,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                         })}
 
                         {/* j pointer */}
-                        {j >= 0 && j < 3 && (
+                        {j >= 0 && j < N2 && (
                             <g>
                                 <line
                                     x1={startX + j * (CW + GAP) + CW / 2}
@@ -1229,8 +1229,9 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
                                 </h3>
                                 <p
                                     className="text-slate-600 leading-7 text-sm"
-                                    dangerouslySetInnerHTML={{ __html: cur.desc }}
-                                />
+                                >
+                                    {cur.desc}
+                                </p>
                             </div>
 
                             <ArrayViz
diff --git a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index b7d35ac0..23325356 100644
--- a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -837,7 +837,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                 {
                     step: 4,
                     title: '比較: nums1[2]=3 vs nums2[0]=2',
-                    desc: '3 &ge; 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
+                    desc: '3 ≥ 2 なので nums1[2]=3 を nums1[3] に書き込む。i-- → i=1, k-- → k=2。',
                     nums1: [1, 2, 3, 3, 5, 6],
                     nums2: [2, 5, 6],
                     i: 1,
@@ -849,7 +849,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                 {
                     step: 5,
                     title: '比較: nums1[1]=2 vs nums2[0]=2',
-                    desc: '2 &ge; 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
+                    desc: '2 ≥ 2（等値は nums1 側優先）なので nums1[1]=2 を nums1[2] に書き込む。i-- → i=0, k-- → k=1。',
                     nums1: [1, 2, 2, 3, 5, 6],
                     nums2: [2, 5, 6],
                     i: 0,
@@ -973,7 +973,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                         })}
 
                         {/* i pointer */}
-                        {i >= 0 && i < 6 && phase !== 'done' && (
+                        {i >= 0 && i < N1 && phase !== 'done' && (
                             <g>
                                 <line
                                     x1={startX + i * (CW + GAP) + CW / 2}
@@ -996,7 +996,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             </g>
                         )}
                         {/* k pointer */}
-                        {k >= 0 && k < 6 && phase !== 'done' && (
+                        {k >= 0 && k < N1 && phase !== 'done' && (
                             <g>
                                 <line
                                     x1={startX + k * (CW + GAP) + CW / 2}
@@ -1063,7 +1063,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                         })}
 
                         {/* j pointer */}
-                        {j >= 0 && j < 3 && (
+                        {j >= 0 && j < N2 && (
                             <g>
                                 <line
                                     x1={startX + j * (CW + GAP) + CW / 2}
@@ -1229,8 +1229,9 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
                                 </h3>
                                 <p
                                     className="text-slate-600 leading-7 text-sm"
-                                    dangerouslySetInnerHTML={{ __html: cur.desc }}
-                                />
+                                >
+                                    {cur.desc}
+                                </p>
                             </div>
 
                             <ArrayViz

From 61c21df16c57d24fb0aa7a33a73bc809271a546c Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 14 Mar 2026 21:38:40 +0900
Subject: [PATCH 3/4] Refine LeetCode 88 (Python, Rust, TS): Correct space
 complexity for Python, clarify Rust index safety, add TS non-null assertions,
 and improve React UI

---
 .../Merge_Sorted_Array_Python.md                |  8 ++++----
 .../Merge_Sorted_Array_Rust.md                  |  2 +-
 .../Merge_Sorted_Array_TypeScript.md            |  2 +-
 .../88. Merge Sorted Array/README.md            | 12 +++++-------
 .../88. Merge Sorted Array/README_React.html    | 17 +++++++++--------
 .../88. Merge Sorted Array/README_React.html    | 17 +++++++++--------
 6 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md
index db1e037b..f440a38c 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
@@ -21,8 +21,8 @@ LeetCode のシグネチャは `None` 返却の破壊的操作。Pylance 対応
 
 | アプローチ             | 時間計算量       | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用 | CPython最適化       | 備考                      |
 | ---------------------- | ---------------- | ---------- | ---------------- | ------ | ------------------ | ------------------- | ------------------------- |
-| 後ろから3ポインタ      | O(m+n)           | O(1)       | 低               | ★★★    | なし               | 適                  | 追加アロケーションなし ✅ |
-| コピー後 `list.sort()` | O((m+n)log(m+n)) | O(1)       | 最低             | ★★★    | なし               | 適（Timsort C実装） | 競技次善策                |
+| 後ろから3ポインタ      | O(m+n)           | O(n)       | 低               | ★★★    | なし               | 適                  | 追加アロケーションなし ✅ |
+| コピー後 `list.sort()` | O((m+n)log(m+n)) | O(m+n)     | 最低             | ★★★    | なし               | 適（Timsort C実装） | 競技次善策                |
 | `heapq.merge` + 展開   | O(m+n)           | O(m+n)     | 低               | ★★☆    | heapq              | 適                  | 一時リスト生成が発生      |
 
 ---
@@ -48,7 +48,7 @@ class Solution:
     def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
         """
         2つのソート済み配列を nums1 にインプレースでマージする。
-        後ろから走査する3ポインタ法により O(m+n) 時間・O(1) 追加空間を実現。
+        後ろから走査する3ポインタ法により O(m+n) 時間・O(n) 追加空間（スライス代入による最悪ケース）を実現。
 
         不変条件: k >= i が常に成立するため nums1 の未処理要素を上書きしない。
             初期値 k - i = n >= 0 が各イテレーションで保持される。
@@ -94,7 +94,7 @@ class Solution:
         ローカル変数へのキャッシュで LOAD_FAST を最大活用。
 
         Time Complexity:  O(m + n)
-        Space Complexity: O(1)
+        Space Complexity: O(n)
         """
         # ローカル変数へのバインドで属性ルックアップを排除
         i, j, k = m - 1, n - 1, m + n - 1
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md
index 588af6ce..9746c905 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
@@ -95,4 +95,4 @@ LeetCode の引数は `i32` ですが、配列インデックスは `usize` が
 
 **ループ本体の最小化**
 
-比較1回・代入1回・デクリメント1回のみ。イテレータ抽象化より命令型ループが適切なケースで、コンパイラは確実にインライン展開・SIMD 最適化を適用できます。
+比較1回・代入1回・デクリメント1回のみ。イテレータ抽象化より命令型ループが適切なケースで、コンパイラは最適化レベルや実装に依存してインライン展開を適用する可能性があります。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md
index 0410e13f..7e1b1d4a 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
@@ -78,7 +78,7 @@ function merge(nums1: number[], m: number, nums2: number[], n: number): void {
     // nums2 の残余要素をコピー
     // （nums1 の残余は既に正しい位置にあるため操作不要）
     while (j >= 0) {
-        nums1[k] = nums2[j];
+        nums1[k] = nums2[j]!;
         j--;
         k--;
     }
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md
index 9f2b2512..bf732eeb 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
@@ -2,7 +2,9 @@
 
 ---
 
-## 目次（Table of Contents）
+## Overview
+
+### 目次（Table of Contents）
 
 - [Overview](#overview)
 - [Algorithm](#algorithm)
@@ -10,10 +12,6 @@
 - [Implementation](#implementation)
 - [Optimization](#optimization)
 
----
-
-## Overview
-
 ### 問題要約
 
 **LeetCode 88 – Merge Sorted Array**
@@ -153,7 +151,7 @@ k - i = (m + n - 1 - step_count) - (m - 1 - i_decrements)
 | ----------------------------- | ----------------- | -------- | --------------------------------------- |
 | 本実装（後ろから 3 ポインタ） | O(m+n)            | **O(n)** | スライス代入の空間コストを含む            |
 | 前から + 一時バッファ         | O(m+n)            | O(m)     | `nums1[:m]` を `list()` でコピー        |
-| `nums1 + nums2` 後 `.sort()`  | O((m+n) log(m+n)) | O(1)     | Timsort は C 実装で高速だが計算量は劣る |
+| `nums1 + nums2` 後 `.sort()`  | O((m+n) log(m+n)) | O(m+n)     | Timsort は C 実装で高速だが計算量は劣る |
 | `heapq.merge` + スライス代入  | O(m+n)            | O(m+n)   | 一時リストが発生                        |
 
 ---
@@ -277,7 +275,7 @@ nums1[:] = merged
 ```
 
 O(m+n) だが一時リストが O(m+n) の追加空間を消費する。
-空間計算量の観点で本実装（O(1)）に劣る。
+空間計算量の観点で、スライス代入 `nums1[:j+1] = nums2[:j+1]` を用いる本実装（最悪ケース O(n)）に劣る。
 
 **Q6. 等値要素の扱いはどうなるか？**
 
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index db78df05..bf139556 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -251,7 +251,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                                 <span
                                     ><strong class="text-slate-700">残余は nums2 のみ</strong
                                     >：nums1 の残余は既に正しい位置にある。nums2
-                                    の残りのみスライス代入で処理</span
+                                    の残りのみコピーする</span
                                 >
                             </li>
                         </ul>
@@ -622,7 +622,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             ループバック
                         </text>
 
-                        <!-- 6. nums2 残余スライスコピー rect: y=492, h=60, bottom=552 -->
+                        <!-- 6. nums2 残余コピー rect: y=492, h=60, bottom=552 -->
                         <rect
                             x="60"
                             y="492"
@@ -642,7 +642,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             font-weight="bold"
                             fill="#1e293b"
                         >
-                            nums2 残余スライスコピー
+                            nums2 残余コピー
                         </text>
                         <text
                             x="280"
@@ -700,8 +700,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                     3. <strong>比較・書き込み</strong>：nums1[i] と nums2[j] を比較し大きい方を
                     nums1[k] に書き込み、対応するポインタを減算<br />
                     4. <strong>k-- 後に紫破線でループ条件へ戻る</strong>（不変条件 k ≥ i を維持）<br />
-                    5. <strong>残余コピー</strong>：nums2 が残っていれば CPython の memmove
-                    相当のスライス代入で高速一括コピー
+                    5. <strong>残余コピー</strong>：nums2 が残っていれば残りの要素をコピーする
                 </div>
             </section>
 
@@ -1316,9 +1315,11 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
                 j -= 1
             k -= 1
 
-        # nums2 残余: CPython の memmove 相当でスライス一括コピー
-        if j >= 0:
-            nums1[: j + 1] = nums2[: j + 1]`,
+        # nums2 残余コピー
+        while j >= 0:
+            nums1[k] = nums2[j]
+            j -= 1
+            k -= 1`,
 
                 typescript: `function merge(
     nums1: number[], m: number,
diff --git a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index 23325356..75508c14 100644
--- a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -251,7 +251,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                                 <span
                                     ><strong class="text-slate-700">残余は nums2 のみ</strong
                                     >：nums1 の残余は既に正しい位置にある。nums2
-                                    の残りのみスライス代入で処理</span
+                                    の残りのみコピーする</span
                                 >
                             </li>
                         </ul>
@@ -622,7 +622,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             ループバック
                         </text>
 
-                        <!-- 6. nums2 残余スライスコピー rect: y=492, h=60, bottom=552 -->
+                        <!-- 6. nums2 残余コピー rect: y=492, h=60, bottom=552 -->
                         <rect
                             x="60"
                             y="492"
@@ -642,7 +642,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             font-weight="bold"
                             fill="#1e293b"
                         >
-                            nums2 残余スライスコピー
+                            nums2 残余コピー
                         </text>
                         <text
                             x="280"
@@ -700,8 +700,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                     3. <strong>比較・書き込み</strong>：nums1[i] と nums2[j] を比較し大きい方を
                     nums1[k] に書き込み、対応するポインタを減算<br />
                     4. <strong>k-- 後に紫破線でループ条件へ戻る</strong>（不変条件 k ≥ i を維持）<br />
-                    5. <strong>残余コピー</strong>：nums2 が残っていれば CPython の memmove
-                    相当のスライス代入で高速一括コピー
+                    5. <strong>残余コピー</strong>：nums2 が残っていれば残りの要素をコピーする
                 </div>
             </section>
 
@@ -1316,9 +1315,11 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
                 j -= 1
             k -= 1
 
-        # nums2 残余: CPython の memmove 相当でスライス一括コピー
-        if j >= 0:
-            nums1[: j + 1] = nums2[: j + 1]`,
+        # nums2 残余コピー
+        while j >= 0:
+            nums1[k] = nums2[j]
+            j -= 1
+            k -= 1`,
 
                 typescript: `function merge(
     nums1: number[], m: number,

From 303c39daabf1ccf2b3ba6643a190b9fd291db383 Mon Sep 17 00:00:00 2001
From: myoshizumi <myoshizumi@alumni.berklee.edu>
Date: Sat, 14 Mar 2026 22:01:41 +0900
Subject: [PATCH 4/4] Refine LeetCode 88 (Python, Rust, TS): Synchronize
 complexity tables, update Rust/TS sort space complexity to O(m+n), and fix
 React UI flowchart text

---
 .../Merge_Sorted_Array_Python.md                     |  2 +-
 .../Merge_Sorted_Array_Rust.md                       |  2 +-
 .../Merge_Sorted_Array_TypeScript.md                 |  2 +-
 .../88. Merge Sorted Array/README.md                 |  2 +-
 .../88. Merge Sorted Array/README_React.html         | 12 ++++++------
 .../88. Merge Sorted Array/README_React.html         | 12 ++++++------
 6 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md
index f440a38c..69ef2826 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Python.md	
@@ -2,7 +2,7 @@
 
 ### 競技プログラミング視点
 
-`nums1` の末尾から逆順に埋める3ポインタ法が最適。CPython では `list` のインデックスアクセスは O(1) の C 実装であり、追加リスト生成ゼロ・ヒープアロケーションゼロで O(m+n) を達成できます。
+`nums1` の末尾から逆順に埋める3ポインタ法が最適。CPython では `list` のインデックスアクセスは O(1) の C 実装であり、本実装のようにスライス代入を用いると最悪ケース O(n) の追加空間を消費しますが、時間計算量 O(m+n) を達成できます。
 
 ### 業務開発視点
 
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md
index 9746c905..5901e8d4 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_Rust.md	
@@ -21,7 +21,7 @@ LeetCode の関数シグネチャは `&mut Vec<i32>` の受け渡しを強制し
 | アプローチ                  | 時間計算量       | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                      |
 | --------------------------- | ---------------- | ---------- | -------------- | ------ | ------ | ------------------------- |
 | 後ろからマージ（3ポインタ） | O(m+n)           | O(1)       | 低             | 高     | 高     | 追加アロケーションなし ✅ |
-| 前からコピー後ソート        | O((m+n)log(m+n)) | O(1)       | 低             | 高     | 高     | 標準の `.sort()` 利用可   |
+| 前からコピー後ソート        | O((m+n)log(m+n)) | O(m+n)     | 低             | 高     | 高     | 標準の `.sort()` 利用可   |
 | 一時バッファにコピー        | O(m+n)           | O(m)       | 低             | 高     | 中     | Vec への clone が発生     |
 
 ---
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md
index 7e1b1d4a..4ce86d4d 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/Merge_Sorted_Array_TypeScript.md	
@@ -21,7 +21,7 @@ LeetCode のシグネチャは `void` 返却の破壊的操作ですが、TypeSc
 | アプローチ                  | 時間計算量       | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                       |
 | --------------------------- | ---------------- | ---------- | ------------ | -------- | ------ | -------------------------- |
 | 後ろからマージ（3ポインタ） | O(m+n)           | O(1)       | 低           | 高       | 高     | 追加アロケーションなし ✅  |
-| コピー後 `.sort()`          | O((m+n)log(m+n)) | O(1)       | 最低         | 高       | 最高   | 比較関数必須・競技では次善 |
+| コピー後 `.sort()`          | O((m+n)log(m+n)) | O(m+n)     | 最低         | 高       | 最高   | 比較関数必須・競技では次善 |
 | 一時バッファにコピー        | O(m+n)           | O(m)       | 低           | 高       | 中     | スプレッド構文でヒープ確保 |
 
 ---
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md
index bf732eeb..90d4b75b 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README.md	
@@ -324,4 +324,4 @@ if n == 0:
 
 `from __future__ import annotations` を使用することで、
 型アノテーションの評価が **遅延評価（文字列化）** になり、
-実行時のインポートオーバーヘッドを最小化する。
\ No newline at end of file
+実行時のインポートオーバーヘッドを最小化する。
diff --git a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index bf139556..56c89362 100644
--- a/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -652,7 +652,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             font-size="12"
                             fill="#475569"
                         >
-                            nums1[:j+1] = nums2[:j+1]
+                            while j &gt;= 0: nums1[k] = nums2[j]; k--; j--
                         </text>
 
                         <line
@@ -753,7 +753,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                                     コピー後 .sort()
                                 </td>
                                 <td class="px-4 py-3 mono text-slate-600">O((m+n) log(m+n))</td>
-                                <td class="px-4 py-3 mono text-slate-600">O(1)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
                                 <td class="px-4 py-3 text-slate-600">実装最短だが計算量で劣る</td>
                             </tr>
                             <tr class="border-b border-slate-100">
@@ -1331,11 +1331,11 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
     let k: number = m + n - 1;  // 書き込み位置ポインタ (k >= i が常に成立)
 
     while (i >= 0 && j >= 0) {
-        if (nums1[i] >= nums2[j]) {
-            nums1[k] = nums1[i];
+        if (nums1[i]! >= nums2[j]!) {
+            nums1[k] = nums1[i]!;
             i--;
         } else {
-            nums1[k] = nums2[j];
+            nums1[k] = nums2[j]!;
             j--;
         }
         k--;
@@ -1343,7 +1343,7 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
 
     // nums2 の残余コピー (nums1 の残余は移動不要)
     while (j >= 0) {
-        nums1[k--] = nums2[j--];
+        nums1[k--] = nums2[j--]!;
     }
 }`,
 
diff --git a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html
index 75508c14..b639788d 100644
--- a/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
+++ b/public/Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html	
@@ -652,7 +652,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                             font-size="12"
                             fill="#475569"
                         >
-                            nums1[:j+1] = nums2[:j+1]
+                            while j &gt;= 0: nums1[k] = nums2[j]; k--; j--
                         </text>
 
                         <line
@@ -753,7 +753,7 @@ <h3 class="text-teal-800 font-bold text-lg mb-3">核心アイデア</h3>
                                     コピー後 .sort()
                                 </td>
                                 <td class="px-4 py-3 mono text-slate-600">O((m+n) log(m+n))</td>
-                                <td class="px-4 py-3 mono text-slate-600">O(1)</td>
+                                <td class="px-4 py-3 mono text-slate-600">O(m+n)</td>
                                 <td class="px-4 py-3 text-slate-600">実装最短だが計算量で劣る</td>
                             </tr>
                             <tr class="border-b border-slate-100">
@@ -1331,11 +1331,11 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
     let k: number = m + n - 1;  // 書き込み位置ポインタ (k >= i が常に成立)
 
     while (i >= 0 && j >= 0) {
-        if (nums1[i] >= nums2[j]) {
-            nums1[k] = nums1[i];
+        if (nums1[i]! >= nums2[j]!) {
+            nums1[k] = nums1[i]!;
             i--;
         } else {
-            nums1[k] = nums2[j];
+            nums1[k] = nums2[j]!;
             j--;
         }
         k--;
@@ -1343,7 +1343,7 @@ <h3 className="mt-0 text-teal-800 text-lg font-bold mb-2">
 
     // nums2 の残余コピー (nums1 の残余は移動不要)
     while (j >= 0) {
-        nums1[k--] = nums2[j--];
+        nums1[k--] = nums2[j--]!;
     }
 }`,