diff --git a/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.html b/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.html
index 6b914d66..1020806e 100644
--- a/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.html	
+++ b/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.html	
@@ -6,7 +6,7 @@
         <title>Best Divisor - √n約数列挙+桁和比較</title>
 
         <!-- Tailwind CSS -->
-        <script src="https://cdn.tailwindcss.com"></script>
+        <script src="https://cdn.tailwindcss.com" crossorigin="anonymous"></script>
 
         <!-- Google Fonts -->
         <link rel="preconnect" href="https://fonts.googleapis.com" />
@@ -20,14 +20,20 @@
         <link
             href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
             rel="stylesheet"
+            integrity="sha512-vswe+cgvic/XBoF1OcM/TeJ2FW0OofqAVdCZiEYkd6dwGXthvkSFWOoGGJgS2CW70VK5dQM5Oh+7ne47s74VTg=="
+            crossorigin="anonymous"
         />
         <link
             href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
             rel="stylesheet"
+            integrity="sha512-cbQXwDFK7lj2Fqfkuxbo5iD1dSbLlJGXGpfTDqbggqjHJeyzx88I3rfwjS38WJag/ihH7lzuGlGHpDBymLirZQ=="
+            crossorigin="anonymous"
         />
         <link
             href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
             rel="stylesheet"
+            integrity="sha512-Dqf5696xtofgH089BgZJo2lSWTvev4GFo+gA2o4GullFY65rzQVQLQVlzLvYwTo0Bb2Gpb6IqwxYWtoMonfdhQ=="
+            crossorigin="anonymous"
         />
 
         <style>
@@ -284,7 +290,12 @@ <h3 class="text-lg font-bold text-slate-700 mb-3">📖 フローチャートの
                         style="max-width: 100%; height: auto; color: #333"
                         role="img"
                         aria-label="Best Divisor flowchart"
+                        aria-describedby="flowchart-desc"
                     >
+                        <title>Best Divisor アルゴリズムのフローチャート</title>
+                        <desc id="flowchart-desc">
+                            √n約数列挙アルゴリズムの処理フローを示す図。入力から約数列挙、桁和計算、最良約数選択までの9ステップを視覚化しています。
+                        </desc>
                         <defs>
                             <!-- 矢印マーカー（大きめに調整） -->
                             <marker
@@ -1203,11 +1214,31 @@ <h3 class="text-xl font-bold text-teal-800 mt-8 mb-3">具体例での計算量</
         <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
 
         <!-- Prism.js -->
-        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
-        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"></script>
-        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"></script>
-        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"></script>
-        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"
+            integrity="sha512-7Z9J3l1+EYfeaPKcGXu3MS/7T+w19WtKQY/n+xzmw4hZhJ9tyYmcUS+4QqAlzhicE5LAfMQSF3iFTK9bQdTxXg=="
+            crossorigin="anonymous"
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"
+            integrity="sha512-AKaNmg8COK0zEbjTdMHJAPJ0z6VeNqvRvH4mfRRWDO9CMxRqi0BlcjWXELn7AbfCvLsZ/SBv8kNEGZOJVdWRCQ=="
+            crossorigin="anonymous"
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"
+            integrity="sha512-BttltKXFyWnGZQcRWj6osIg7lbizJchuAMotOkdLxHxwt/Hyo+cl47bZU0QADg+Qt5DJwni3SbYGXeGMB5cBcw=="
+            crossorigin="anonymous"
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"
+            integrity="sha512-st608h+ZqzliahyzEpETxzU0f7z7a9acN6AFvYmHvpFhmcFuKT8a22TT5TpKpjDa3pt3Wv7Z3SdQBCBdDPhyWA=="
+            crossorigin="anonymous"
+        ></script>
+        <script
+            src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"
+            integrity="sha512-/kVH1yrq7ajXhLpvjMxXJqPp6R9w7bqCjW5xhPjGAJTo9JTlx2NjQnM4+Q8dWmjJoMTaYVm7/ZqfqbWLGz+CIQ=="
+            crossorigin="anonymous"
+        ></script>
 
         <!-- React Component -->
         <script type="text/babel">
@@ -1340,7 +1371,7 @@ <h3 class="text-xl font-bold text-teal-800 mt-8 mb-3">具体例での計算量</
                         >
                             <defs>
                                 <marker
-                                    id="arrow"
+                                    id="step-arrow"
                                     markerWidth="10"
                                     markerHeight="10"
                                     refX="9"
@@ -1976,7 +2007,7 @@ <h3 class="text-xl font-bold text-teal-800 mt-8 mb-3">具体例での計算量</
                                 stroke="#64748b"
                                 strokeWidth="3"
                                 fill="none"
-                                markerEnd="url(#arrow)"
+                                markerEnd="url(#step-arrow)"
                             />
                             <text
                                 x="295"
@@ -2100,7 +2131,7 @@ <h3 class="text-xl font-bold text-teal-800 mt-8 mb-3">具体例での計算量</
                     return () => {
                         if (timerRef.current) clearTimeout(timerRef.current);
                     };
-                }, [isPlaying, activeStep]);
+                }, [isPlaying, activeStep, stepsData.length]);
 
                 const handlePlay = () => {
                     if (isPlaying) return;
diff --git a/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.ipynb b/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.ipynb
index 8baaa645..6c4c376b 100644
--- a/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.ipynb	
+++ b/Mathematics/Fundamentals/HackerRank/Claude/Easy/Best Divisor/BestDivisor.ipynb	
@@ -1,407 +1,261 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "3e4cb1d9",
-   "metadata": {},
-   "source": [
-    "# 問題分析と実装\n",
-    "\n",
-    "## 1. 問題分析結果\n",
-    "\n",
-    "### 競技プログラミング視点\n",
-    "- **制約分析**: n ≤ 10^5 → O(√n) の約数列挙で十分\n",
-    "- **最速手法**: √n までループして約数を収集、桁和を組み込み関数で計算\n",
-    "- **メモリ最小化**: 約数の数は高々O(√n)、桁和計算は即座に実行\n",
-    "- **CPython最適化**: `sum()`と文字列変換、`max()`のkey引数を活用\n",
-    "\n",
-    "### 業務開発視点\n",
-    "- **型安全設計**: 入力検証、厳密な型ヒント\n",
-    "- **エラーハンドリング**: 不正入力の検証\n",
-    "- **可読性**: 明確な関数分割、詳細なdocstring\n",
-    "\n",
-    "### Python特有分析\n",
-    "- **データ構造選択**: リストで約数を保持（順序不要、重複なし）\n",
-    "- **標準ライブラリ活用度**: 組み込み関数`sum()`, `max()`を効果的に使用\n",
-    "- **CPython最適化度**: 文字列変換とジェネレータ式でC実装を活用\n",
-    "\n",
-    "## 2. 採用アルゴリズムと根拠\n",
-    "\n",
-    "### アルゴリズム比較表\n",
-    "\n",
-    "|アプローチ|時間計算量|空間計算量|Python実装コスト|可読性|標準ライブラリ活用|CPython最適化|備考|\n",
-    "|---------|---------|---------|---------------|------|----------------|------------|-----|\n",
-    "|√n約数列挙|O(√n)|O(d)|低|★★★|sum(), max()|適|dは約数の個数|\n",
-    "|全探索|O(n)|O(d)|低|★★☆|同上|適|非効率|\n",
-    "\n",
-    "**選択理由**: O(√n)で全約数を列挙可能。桁和計算は定数時間（桁数は高々log n）。Pythonの組み込み関数を最大活用。\n",
-    "\n",
-    "**Python最適化戦略**:\n",
-    "- `sum(int(d) for d in str(num))`: ジェネレータ式とC実装のsumを活用\n",
-    "- `max(divisors, key=...)`: C実装のmax関数でソート不要\n",
-    "\n",
-    "## 3. 実装パターン\n",
-    "\n",
-    "```python\n",
-    "from typing import List, Tuple\n",
-    "\n",
-    "class Solution:\n",
-    "    \"\"\"\n",
-    "    最良の約数を見つける問題の解決クラス\n",
-    "    \n",
-    "    競技プログラミング向けと業務開発向けの2パターンを提供\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def findBestDivisor(self, n: int) -> int:\n",
-    "        \"\"\"\n",
-    "        業務開発向け実装（型安全・エラーハンドリング重視）\n",
-    "        \n",
-    "        Args:\n",
-    "            n: 正の整数（1 ≤ n ≤ 10^5）\n",
-    "            \n",
-    "        Returns:\n",
-    "            最良の約数（桁和が最大、同じなら最小値）\n",
-    "            \n",
-    "        Raises:\n",
-    "            ValueError: 入力値が制約を満たさない場合\n",
-    "            TypeError: 入力型が不正な場合\n",
-    "            \n",
-    "        Time Complexity: O(√n + d)\n",
-    "        Space Complexity: O(d)\n",
-    "        \"\"\"\n",
-    "        # 1. 入力検証\n",
-    "        self._validate_input(n)\n",
-    "        \n",
-    "        # 2. 約数を列挙\n",
-    "        divisors = self._find_divisors(n)\n",
-    "        \n",
-    "        # 3. 最良の約数を選択\n",
-    "        best_divisor = self._select_best_divisor(divisors)\n",
-    "        \n",
-    "        return best_divisor\n",
-    "    \n",
-    "    def findBestDivisorCompetitive(self, n: int) -> int:\n",
-    "        \"\"\"\n",
-    "        競技プログラミング向け最適化実装\n",
-    "        \n",
-    "        Time Complexity: O(√n)\n",
-    "        Space Complexity: O(d)\n",
-    "        \"\"\"\n",
-    "        divisors: List[int] = []\n",
-    "        i = 1\n",
-    "        while i * i <= n:\n",
-    "            if n % i == 0:\n",
-    "                divisors.append(i)\n",
-    "                if i != n // i:\n",
-    "                    divisors.append(n // i)\n",
-    "            i += 1\n",
-    "        \n",
-    "        # 桁和が最大、同値なら最小値を選択\n",
-    "        return max(divisors, key=lambda x: (sum(int(d) for d in str(x)), -x))\n",
-    "    \n",
-    "    def _validate_input(self, n: int) -> None:\n",
-    "        \"\"\"型安全な入力検証\"\"\"\n",
-    "        if not isinstance(n, int):\n",
-    "            raise TypeError(f\"Input must be integer, got {type(n)}\")\n",
-    "        \n",
-    "        if n < 1 or n > 10**5:\n",
-    "            raise ValueError(f\"Input must be in range [1, 10^5], got {n}\")\n",
-    "    \n",
-    "    def _find_divisors(self, n: int) -> List[int]:\n",
-    "        \"\"\"\n",
-    "        nの全約数を列挙\n",
-    "        \n",
-    "        Args:\n",
-    "            n: 正の整数\n",
-    "            \n",
-    "        Returns:\n",
-    "            約数のリスト\n",
-    "        \"\"\"\n",
-    "        divisors: List[int] = []\n",
-    "        i = 1\n",
-    "        # √nまでループして約数をペアで収集\n",
-    "        while i * i <= n:\n",
-    "            if n % i == 0:\n",
-    "                divisors.append(i)\n",
-    "                # i ≠ n/i の場合のみ追加（平方数対策）\n",
-    "                if i != n // i:\n",
-    "                    divisors.append(n // i)\n",
-    "            i += 1\n",
-    "        \n",
-    "        return divisors\n",
-    "    \n",
-    "    def _digit_sum(self, num: int) -> int:\n",
-    "        \"\"\"\n",
-    "        数値の桁和を計算\n",
-    "        \n",
-    "        Args:\n",
-    "            num: 正の整数\n",
-    "            \n",
-    "        Returns:\n",
-    "            各桁の合計\n",
-    "        \"\"\"\n",
-    "        # 文字列変換とsum()でCPython最適化\n",
-    "        return sum(int(digit) for digit in str(num))\n",
-    "    \n",
-    "    def _select_best_divisor(self, divisors: List[int]) -> int:\n",
-    "        \"\"\"\n",
-    "        最良の約数を選択\n",
-    "        \n",
-    "        Args:\n",
-    "            divisors: 約数のリスト\n",
-    "            \n",
-    "        Returns:\n",
-    "            最良の約数（桁和最大、同値なら最小値）\n",
-    "        \"\"\"\n",
-    "        # max()のkey引数を使用\n",
-    "        # タプルで優先順位: (桁和が大きい, 値が小さい)\n",
-    "        return max(divisors, key=lambda x: (self._digit_sum(x), -x))\n",
-    "\n",
-    "\n",
-    "# メイン処理\n",
-    "if __name__ == '__main__':\n",
-    "    n = int(input().strip())\n",
-    "    solution = Solution()\n",
-    "    # 競技プログラミング版を使用（高速）\n",
-    "    result = solution.findBestDivisorCompetitive(n)\n",
-    "    print(result)\n",
-    "```\n",
-    "\n",
-    "## 4. 検証\n",
-    "\n",
-    "### 境界値テスト\n",
-    "- **n = 1**: 約数は1のみ → 出力: 1\n",
-    "- **n = 12**: 約数 {1,2,3,4,6,12}、桁和 {1,2,3,4,6,3} → 最大6 → 出力: 6 ✓\n",
-    "- **n = 100**: 約数に10(桁和1), 20(桁和2), 25(桁和7), 50(桁和5)等 → 桁和最大を選択\n",
-    "\n",
-    "### Python特有の最適化ポイント\n",
-    "1. **組み込み関数**: `sum()`, `max()` はC実装で高速\n",
-    "2. **ジェネレータ式**: `sum(int(d) for d in str(x))` はメモリ効率的\n",
-    "3. **文字列変換**: 桁和計算で算術演算より簡潔かつ高速\n",
-    "4. **タプル比較**: `max(key=lambda x: (a, -b))` で複数条件ソート"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9086447b",
-   "metadata": {},
-   "source": [
-    "# コード全体の目的\n",
-    "\n",
-    "**入力:** 整数 `n`\n",
-    "**出力:**\n",
-    "\n",
-    "* 約数の中で **桁和（各桁の合計）が最大のもの**\n",
-    "* 桁和が同じなら **数値が小さい方**\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# コード本体\n",
-    "\n",
-    "```python\n",
-    "def findBestDivisor(n: int) -> int:\n",
-    "```\n",
-    "\n",
-    "`n` の「最良の約数」を求める関数です。\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# 計算量の意図（docstring）\n",
-    "\n",
-    "```python\n",
-    "\"\"\"\n",
-    "Time Complexity: O(√n)\n",
-    "Space Complexity: O(d) where d is number of divisors\n",
-    "\"\"\"\n",
-    "```\n",
-    "\n",
-    "### ✔ 時間計算量 `O(√n)`\n",
-    "\n",
-    "約数探索を √n までに制限して高速化。\n",
-    "\n",
-    "### ✔ 空間計算量 `O(d)`\n",
-    "\n",
-    "約数の個数 `d` 分だけメモリ使用。\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# 約数収集ロジック（√n 最適化）\n",
-    "\n",
-    "```python\n",
-    "divisors = []\n",
-    "i = 1\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "```python\n",
-    "while i * i <= n:\n",
-    "```\n",
-    "\n",
-    "### なぜ √n までで良い？\n",
-    "\n",
-    "約数は **ペア（i, n//i）** で現れるため、√n まで探索すれば十分。\n",
-    "\n",
-    "---\n",
-    "\n",
-    "```python\n",
-    "if n % i == 0:\n",
-    "    divisors.append(i)\n",
-    "```\n",
-    "\n",
-    "`i` が約数なら追加。\n",
-    "\n",
-    "---\n",
-    "\n",
-    "```python\n",
-    "if i != n // i:\n",
-    "    divisors.append(n // i)\n",
-    "```\n",
-    "\n",
-    "### ✔ 平方数対策\n",
-    "\n",
-    "* `n = 36` のとき `i = 6` → `6 * 6`\n",
-    "* 同じ約数を **2回追加しない** ように防止\n",
-    "\n",
-    "---\n",
-    "\n",
-    "### ✔ 結果として\n",
-    "\n",
-    "**全ての約数を漏れなく収集**\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# 約数の選択ルール（最重要）\n",
-    "\n",
-    "```python\n",
-    "return max(divisors, key=lambda x: (sum(int(d) for d in str(x)), -x))\n",
-    "```\n",
-    "\n",
-    "---\n",
-    "\n",
-    "## 評価基準（タプル比較）\n",
-    "\n",
-    "```python\n",
-    "(sum_of_digits(x), -x)\n",
-    "```\n",
-    "\n",
-    "### ① 桁和が大きいものを優先\n",
-    "\n",
-    "```python\n",
-    "sum(int(d) for d in str(x))\n",
-    "```\n",
-    "\n",
-    "例:\n",
-    "\n",
-    "* 84 → 8+4 = 12\n",
-    "* 96 → 9+6 = 15（勝ち）\n",
-    "\n",
-    "---\n",
-    "\n",
-    "### ② 桁和が同じなら「値が小さい方」\n",
-    "\n",
-    "```python\n",
-    "-x\n",
-    "```\n",
-    "\n",
-    "**max() なので、値を反転することで「小さい数を優先」**\n",
-    "\n",
-    "例:\n",
-    "\n",
-    "* 39 (3+9=12)\n",
-    "* 48 (4+8=12)\n",
-    "\n",
-    "同じ桁和 → **39 を選ぶ**\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# 実行例\n",
-    "\n",
-    "### 入力\n",
-    "\n",
-    "```\n",
-    "n = 100\n",
-    "```\n",
-    "\n",
-    "### 約数\n",
-    "\n",
-    "```\n",
-    "1, 2, 4, 5, 10, 20, 25, 50, 100\n",
-    "```\n",
-    "\n",
-    "### 桁和\n",
-    "\n",
-    "| 約数  | 桁和 |\n",
-    "| --- | -- |\n",
-    "| 1   | 1  |\n",
-    "| 2   | 2  |\n",
-    "| 4   | 4  |\n",
-    "| 5   | 5  |\n",
-    "| 10  | 1  |\n",
-    "| 20  | 2  |\n",
-    "| 25  | 7  |\n",
-    "| 50  | 5  |\n",
-    "| 100 | 1  |\n",
-    "\n",
-    "### ✔ 最大は `25`（7）\n",
-    "\n",
-    "→ 出力 `25`\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# main 部分\n",
-    "\n",
-    "```python\n",
-    "if __name__ == '__main__':\n",
-    "    n = int(input().strip())\n",
-    "    result = findBestDivisor(n)\n",
-    "    print(result)\n",
-    "```\n",
-    "\n",
-    "標準入力から整数を受け取り、結果を出力。\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# アルゴリズムの強み\n",
-    "\n",
-    "| 項目       | 評価                 |\n",
-    "| -------- | ------------------ |\n",
-    "| 高速       | √n で約数探索           |\n",
-    "| 無駄がない    | 約数ペア回収             |\n",
-    "| Pythonic | `max(key=...)` で簡潔 |\n",
-    "| 競プロ向き    | 大きな n にも対応         |\n",
-    "\n",
-    "---\n",
-    "\n",
-    "# 改善・代替案（さらに最適化）\n",
-    "\n",
-    "## メモリを使わず直接最大を更新（O(1) space）\n",
-    "\n",
-    "```python\n",
-    "def findBestDivisor(n):\n",
-    "    best = 1\n",
-    "    best_sum = 1\n",
-    "    \n",
-    "    i = 1\n",
-    "    while i * i <= n:\n",
-    "        if n % i == 0:\n",
-    "            for d in (i, n // i):\n",
-    "                s = sum(map(int, str(d)))\n",
-    "                if s > best_sum or (s == best_sum and d < best):\n",
-    "                    best = d\n",
-    "                    best_sum = s\n",
-    "        i += 1\n",
-    "    \n",
-    "    return best\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "3e4cb1d9",
+            "metadata": {},
+            "source": [
+                "# 問題分析と実装\n",
+                "\n",
+                "## 1. 問題分析結果\n",
+                "\n",
+                "### 競技プログラミング視点\n",
+                "- **制約分析**: n ≤ 10^5 → O(√n) の約数列挙で十分\n",
+                "- **最速手法**: √n までループして約数を収集、桁和を組み込み関数で計算\n",
+                "- **メモリ最小化**: 約数の数は高々O(√n)、桁和計算は即座に実行\n",
+                "- **CPython最適化**: `sum()`と文字列変換、`max()`のkey引数を活用\n",
+                "\n",
+                "### 業務開発視点\n",
+                "- **型安全設計**: 入力検証、厳密な型ヒント\n",
+                "- **エラーハンドリング**: 不正入力の検証\n",
+                "- **可読性**: 明確な関数分割、詳細なdocstring\n",
+                "\n",
+                "### Python特有分析\n",
+                "- **データ構造選択**: リストで約数を保持（順序不要、重複なし）\n",
+                "- **標準ライブラリ活用度**: 組み込み関数`sum()`, `max()`を効果的に使用\n",
+                "- **CPython最適化度**: 文字列変換とジェネレータ式でC実装を活用\n",
+                "\n",
+                "## 2. 採用アルゴリズムと根拠\n",
+                "\n",
+                "### アルゴリズム比較表\n",
+                "\n",
+                "|アプローチ|時間計算量|空間計算量|Python実装コスト|可読性|標準ライブラリ活用|CPython最適化|備考|\n",
+                "|---------|---------|---------|---------------|------|----------------|------------|-----|\n",
+                "|√n約数列挙|O(√n + d·log n)|O(d)|低|★★★|sum(), max()|適|dは約数の個数、桁和計算がO(log n)|\n",
+                "|全探索|O(n·log n)|O(d)|低|★★☆|同上|適|非効率|\n",
+                "\n",
+                "**選択理由**: O(√n)で全約数を列挙可能。桁和計算は各約数につきO(log n)（桁数はlog n）。Pythonの組み込み関数を最大活用。\n",
+                "\n",
+                "**Python最適化戦略**:\n",
+                "- `sum(int(d) for d in str(num))`: ジェネレータ式とC実装のsumを活用\n",
+                "- `max(divisors, key=...)`: C実装のmax関数でソート不要\n",
+                "\n",
+                "## 3. 実装パターン"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "implementation",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from typing import List\n",
+                "\n",
+                "def findBestDivisor(n: int) -> int:\n",
+                "    \"\"\"\n",
+                "    最良の約数を見つける（競技プログラミング最適化版）\n",
+                "    \n",
+                "    Args:\n",
+                "        n: 正の整数（1 ≤ n ≤ 10^5）\n",
+                "        \n",
+                "    Returns:\n",
+                "        最良の約数（桁和が最大、同じなら最小値）\n",
+                "        \n",
+                "    Time Complexity: O(√n + d·log n) where d is number of divisors\n",
+                "    Space Complexity: O(d)\n",
+                "    \"\"\"\n",
+                "    divisors: List[int] = []\n",
+                "    i = 1\n",
+                "    \n",
+                "    # √n まで探索して約数をペアで収集\n",
+                "    while i * i <= n:\n",
+                "        if n % i == 0:\n",
+                "            divisors.append(i)\n",
+                "            # 平方数でない場合のみペアを追加\n",
+                "            if i != n // i:\n",
+                "                divisors.append(n // i)\n",
+                "        i += 1\n",
+                "    \n",
+                "    # 桁和が最大、同値なら最小値を選択\n",
+                "    # タプル比較: (桁和大, 値小) = (sum, -divisor)\n",
+                "    return max(divisors, key=lambda x: (sum(int(d) for d in str(x)), -x))"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "test_section",
+            "metadata": {},
+            "source": [
+                "## 4. 検証\n",
+                "\n",
+                "### テストケース"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "validation",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# テストケース実行\n",
+                "test_cases = [\n",
+                "    (1, 1),      # 約数は1のみ\n",
+                "    (12, 6),     # 12の約数 {1,2,3,4,6,12}、桁和 {1,2,3,4,6,3} → 最大6\n",
+                "    (100, 25),   # 100の約数で桁和最大は25 (2+5=7)\n",
+                "]\n",
+                "\n",
+                "print(\"=== テスト実行 ===\")\n",
+                "for n, expected in test_cases:\n",
+                "    result = findBestDivisor(n)\n",
+                "    status = \"✓\" if result == expected else \"✗\"\n",
+                "    print(f\"{status} n={n}: expected={expected}, got={result}\")\n",
+                "\n",
+                "# 詳細デバッグ用\n",
+                "print(\"\\n=== n=12 の詳細 ===\")\n",
+                "n = 12\n",
+                "divisors = []\n",
+                "i = 1\n",
+                "while i * i <= n:\n",
+                "    if n % i == 0:\n",
+                "        divisors.append(i)\n",
+                "        if i != n // i:\n",
+                "            divisors.append(n // i)\n",
+                "    i += 1\n",
+                "\n",
+                "print(f\"約数: {sorted(divisors)}\")\n",
+                "for d in sorted(divisors):\n",
+                "    digit_sum = sum(int(digit) for digit in str(d))\n",
+                "    print(f\"  {d} → 桁和 = {digit_sum}\")\n",
+                "print(f\"最良約数: {findBestDivisor(n)}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "explanation",
+            "metadata": {},
+            "source": [
+                "### Python特有の最適化ポイント\n",
+                "1. **組み込み関数**: `sum()`, `max()` はC実装で高速\n",
+                "2. **ジェネレータ式**: `sum(int(d) for d in str(x))` はメモリ効率的\n",
+                "3. **文字列変換**: 桁和計算で算術演算より簡潔かつ高速\n",
+                "4. **タプル比較**: `max(key=lambda x: (a, -b))` で複数条件ソート"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "detailed_explanation",
+            "metadata": {},
+            "source": [
+                "# コード詳細解説\n",
+                "\n",
+                "## コード全体の目的\n",
+                "\n",
+                "**入力:** 整数 `n`  \n",
+                "**出力:**\n",
+                "* 約数の中で **桁和（各桁の合計）が最大のもの**\n",
+                "* 桁和が同じなら **数値が小さい方**\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## 計算量の意図\n",
+                "\n",
+                "### ✔ 時間計算量 `O(√n + d·log n)`\n",
+                "\n",
+                "- 約数探索を √n までに制限: O(√n)\n",
+                "- 各約数の桁和計算: O(log n) × d個\n",
+                "\n",
+                "### ✔ 空間計算量 `O(d)`\n",
+                "\n",
+                "約数の個数 `d` 分だけメモリ使用。\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## 約数収集ロジック（√n 最適化）\n",
+                "\n",
+                "### なぜ √n までで良い？\n",
+                "\n",
+                "約数は **ペア（i, n//i）** で現れるため、√n まで探索すれば十分。\n",
+                "\n",
+                "### ✔ 平方数対策\n",
+                "\n",
+                "* `n = 36` のとき `i = 6` → `6 * 6`\n",
+                "* 同じ約数を **2回追加しない** ように防止（`i != n // i` でチェック）\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## 約数の選択ルール（最重要）\n",
+                "\n",
+                "```python\n",
+                "max(divisors, key=lambda x: (sum(int(d) for d in str(x)), -x))\n",
+                "```\n",
+                "\n",
+                "### 評価基準（タプル比較）\n",
+                "\n",
+                "#### ① 桁和が大きいものを優先\n",
+                "\n",
+                "例:\n",
+                "* 84 → 8+4 = 12\n",
+                "* 96 → 9+6 = 15（勝ち）\n",
+                "\n",
+                "#### ② 桁和が同じなら「値が小さい方」\n",
+                "\n",
+                "**max() なので、値を反転することで「小さい数を優先」**\n",
+                "\n",
+                "例:\n",
+                "* 39 (3+9=12)\n",
+                "* 48 (4+8=12)\n",
+                "\n",
+                "同じ桁和 → **39 を選ぶ**\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## 実行例\n",
+                "\n",
+                "### 入力: n = 100\n",
+                "\n",
+                "### 約数\n",
+                "```\n",
+                "1, 2, 4, 5, 10, 20, 25, 50, 100\n",
+                "```\n",
+                "\n",
+                "### 桁和\n",
+                "\n",
+                "| 約数  | 桁和 |\n",
+                "| --- | -- |\n",
+                "| 1   | 1  |\n",
+                "| 2   | 2  |\n",
+                "| 4   | 4  |\n",
+                "| 5   | 5  |\n",
+                "| 10  | 1  |\n",
+                "| 20  | 2  |\n",
+                "| 25  | 7  |\n",
+                "| 50  | 5  |\n",
+                "| 100 | 1  |\n",
+                "\n",
+                "### ✔ 最大は `25`（7）\n",
+                "\n",
+                "→ 出力 `25`\n",
+                "\n",
+                "---\n",
+                "\n",
+                "## アルゴリズムの強み\n",
+                "\n",
+                "| 項目       | 評価                 |\n",
+                "| -------- | ------------------ |\n",
+                "| 高速       | √n で約数探索           |\n",
+                "| 無駄がない    | 約数ペア回収、重複防止       |\n",
+                "| Pythonic | `max(key=...)` で簡潔 |\n",
+                "| 競プロ向き    | 大きな n にも対応         |"
+            ]
+        }
+    ],
+    "metadata": {
+        "language_info": {
+            "name": "python"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
 }