leetcode 28. Find the Index of the First Occurrence in a String KMP（Knuth-Morris-Pratt）法

Author: myoshi2891

Algorithm/Knuth-Morris-Pratt/leetcode/28. Find the Index of the First Occurrence in a String/Find-the-Index-of-the-First-Occurrence-in-a-String.js

@@ -0,0 +1,61 @@
+// 以下に、`Node.js 18.16.1` 環境で実行可能な `.indexOf()` を使ったシンプルで効率的な **JavaScript（関数形式）** の実装を提示します。
+
+// ---
+
+// ## ✅ 実装コード（JavaScript + `.indexOf()`）
+
+// ```javascript
+/**
+ * haystack から needle を検索し、最初に一致するインデックスを返す。
+ * 一致しない場合は -1 を返す。
+ *
+ * @param {string} haystack - 探索対象の文字列（最大長 10^4）
+ * @param {string} needle - 探索する部分文字列（最大長 10^4）
+ * @returns {number} - needle の最初の出現インデックス、存在しない場合は -1
+ *
+ * 時間計算量: O(n * m) 最悪ケース（平均は高速）
+ * 空間計算量: O(1)
+ */
+function strStrJs(haystack, needle) {
+  return haystack.indexOf(needle);
+}
+
+// ## 🧪 テストケース例
+
+// ```javascript
+// console.log(strStr("sadbutsad", "sad"));       // => 0
+// console.log(strStr("leetcode", "leeto"));      // => -1
+// console.log(strStr("mississippi", "issip"));   // => 4
+// console.log(strStr("abc", ""));                // => 0
+// ```
+
+// ---
+
+// ## 🔍 計算量と実行パフォーマンスの評価
+
+// | 項目              | 値                           |
+// | --------------- | --------------------------- |
+// | **時間計算量**       | 平均: `O(n)` ／ 最悪: `O(n * m)` |
+// | **空間計算量**       | `O(1)`（追加メモリなし）             |
+// | **Node.js実行環境** | `v18.16.1`（ECMAScript仕様準拠）  |
+// | **最大長制約**       | 10⁴（LeetCode制限内）            |
+
+// ---
+
+// ## ✅ なぜ `.indexOf()` は便利か？
+
+// * ネイティブ実装のため **高速な最適化** がされている。
+// * 内部的には **Boyer-Moore** や **KMPのような手法**を使うこともあり、**平均ケースで高速**。
+// * コードが非常に短く保守性が高い。
+
+// ---
+
+// ## ❗️注意点
+
+// * 最悪ケースでは `O(n * m)` の比較が発生することがあります。
+
+//   * 例: `haystack = "aaaaaaaab"`, `needle = "aaaab"` のようなケース
+
+// ---
+
+// ご希望があれば、`.indexOf()` の内部アルゴリズムや他手法（Rabin-Karp など）との速度比較も可能です。どうぞお申し付けください。

Algorithm/Knuth-Morris-Pratt/leetcode/28. Find the Index of the First Occurrence in a String/Find-the-Index-of-the-First-Occurrence-in-a-String.py

@@ -0,0 +1,93 @@
+# 以下に、`Python (CPython 3.11.4)` を使用し、LeetCode形式に準拠した `class Solution` を用いた解答を示します。
+
+# 処理効率を重視し、**KMP（Knuth-Morris-Pratt）法**を用いて、`needle`の最初の出現インデックスを効率よく探索します。
+
+# ---
+
+# ### ✅ 実装コード（KMP法使用）
+
+# ```python
+from typing import List
+
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        """
+        haystack: str - 探索対象の文字列
+        needle: str - 探索する部分文字列
+        return: int - needleの最初の出現インデックス。見つからない場合は-1。
+        時間計算量: O(n + m), 空間計算量: O(m)
+        （n = haystackの長さ, m = needleの長さ）
+        """
+
+        def build_lps(pattern: str) -> List[int]:
+            """部分一致テーブル（LPS配列）を構築する"""
+            lps = [0] * len(pattern)
+            length = 0  # 前のLPS長
+            i = 1
+
+            while i < len(pattern):
+                if pattern[i] == pattern[length]:
+                    length += 1
+                    lps[i] = length
+                    i += 1
+                else:
+                    if length != 0:
+                        length = lps[length - 1]
+                    else:
+                        lps[i] = 0
+                        i += 1
+            return lps
+
+        if not needle:
+            return 0  # 空文字列は0番目に見つかったとみなす
+
+        lps = build_lps(needle)
+        i = j = 0  # iはhaystack用, jはneedle用
+
+        while i < len(haystack):
+            if haystack[i] == needle[j]:
+                i += 1
+                j += 1
+                if j == len(needle):
+                    return i - j
+            else:
+                if j != 0:
+                    j = lps[j - 1]
+                else:
+                    i += 1
+
+        return -1  # 見つからなかった場合
+# ```
+
+# ---
+
+# ### 🔍 処理時間・メモリ計算量
+
+# | 項目     | 計算量                            |
+# | ------ | ------------------------------ |
+# | 時間計算量  | `O(n + m)`                     |
+# | 空間計算量  | `O(m)`（LPS配列の構築）               |
+# | 最悪ケース例 | haystack: 10⁴文字, needle: 10⁴文字 |
+
+# ---
+
+# ### ✅ テストケース例
+
+# ```python
+# s = Solution()
+# print(s.strStr("sadbutsad", "sad"))       # 出力: 0
+# print(s.strStr("leetcode", "leeto"))      # 出力: -1
+# print(s.strStr("aaaabaaabaaac", "abaaac"))# 出力: 7
+# print(s.strStr("abc", ""))                # 出力: 0（空needle）
+# ```
+
+# ---
+
+# ### ✅ 備考
+
+# * Pythonの組み込み関数 `haystack.find(needle)` を使えばワンライナーでも同様の結果が得られますが、KMP法はアルゴリズム的理解と応用力の訓練に適しています。
+# * LPS（Longest Prefix which is also Suffix）は、部分一致の再利用を可能にし、不要な比較を省きます。
+
+# ---
+
+# 必要があれば **図解付き**でLPS配列やKMPステップの説明も可能です。希望があればお知らせください。

Algorithm/Knuth-Morris-Pratt/leetcode/28. Find the Index of the First Occurrence in a String/Find-the-Index-of-the-First-Occurrence-in-a-String.ts

@@ -0,0 +1,104 @@
+// 以下に、\*\*TypeScript 5.1（Node.js 18.16.1）\*\*で `needle` を `haystack` の中から最初に探す関数を、**KMP（Knuth-Morris-Pratt）法**を用いて効率的に実装したものを提示します。
+
+// クラスは使用せず、**関数ベース**で構成されています。
+
+// ---
+
+// ## ✅ 実装（TypeScript・関数形式）
+
+// ```ts
+/**
+ * haystack から needle を検索し、最初に一致するインデックスを返す。
+ * 一致しない場合は -1 を返す。
+ *
+ * @param haystack - 探索対象の文字列（長さ最大10^4）
+ * @param needle - 探索する部分文字列（長さ最大10^4）
+ * @returns 最初に一致した位置のインデックス、または -1
+ *
+ * 時間計算量: O(n + m)
+ * 空間計算量: O(m)
+ */
+function strStr(haystack: string, needle: string): number {
+  if (needle.length === 0) return 0;
+
+  // KMP: LPS（Longest Prefix Suffix）配列の構築
+  function buildLPS(pattern: string): number[] {
+    const lps: number[] = new Array(pattern.length).fill(0);
+    let length = 0;
+    let i = 1;
+
+    while (i < pattern.length) {
+      if (pattern[i] === pattern[length]) {
+        length++;
+        lps[i] = length;
+        i++;
+      } else {
+        if (length !== 0) {
+          length = lps[length - 1]; // 戻って再試行
+        } else {
+          lps[i] = 0;
+          i++;
+        }
+      }
+    }
+    return lps;
+  }
+
+  const lps = buildLPS(needle);
+  let i = 0; // haystack index
+  let j = 0; // needle index
+
+  while (i < haystack.length) {
+    if (haystack[i] === needle[j]) {
+      i++;
+      j++;
+      if (j === needle.length) {
+        return i - j; // 完全一致発見
+      }
+    } else {
+      if (j !== 0) {
+        j = lps[j - 1]; // needle をスライド
+      } else {
+        i++;
+      }
+    }
+  }
+
+  return -1; // 一致せず
+}
+// ```
+
+// ---
+
+// ## 📦 テストケース例
+
+// ```ts
+// console.log(strStr("sadbutsad", "sad"));       // => 0
+// console.log(strStr("leetcode", "leeto"));      // => -1
+// console.log(strStr("mississippi", "issip"));   // => 4
+// console.log(strStr("abc", ""));                // => 0
+// ```
+
+// ---
+
+// ## 🧠 処理時間・メモリ消費量の考察
+
+// | 項目    | 値                                |
+// | ----- | -------------------------------- |
+// | 時間計算量 | `O(n + m)` （KMP法）                |
+// | 空間計算量 | `O(m)`（LPS配列）                    |
+// | 実行環境  | TypeScript 5.1 + Node.js 18.16.1 |
+// | 最大文字数 | 10⁴（問題制約）                        |
+
+// この方法は、最悪ケースでも `haystack` と `needle` の長さの合計だけで済むため、**TLE（Time Limit Exceeded）を回避しやすい**です。
+
+// ---
+
+// ## ✅ 補足
+
+// * TypeScriptでは `.indexOf()` を使えば O(n \* m) になる可能性があるため、KMP法がパフォーマンス的に優れています。
+// * クラスベースでの設計が不要な場合、競技プログラミングやLeetCodeの制約にも適しています。
+
+// ---
+
+// 他のアルゴリズム（Rabin-Karp など）や `.indexOf` ベースもご希望であれば比較提示可能です。必要であればお知らせください。

Algorithm/Knuth-Morris-Pratt/leetcode/28. Find the Index of the First Occurrence in a String/README.md

@@ -0,0 +1,136 @@
+では、先ほどの `strStr` 関数（KMP法による文字列探索）の**各処理ステップを図解とともに具体的に解析・説明**します。
+
+---
+
+## 🔍 **問題概要**
+
+* `haystack` から `needle` が **最初に現れる位置（インデックス）** を返す。
+* 見つからなければ `-1` を返す。
+
+例:
+
+```
+haystack = "sadbutsad"
+needle   = "sad"
+出力: 0
+```
+
+---
+
+## ✅ **KMP法 全体の流れ**
+
+### ステップ1: `needle` から **LPS配列（部分一致テーブル）** を作る
+
+### ステップ2: `haystack` を走査し、`needle` とマッチングする
+
+---
+
+## 📘 ステップ1: LPS 配列の構築
+
+### ✅ 目的：
+
+* パターンの途中で不一致が起きたとき、比較を**最初からやり直さずに済む**ようにする
+* LPS = `Longest Prefix which is also Suffix`
+
+---
+
+### 🎯 例:
+
+```text
+needle = "ababc"
+```
+
+#### LPS 配列の構築ステップ
+
+| i | needle\[0\:i] | LPS\[i] | 説明                                              |
+| - | ------------- | ------- | ----------------------------------------------- |
+| 0 | "a"           | 0       | 最初の文字なので LPS=0                                  |
+| 1 | "ab"          | 0       | "a" ≠ "b" なので 0                                 |
+| 2 | "aba"         | 1       | "a" で prefix=suffix -> 長さ1                      |
+| 3 | "abab"        | 2       | "ab" で prefix=suffix -> 長さ2                     |
+| 4 | "ababc"       | 0       | "c" ≠ "a", "c" ≠ "b" -> 一致するprefix/suffix無し → 0 |
+
+```
+最終LPS = [0, 0, 1, 2, 0]
+```
+
+📌 **この配列は失敗時にどこまで戻ればよいかを示すテーブル**です。
+
+---
+
+## 📘 ステップ2: `haystack` の走査
+
+### ✅ 目的：
+
+* LPS配列を使って `haystack` を効率よく走査
+* 一致しない時に `needle` のどこから再比較すればよいかを判断する
+
+---
+
+### 🎯 例:
+
+```text
+haystack = "abxabcabcaby"
+needle   = "abcaby"
+```
+
+#### LPS（事前計算済み）:
+
+```
+needle = "a b c a b y"
+LPS    = [0 0 0 1 2 0]
+```
+
+---
+
+### 🔄 マッチング処理ステップ（図で追跡）：
+
+```text
+haystack: a b x a b c a b c a b y
+needle  : a b c a b y
+                     ↑
+```
+
+#### 比較の様子：
+
+| i (haystack) | j (needle) | 一致？ | 説明                            |
+| ------------ | ---------- | --- | ----------------------------- |
+| 0            | 0          | ✅   | 'a'=='a' → i++, j++           |
+| 1            | 1          | ✅   | 'b'=='b' → i++, j++           |
+| 2            | 2          | ❌   | 'x' ≠ 'c' → j = LPS\[j-1] = 0 |
+| 2            | 0          | ❌   | 'x' ≠ 'a' → i++, j stays at 0 |
+| ...          | ...        |     | 同様の比較とジャンプが続く                 |
+| 6            | 0\~5       | ✅   | すべて一致 → i=12, j=6（完了）         |
+| 出力:          |            |     | i - j = 12 - 6 = 6 が解         |
+
+---
+
+## 🎯 ビジュアル図（イメージ）
+
+```
+haystack:  a b x a b c a b c a b y
+                  ↑↑↑↑↑↑       ← ここでneedle完全一致（6文字）
+
+needle  :      a b c a b y
+```
+
+---
+
+## 🧠 KMP法が効率的な理由
+
+* **部分一致までの情報をLPSに持っている**ので、無駄に戻らない
+* 文字列長が最大1万でも `O(n + m)` で探索できる（`find`より効率よい場合あり）
+
+---
+
+## ✅ 補足まとめ
+
+| ステップ       | 内容              | 時間計算量        | 空間計算量 |
+| ---------- | --------------- | ------------ | ----- |
+| LPS構築      | 部分一致テーブルの準備     | O(m)         | O(m)  |
+| haystack走査 | LPSを用いて文字列マッチング | O(n)         | O(1)  |
+| 合計         |                 | **O(n + m)** | O(m)  |
+
+---
+
+ご希望であれば「比較の様子を表に拡張」や「より長い文字列の可視化」も可能です。お気軽にどうぞ！