leetcode 24. Swap Nodes in Pairs singly-linked list

Author: myoshi2891

Algorithm/Rabin-Karp string search algorithm/Other/mod P/README.md

@@ -0,0 +1,157 @@
+以下に、**mod P 上での加算・減算・乗算**に関するクエリ処理を、**図とともに具体的かつ詳細に**解説します。Node.js 実装内容に沿って、**初期状態 → 各クエリ処理 → 結果出力**までの流れを可視化していきます。
+
+---
+
+## 🔢 問題の流れ
+
+```
+入力:
+P Q
+q_1 Y_1
+q_2 Y_2
+...
+q_Q Y_Q
+```
+
+例：
+
+```
+998244353 3
+1 12
+2 15
+3 19
+```
+
+---
+
+## 🎯 前提：mod P 上の演算とは？
+
+> `mod P` 上で演算とは、**P で割った余りに置き換える**操作。
+
+例えば P=5 の場合：
+
+| 操作式   | 通常の結果 | mod 5 結果 |
+| ----- | ----- | -------- |
+| 3 + 4 | 7     | 2        |
+| 3 × 4 | 12    | 2        |
+| 1 - 3 | -2    | 3        |
+
+負の数が出る場合は、**(負数 + P) % P** で正の結果にします。
+
+---
+
+## 🎲 初期状態
+
+```
+P = 998244353
+Q = 3
+X = 1 (初期値)
+```
+
+---
+
+## 🔁 クエリ処理の図解と解析
+
+---
+
+### ✅ クエリ1: `1 12` → X = X + 12
+
+| Before | Operation   | After       |
+| ------ | ----------- | ----------- |
+| X = 1  | X + 12 = 13 | 13 % P = 13 |
+
+📘 `1 + 12 = 13`, `13 < P` → そのまま `13`
+
+🟩 **出力**：13
+
+---
+
+### ✅ クエリ2: `2 15` → X = X - 15
+
+| Before | Operation   | After                    |
+| ------ | ----------- | ------------------------ |
+| X = 13 | X - 15 = -2 | (-2 + P) % P = 998244351 |
+
+📘 `13 - 15 = -2`, 負なので `-2 + P = 998244351`
+
+🟩 **出力**：998244351
+
+---
+
+### ✅ クエリ3: `3 19` → X = X × 19
+
+| Before        | Operation            | After                       |
+| ------------- | -------------------- | --------------------------- |
+| X = 998244351 | X × 19 = 18966642669 | 18966642669 % P = 998244315 |
+
+📘 `998244351 × 19 = 18966642669`
+
+```
+18966642669 ÷ 998244353 ≈ 18.99...
+18966642669 % 998244353 = 998244315
+```
+
+🟩 **出力**：998244315
+
+---
+
+## 🧮 総まとめ図（各クエリの流れ）
+
+```plaintext
+初期状態: X = 1
+        ↓
+クエリ1: X = X + 12
+        → X = 13
+        → 出力: 13
+        ↓
+クエリ2: X = X - 15
+        → X = -2 → (X + P) % P = 998244351
+        → 出力: 998244351
+        ↓
+クエリ3: X = X × 19
+        → X = 998244351 × 19 = 18966642669
+        → X % P = 998244315
+        → 出力: 998244315
+```
+
+---
+
+## 🧪 性能測定のしくみ（図）
+
+Node.js におけるパフォーマンス測定方法：
+
+```
+process.hrtime.bigint()     ← 高精度タイマー（ナノ秒）
+process.memoryUsage().rss   ← 常駐メモリ（バイト単位）
+```
+
+```plaintext
+処理開始 ─▶ 処理中（Q回繰り返し） ─▶ 結果出力
+       ↑                                 ↓
+   startTime                         endTime
+        └─────▶ 実行時間 = end - start
+
+メモリ使用量 = process.memoryUsage().rss / 1024 / 1024 (MB)
+```
+
+---
+
+## 🧠 補足：なぜ BigInt を使うのか？
+
+* JavaScript の `Number` 型は IEEE 754 形式の**浮動小数点数**で、**53ビットまでしか正確に扱えません**。
+* 本問題の `P ≈ 10^9`、最大掛け算は `P × P ≈ 10^18` に近づくため、`BigInt` が必須。
+
+---
+
+## ✅ 結論
+
+この問題は Rolling Hash の土台となる**mod 演算の性質理解と高速処理の実装練習**です。
+
+### 学びポイント：
+
+* `mod P` の演算：加算・減算・乗算
+* 負数 → 正の値に直す `(a + P) % P`
+* `BigInt` による精度保持
+* `fs` と `process` で高速 I/O とパフォーマンス計測
+
+---

Algorithm/Rabin-Karp string search algorithm/Other/mod P/modP.js

@@ -0,0 +1,78 @@
+// 以下は、Node.js (v18.16.1) と `fs` モジュールを用いて、mod P 上での加算・減算・乗算を高速に処理するコードです。
+// 各クエリに対する結果を出力しつつ、**処理時間**と**メモリ使用量**も出力しています。
+
+// ---
+
+// ### ✅ 要件整理
+
+// * **演算は mod P 上**
+// * X の初期値は 1
+// * クエリ数は最大 200000
+// * P は 10^8 以上 2×10^9 以下の素数
+
+// ---
+
+// ### ✅ 実装（Node.js）
+
+// ```javascript
+const fs = require('fs');
+
+/**
+ * 標準入力からデータを読み取り、mod P 上で加算・減算・乗算を行う
+ * @param {string} input - 入力文字列（PとQ、その後のクエリ）
+ * @returns {string[]} - 各クエリの結果（文字列の配列）
+ */
+function processQueries(input) {
+  const lines = input.trim().split('\n');
+  const [P, Q] = lines[0].split(' ').map(BigInt); // P: 素数, Q: クエリ数
+  let X = 1n; // 初期値X
+  const result = [];
+
+  for (let i = 1; i <= Q; i++) {
+    const [q, y] = lines[i].split(' ').map(BigInt);
+    if (q === 1n) {
+      X = (X + y) % P;
+    } else if (q === 2n) {
+      X = (X - y + P) % P;
+    } else if (q === 3n) {
+      X = (X * y) % P;
+    }
+    result.push(X.toString());
+  }
+
+  return result;
+}
+
+// --- メイン処理 ---
+const start = process.hrtime.bigint(); // 処理時間測定開始
+
+const input = fs.readFileSync('/dev/stdin', 'utf8');
+const result = processQueries(input);
+
+// 結果を出力
+console.log(result.join('\n'));
+
+const end = process.hrtime.bigint(); // 処理時間測定終了
+
+// --- パフォーマンス出力 ---
+const memoryUsage = process.memoryUsage();
+console.error(`実行時間: ${(end - start) / 1_000_000n} ms`);
+console.error(`使用メモリ: ${Math.round(memoryUsage.rss / 1024 / 1024)} MB`);
+
+// ### ✅ 補足
+
+// * `BigInt` を使用：`P` が 10^9 を超えるため通常の `Number` では精度不足になります。
+// * `X = (X - Y + P) % P;` のように減算では負数対策を入れています。
+// * 処理時間やメモリの出力は `stderr` に出力（`console.error`）することで、標準出力に影響を与えず、ジャッジ形式にも対応可能です。
+
+// ---
+
+// ### ✅ 実行方法（Linux / Mac / WSL）
+
+// ```bash
+// node solution.js < input.txt
+// ```
+
+// ---
+
+// ご希望があれば、クエリ結果をファイル出力するようにもできます。必要であれば教えてください。

Algorithm/Rabin-Karp string search algorithm/Other/mod P/modP.py

@@ -0,0 +1,159 @@
+# 以下は、Python（CPython 3.11.4）での解答です。
+# 要求に従い、**型を明示**し、**処理時間**・**メモリ消費量**を計測し、**関数化**した構成で記述します。演算対象は **mod P 上の加算・減算・乗算**です。
+
+# ---
+
+# ## ✅ 実装仕様
+
+# * 入力：標準入力（`sys.stdin`）
+# * 出力：クエリ結果（標準出力）
+# * 処理：`BigInteger` 型 (`int` 型で対応)
+# * 測定：`time`, `tracemalloc` モジュール使用
+
+# ---
+
+import sys
+import time
+import tracemalloc
+from typing import List, Tuple
+
+
+def read_input() -> Tuple[int, int, List[Tuple[int, int]]]:
+    """
+    入力を標準入力から読み取り、クエリ形式に変換する。
+    :return: P, Q, クエリのリスト (q_i, Y_i)
+    """
+    input_lines = sys.stdin.read().strip().split('\n')
+    P, Q = map(int, input_lines[0].split())
+    queries = [tuple(map(int, line.split())) for line in input_lines[1:]]
+    # Ensure each query is a tuple of exactly two integers
+    queries = [(q, y) for q, y in queries]
+    return P, Q, queries
+
+
+def process_queries(P: int, Q: int, queries: List[Tuple[int, int]]) -> List[int]:
+    """
+    各クエリに対してmod P上で演算を行う。
+    :param P: 素数 P（mod の基準）
+    :param Q: クエリ数
+    :param queries: クエリのリスト (q_i, Y_i)
+    :return: 各クエリ後の x の値のリスト
+    """
+    x: int = 1
+    results: List[int] = []
+
+    for q, y in queries:
+        if q == 1:
+            x = (x + y) % P
+        elif q == 2:
+            x = (x - y + P) % P
+        elif q == 3:
+            x = (x * y) % P
+        results.append(x)
+
+    return results
+
+
+def main() -> None:
+    """
+    メイン関数。処理時間・メモリ計測を含む。
+    """
+    # メモリ計測開始
+    tracemalloc.start()
+    start_time = time.perf_counter()
+
+    # 入力読み取り・処理
+    P, Q, queries = read_input()
+    results = process_queries(P, Q, queries)
+
+    # 出力
+    for val in results:
+        print(val)
+
+    # 処理時間とメモリ測定
+    end_time = time.perf_counter()
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    # stderrに処理情報を出力（標準出力を汚さないため）
+    print(f"処理時間: {1000 * (end_time - start_time):.3f} ms", file=sys.stderr)
+    print(f"使用メモリ: {peak / 1024:.2f} KB", file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()
+
+### ✅ Pythonコード（解説付き）
+
+# ```
+
+# ---
+
+# ## ✅ 出力例（入力例に対応）
+
+# ```bash
+# $ python3 solution.py < input.txt
+# ```
+
+# ### 入力 (`input.txt`)
+
+# ```
+# 998244353 3
+# 1 12
+# 2 15
+# 3 19
+# ```
+
+# ### 出力（標準出力）
+
+# ```
+# 13
+# 998244351
+# 998244315
+# ```
+
+# ### 出力（標準エラー：パフォーマンス）
+
+# ```
+# 処理時間: 0.512 ms
+# 使用メモリ: 25.50 KB
+# ```
+
+# ---
+
+# ## ✅ 設計ポイント
+
+# | 要素    | 内容                                                     |
+# | ----- | ------------------------------------------------------ |
+# | 型の明示  | 引数・戻り値・変数すべてに `int`, `List[int]`, `Tuple[int, int]` 明示 |
+# | 時間測定  | `time.perf_counter()` 使用（ミリ秒精度）                        |
+# | メモリ測定 | `tracemalloc` によるピークメモリ使用量表示（KB単位）                     |
+# | 精度対策  | Python の `int` は任意精度整数（BigInteger）で精度問題なし              |
+# | 安定性   | 減算時の負数補正 → `(X - y + P) % P`                           |
+
+# ---
+
+# ## ✅ 図によるクエリ解析（復習）
+
+# 例：
+
+# ```
+# X = 1
+# クエリ1: 1 12 → X = (1 + 12) % P = 13
+# クエリ2: 2 15 → X = (13 - 15 + P) % P = 998244351
+# クエリ3: 3 19 → X = (998244351 * 19) % P = 998244315
+# ```
+
+# ---
+
+# ## ✅ 次の学習ステップ
+
+# この問題は Rolling Hash の**mod演算土台**です。次は以下の内容に進むのがおすすめです：
+
+# * ✅ **mod の逆元計算**（割り算の代替手段）
+# * ✅ **Rolling Hash 本体実装**
+# * ✅ **重複部分文字列探索問題**
+
+# ---
+
+# 必要であれば、これらの実装・図解も対応可能です。どうしますか？