docs: update README.md and add Sqrt(x) solution

Author: myoshi2891

Algorithm/BinarySearch/leetcode/69. Sqrt(x)/Claude4.6 extended/README.md

@@ -0,0 +1,199 @@
+## 1. 問題分析結果
+
+## 競技プログラミング視点
+
+- 制約 `0 ≤ x ≤ 2³¹ - 1` → 探索空間は最大 `~46340` → **二分探索で最大31回**のイテレーションで確定
+- Python の `int` は任意精度 → オーバーフロー完全ゼロ・キャスト不要（Rust/TSと異なる大きな利点）
+- `x >> 1` でビットシフト整数除算 → CPython の `BINARY_OP` 最適化が効く
+- `math.sqrt` / `**` / `pow` は使用禁止 → 純粋な整数演算のみで完結
+
+## 業務開発視点
+
+- 入力は `int` だが、`float`・`str`・負数が混入する可能性 → **実行時型ガード**が必要
+- `pylance` 対応: 戻り値型 `int` を明示し、`isinstance` ガードで型を narrowing
+- `ValueError` / `TypeError` を使い分けて呼び出し元が例外種別で判断できるように設計
+
+## Python特有分析
+
+- **データ構造**: 変数3つ（`low`, `high`, `mid`）のみ → `list`/`deque` 不要
+- **標準ライブラリ活用**: `math` モジュールは使用禁止のため不使用。ビットシフト演算子のみ
+- **CPython最適化**: `while` ループ + ビットシフト → 組み込み演算子レベルで最速
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+| アプローチ        | 時間計算量   | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用 | CPython最適化 | 備考                    |
+| ----------------- | ------------ | ---------- | ---------------- | ------ | ------------------ | ------------- | ----------------------- |
+| **線形探索**      | O(√n)        | O(1)       | 低               | ★★★    | なし               | 適            | x=2³¹で~46340回、非効率 |
+| **二分探索**      | O(log n)     | O(1)       | 低               | ★★★    | なし               | ✅ 適         | 整数演算のみ・誤差ゼロ  |
+| **ニュートン法**  | O(log log n) | O(1)       | 中               | ★★☆    | なし               | 不適          | float収束判定が曖昧     |
+| **`isqrt()`使用** | O(log n)     | O(1)       | 最低             | ★★★    | `math.isqrt`       | 適            | 問題の禁止制約に抵触    |
+
+---
+
+## 3. 採用アルゴリズムと根拠
+
+- **選択**: 二分探索（Binary Search）
+- **理由**: O(log n)・整数演算のみ・Python の任意精度 `int` でオーバーフロー皆無・Loop Invariant が明確で保守性最高
+- **Python最適化戦略**: `x >> 1`（ビットシフト）+ `(low + high) >> 1`（中点計算）で CPython のバイトコード最適化を最大活用
+- **トレードオフ**: ニュートン法は収束が速いが `float` の誤差管理が複雑 → 保守性 vs わずかな速度差で二分探索を選択
+
+---
+
+## 4. 実装コード
+
+```python
+# Runtime 3 ms
+# Beats 66.79%
+# Memory 19.32 MB
+# Beats 57.57%
+
+class Solution:
+    """
+    Sqrt(x) — 整数平方根（切り捨て）
+    math.sqrt / ** 演算子禁止・二分探索で実装
+    """
+
+    # ------------------------------------------------------------------ #
+    #  業務開発版（型安全・エラーハンドリング・pylance 対応）
+    # ------------------------------------------------------------------ #
+    def mySqrt(self, x: int) -> int:
+        """
+        非負整数 x の平方根を小数点以下切り捨てで返す。
+
+        Args:
+            x: 非負整数 (0 ≤ x ≤ 2^31 - 1)
+
+        Returns:
+            floor(√x) の整数値
+
+        Raises:
+            TypeError:  x が int でない場合
+            ValueError: x が負数または制約超過の場合
+
+        Complexity:
+            Time:  O(log n) — 最大 31 回のイテレーション
+            Space: O(1)     — 固定変数のみ、追加アロケーションなし
+        """
+        # ── 実行時型ガード（pylance narrowing 対応） ──────────────────
+        if not isinstance(x, int) or isinstance(x, bool):
+            raise TypeError(f"x must be int, got {type(x).__name__!r}")
+
+        if x < 0:
+            raise ValueError(f"x must be non-negative, got {x}")
+
+        if x > 2**31 - 1:
+            raise ValueError(f"x={x} exceeds constraint 2^31 - 1")
+
+        return self._binary_search_sqrt(x)
+
+    def _binary_search_sqrt(self, x: int) -> int:
+        """
+        二分探索による整数平方根の計算（内部実装）。
+
+        Loop Invariant:
+            low  - 1 の二乗は x 以下
+            high + 1 の二乗は x より大きい
+        → ループ終了時: high = floor(√x)
+
+        Args:
+            x: 検証済み非負整数
+
+        Returns:
+            floor(√x)
+        """
+        # ── エッジケース早期リターン ──────────────────────────────────
+        # x=0 → 0、x=1 → 1（ループを回さず即リターン）
+        if x < 2:
+            return x
+
+        # ── 二分探索 ─────────────────────────────────────────────────
+        # 探索範囲: [1, x // 2]
+        # 根拠: x >= 2 のとき floor(√x) <= x // 2 が常に成立
+        low: int = 1
+        high: int = x >> 1  # == x // 2（ビットシフトで整数除算）
+
+        while low <= high:
+            # オーバーフロー不要（Python の int は任意精度）だが
+            # ビットシフトで中点計算 → CPython バイトコード最適化
+            mid: int = (low + high) >> 1
+            square: int = mid * mid
+
+            if square == x:
+                # 完全平方数: mid が答えそのもの
+                return mid
+            elif square < x:
+                # mid が小さすぎる → 下限を引き上げ
+                low = mid + 1
+            else:
+                # mid が大きすぎる → 上限を引き下げ
+                high = mid - 1
+
+        # ループ終了後: high = floor(√x)
+        # 例: x=8 → mid=2(4<8)→low=3, mid=3(9>8)→high=2
+        #     low(3) > high(2) → return 2 ✓
+        return high
+
+    # ------------------------------------------------------------------ #
+    #  競技プログラミング版（型チェック・docstring 省略・速度最優先）
+    # ------------------------------------------------------------------ #
+    def mySqrt_competitive(self, x: int) -> int:
+        """
+        Competitive: O(log n) / O(1)
+        エラーハンドリング省略・CPython 最速パターン
+        """
+        if x < 2:
+            return x
+
+        low, high = 1, x >> 1
+
+        while low <= high:
+            mid = (low + high) >> 1
+            sq = mid * mid
+            if sq == x:
+                return mid
+            elif sq < x:
+                low = mid + 1
+            else:
+                high = mid - 1
+
+        return high
+```
+
+---
+
+## 5. アルゴリズム動作トレース
+
+```
+─── x = 4 ─────────────────────────────────────────────────────
+  初期値: low=1, high=2
+
+  Iter 1: mid=1, sq=1  < 4  → low=2
+  Iter 2: mid=2, sq=4 == 4  → return 2  ✓
+
+─── x = 8 ─────────────────────────────────────────────────────
+  初期値: low=1, high=4
+
+  Iter 1: mid=2, sq=4  < 8  → low=3
+  Iter 2: mid=3, sq=9  > 8  → high=2
+  low(3) > high(2) → return high=2  ✓
+
+─── エッジケース ────────────────────────────────────────────────
+  x=0  → early return 0
+  x=1  → early return 1
+  x=2  → low=1,high=1 → mid=1(1<2)→low=2 → 終了: return 1  ✓
+  x=2147483647 → return 46340
+```
+
+---
+
+## 6. Python固有の設計ポイント整理
+
+| 観点                       | 実装での対応                                                                |
+| -------------------------- | --------------------------------------------------------------------------- |
+| **オーバーフロー完全ゼロ** | Python `int` は任意精度 → `u64` キャスト（Rust）が不要                      |
+| **型narrowing (pylance)**  | `isinstance(x, int) and not isinstance(x, bool)` で `bool` 混入も排除       |
+| **ビットシフト最適化**     | `x >> 1` / `(low+high) >> 1` → CPython `BINARY_OP` 命令で最速               |
+| **`bool` ガード**          | Python では `bool` は `int` のサブクラス → `isinstance(x, bool)` で明示排除 |
+| **2パターン分離**          | 業務版（型安全）と競技版（速度最優先）を明確に分離し保守性向上              |

Algorithm/BinarySearch/leetcode/69. Sqrt(x)/Claude4.6 extended/README_react.html

@@ -0,0 +1,167 @@
+## 1. 問題の分析
+
+## 競技プログラミング視点での分析
+
+- 探索空間 `[0, x]` は単調増加 → **二分探索**が最適（最大31回のイテレーション）
+- `u32::MAX = 2³¹ - 1 = 2147483647` → `mid * mid` は最大 `u64` で `~4.6 × 10¹⁸` に達するため、**`u64` へのキャスト**でオーバーフローを防止
+- スタックのみ使用・ヒープアロケーション完全ゼロ → キャッシュに最適
+- 全変数が `Copy` 型（`u32`, `u64`） → 借用・所有権の複雑性なし
+
+## 業務開発視点での分析
+
+- LeetCode 制約 `0 ≤ x ≤ 2³¹ - 1` → `i32` ではなく**`u32` が意味論的に正確**（非負整数）
+- `Result<u32, SqrtError>` で不正入力を型レベルで表現
+- `Option<u32>` ではなく `Result` を選択 → エラー種別を呼び出し元に伝達可能
+
+## Rust特有の考慮点
+
+- `i32` パラメータ（LeetCode signature）を `u32` に変換する際の**符号安全変換** `u32::try_from()` を活用
+- `mid.checked_mul(mid)` で算術オーバーフローを**型安全に**回避する選択肢もあるが、`u64` キャストの方がパフォーマンス上有利
+- イテレータ vs 命令型ループ: 二分探索は**収束条件が動的**なため `while` ループが最適（`Iterator` では表現しにくい）
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+| アプローチ          | 時間計算量   | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                           |
+| ------------------- | ------------ | ---------- | -------------- | ------ | ------ | ------------------------------ |
+| **線形探索**        | O(√n)        | O(1)       | 低             | 高     | 高     | x=2³¹では~46340回、非効率      |
+| **二分探索**        | O(log n)     | O(1)       | 低             | 高     | 高     | ✅ 整数演算のみ・誤差なし      |
+| **ニュートン法**    | O(log log n) | O(1)       | 中             | 中     | 中     | 浮動小数点誤差・収束判定が複雑 |
+| **ビット操作(MSB)** | O(log n)     | O(1)       | 高             | 中     | 低     | 最上位ビットから確定、可読性低 |
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: 二分探索（Binary Search）
+- **理由**:
+    - O(log n) = **最大31回**のループで解が確定（`log₂(2³¹) ≈ 31`）
+    - 浮動小数点を**一切使わない整数演算**のみ → Rust の `u32`/`u64` 型安全性を最大活用
+    - Loop Invariant（`high * high <= x`）がコード上で自明 → 保守性・レビュー効率が高い
+- **Rust特有の最適化ポイント**:
+    - `u32` / `u64` は `Copy` トレイト実装済み → 借用なしで値渡し、ゼロコスト
+    - 全変数がスタック配置 → ヒープアロケーション完全ゼロ
+    - モノモーフィゼーション不要（ジェネリクスなし） → コンパイル結果がシンプルで高速
+
+---
+
+## 4. 実装コード
+
+```rust
+impl Solution {
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.07 MB
+// Beats 90.93%
+
+    /// 非負整数 x の平方根を小数点以下切り捨てで返す（二分探索）
+    ///
+    /// # Arguments
+    /// * `x` - 非負整数 (0 ≤ x ≤ 2^31 - 1)
+    ///
+    /// # Returns
+    /// `floor(√x)` を `i32` で返す
+    ///
+    /// # Panics
+    /// `x` が負の場合（LeetCode 制約上は発生しない）
+    ///
+    /// # Complexity
+    /// - Time:  O(log n) — 最大 31 回のイテレーション
+    /// - Space: O(1)     — スタック変数のみ、ヒープアロケーションなし
+    pub fn my_sqrt(x: i32) -> i32 {
+        // ── 符号安全変換 ─────────────────────────────────────────────
+        // LeetCode は i32 で渡すが、問題制約は非負整数 → u32 に変換
+        // x < 0 は制約上あり得ないが、安全のため assert で明示
+        debug_assert!(x >= 0, "x must be non-negative, got {x}");
+        let x = x as u32;
+
+        // ── エッジケース早期リターン ──────────────────────────────────
+        // x = 0 → 0、x = 1 → 1（二分探索を回さず即リターン）
+        if x < 2 {
+            return x as i32;
+        }
+
+        // ── 二分探索 ─────────────────────────────────────────────────
+        // 探索範囲: [1, x / 2]
+        // 根拠: x >= 2 のとき floor(√x) <= x / 2 が常に成立
+        let mut low: u32 = 1;
+        let mut high: u32 = x >> 1; // x / 2（ビットシフトで整数除算）
+
+        // Loop Invariant:
+        //   low  - 1 の二乗は x 以下
+        //   high + 1 の二乗は x より大きい
+        // → ループ終了時: high = floor(√x)
+        while low <= high {
+            // オーバーフロー安全な中点計算
+            // u32 同士の加算が u32::MAX を超える可能性があるため
+            // low + (high - low) / 2 パターンを採用
+            let mid: u32 = low + (high - low) / 2;
+
+            // mid * mid は最大 (2^31/2)^2 ≈ 1.15×10^18 → u64 が必要
+            let square: u64 = (mid as u64) * (mid as u64);
+            let target: u64 = x as u64;
+
+            match square.cmp(&target) {
+                // 完全平方数: mid が答えそのもの
+                std::cmp::Ordering::Equal => return mid as i32,
+
+                // mid が小さすぎる: 下限を引き上げ
+                std::cmp::Ordering::Less => low = mid + 1,
+
+                // mid が大きすぎる: 上限を引き下げ
+                std::cmp::Ordering::Greater => high = mid - 1,
+            }
+        }
+
+        // ループ終了後、high = floor(√x)
+        // 例: x=8 → [low=1, high=4]
+        //   mid=2 (4<8)  → low=3
+        //   mid=3 (9>8)  → high=2
+        //   low(3) > high(2) → 終了: return high=2 ✓
+        high as i32
+    }
+}
+```
+
+---
+
+# 5. アルゴリズム動作トレース
+
+```
+─── x = 4 ───────────────────────────────────────────────────
+  early return なし（x >= 2）
+  初期値: low=1, high=2
+
+  Iter 1: mid=1, square=1 < 4  → low=2
+  Iter 2: mid=2, square=4 == 4 → return 2  ✓
+
+─── x = 8 ───────────────────────────────────────────────────
+  初期値: low=1, high=4
+
+  Iter 1: mid=2, square=4  < 8  → low=3
+  Iter 2: mid=3, square=9  > 8  → high=2
+  low(3) > high(2) → return high=2  ✓
+
+─── x = 2147395600 (46340²) ────────────────────────────────
+  完全平方数 → Equal 分岐で即 return 46340
+  最大でも約 30 回のイテレーションで収束
+
+─── エッジケース ────────────────────────────────────────────
+  x=0 → early return 0
+  x=1 → early return 1
+  x=2147483647 (i32::MAX) → return 46340
+```
+
+---
+
+## 6. Rust 固有の設計ポイント整理
+
+| 観点                           | 実装での対応                                               |
+| ------------------------------ | ---------------------------------------------------------- |
+| **オーバーフロー防止（中点）** | `low + (high - low) / 2` でラップアラウンドを回避          |
+| **オーバーフロー防止（二乗）** | `mid as u64 * mid as u64` で `u64` に昇格してから乗算      |
+| **符号安全変換**               | `x as u32`（非負制約を `debug_assert!` で文書化）          |
+| **`match` + `Ordering`**       | `if/else` より意図が明確・コンパイラの網羅性チェックが効く |
+| **ゼロコスト抽象化**           | 全変数 `Copy`・スタックのみ・ヒープアロケーション完全ゼロ  |
+| **`debug_assert!`**            | リリースビルドで消滅するため実行時コストゼロ               |