atcoder B13 - Supermarket 2 しゃくとり法 (Two Pointers)

Author: myoshi2891

Algorithm/RSA encryption/ASCII code expansion/ASCIICodeExpansion.js

@@ -0,0 +1,127 @@
+// 以下は、**RSA復号処理 + ASCIIコード展開（28ビット → 7ビット×4分割）** を行うJavaScriptコードです。
+// `fs` モジュールで標準入力から値を取得し、**実行時間・メモリの消費を抑えた実装**になっています。
+
+// ---
+
+// ## ✅ 処理概要
+
+// 1. 入力：`n`, `e`, `E`
+// 2. φ(n) を求めるために、`n` を素因数分解 → `p`, `q` を得る
+// 3. `φ(n) = (p-1)(q-1)` を計算
+// 4. `d = e⁻¹ mod φ(n)` を求める（拡張ユークリッド）
+// 5. `M = E^d mod n`（繰り返し二乗法）
+// 6. `M` を28ビットで見て、7ビットごとに区切って文字列化
+
+// ---
+
+// ## ✅ コード（Node.js）
+
+const fs = require('fs');
+
+// 入力取得
+const input = fs.readFileSync(0, 'utf8').trim();
+const [nRaw, eRaw, Eraw] = input.split(' ').map(BigInt);
+
+const n = nRaw;
+const e = eRaw;
+const E = Eraw;
+
+// 素因数分解（p, q）
+// n は 10^10 以下なので √n まで試せば良い
+function findFactors(n) {
+    const sqrtN = BigInt(Math.floor(Math.sqrt(Number(n))));
+    for (let i = 2n; i <= sqrtN; i++) {
+        if (n % i === 0n) {
+            return [i, n / i];
+        }
+    }
+    return [1n, n]; // fallback
+}
+
+// 拡張ユークリッド互除法で逆元を求める
+function modInv(a, m) {
+    let m0 = m, x0 = 0n, x1 = 1n;
+    while (a > 1n) {
+        const q = a / m;
+        [a, m] = [m, a % m];
+        [x0, x1] = [x1 - q * x0, x0];
+    }
+    return x1 < 0n ? x1 + m0 : x1;
+}
+
+// 繰り返し二乗法で a^b % m を高速計算
+function modPow(base, exp, mod) {
+    let result = 1n;
+    base = base % mod;
+    while (exp > 0n) {
+        if (exp % 2n === 1n) {
+            result = (result * base) % mod;
+        }
+        base = (base * base) % mod;
+        exp = exp / 2n;
+    }
+    return result;
+}
+
+// 1. 素因数分解
+const [p, q] = findFactors(n);
+
+// 2. φ(n) = (p-1)(q-1)
+const phi = (p - 1n) * (q - 1n);
+
+// 3. 秘密鍵 d = e^-1 mod φ(n)
+const d = modInv(e, phi);
+
+// 4. 復号処理 M = E^d mod n
+const M = modPow(E, d, n);
+
+// 5. 28ビットを 7ビット × 4 に分割し ASCII 変換
+const chars = [];
+let temp = M;
+for (let i = 0; i < 4; i++) {
+    const charCode = Number(temp & 0b1111111n); // 下位7ビット
+    if (charCode !== 0) {
+        chars.unshift(String.fromCharCode(charCode));
+    }
+    temp >>= 7n;
+}
+
+// 出力
+console.log(chars.join(''));
+
+// ## ✅ 実行例
+
+// ### 入力:
+
+// ```
+// 3995747143 3007 602607029
+// ```
+
+// ### 出力:
+
+// ```
+// PAIZ
+// ```
+
+// ---
+
+// ## ✅ 実行時間・メモリ分析
+
+// | ステップ            | 時間計算量       | 備考                        |
+// | --------------- | ----------- | ------------------------- |
+// | 素因数分解           | O(√n)       | n ≤ 10^10 なので最大 10^5 回ループ |
+// | 逆元計算（modInv）    | O(log φ(n)) | log(10^10) ≈ 33 回以下       |
+// | 繰り返し二乗法（modPow） | O(log d)    | 非常に高速                     |
+// | ビット操作＆変換        | O(1)        | 最大4文字分                    |
+// | **総メモリ使用量**     | 数百 KB 程度    | BigInt 計算のために多少のオーバーヘッドあり |
+
+// ---
+
+// ## ✅ 補足
+
+// * 暗号文（`E`）が 28 ビットの復号文 `M` を生成する前提です。
+// * `M` は ASCII コードの7ビット（0〜127）範囲の文字しか使わない設計です。
+
+// ---
+
+// ご希望があれば、RSAの暗号化側（E = M^e mod n）コードや、多文字列対応の拡張版なども提供可能です。お気軽にどうぞ！

Algorithm/RSA encryption/ASCII code expansion/ASCIICodeExpansion.py

@@ -0,0 +1,46 @@
+from typing import Tuple
+
+def extgcd(a: int, b: int) -> Tuple[int, int, int]:
+    if b != 0:
+        c, y, x = extgcd(b, a % b)
+        y -= (a // b) * x
+        return c, x, y
+    return a, 1, 0
+
+def modpow(a: int, b: int, m: int) -> int:
+    ans = 1
+    while 0 < b:
+        if b & 1 == 1:
+            ans = (ans * a) % m
+        a = (a * a) % m
+        b >>= 1
+    return ans
+
+def divisor(n: int) -> Tuple[int, int]:
+    for i in range(2, int(n ** (1 / 2))):
+        if n % i == 0:
+            p = i
+            q = n // i
+            return p, q
+    raise ValueError("No divisors found")
+
+n, e, E = map(int, input().split())
+p, q = divisor(n)
+n_prime = (p - 1) * (q - 1)
+
+c, x, y = extgcd(e, n_prime)
+d = (x + n_prime) % n_prime
+message = modpow(E, d, n)  # Renamed from M to message
+
+letter = [0] * 4
+for i in range(4):
+    for j in range(7):
+        if message % 2 == 1:
+            letter[i] += pow(2, j)
+        message //= 2
+
+output = ""
+for i in range(4):
+    if letter[3 - i] != 0:
+        output += chr(letter[3 - i])
+print(output)

Algorithm/RSA encryption/ASCII code expansion/README.md

@@ -0,0 +1,196 @@
+
+---
+
+## 🔐 問題の背景と目的
+
+RSA暗号では以下の数式に基づいて **秘密の数字 M** を安全にやりとりできます。
+
+* 暗号化：`E ≡ M^e mod n`
+* 復号化：`M ≡ E^d mod n`
+
+さらに今回は、`M`（28ビット）を **7ビットごとに区切ってASCII文字に復元**します。
+
+---
+
+## 🧩 入力例
+
+```
+n = 3995747143  
+e = 3007  
+E = 602607029
+```
+
+---
+
+## 🪜 処理ステップ図解（全体）
+
+```mermaid
+flowchart TD
+    A[入力: n, e, E] --> B[素因数分解 n = p × q]
+    B --> C[φ(n) = (p-1)(q-1)]
+    C --> D[d = e⁻¹ mod φ(n)]
+    D --> E[M = E^d mod n]
+    E --> F[28ビット → 7ビット×4 に分割]
+    F --> G[ASCIIコード → 文字列]
+```
+
+---
+
+## 🔹 ステップ①：n の素因数分解（p, q）
+
+```
+n = 3995747143 = p × q
+```
+
+調べると、
+
+```
+p = 59359  
+q = 67309
+```
+
+#### 図：
+
+```
++-----------------------------+
+|         素因数分解         |
++-----------------------------+
+|          n = pq             |
+|   p = 59359 , q = 67309     |
++-----------------------------+
+```
+
+---
+
+## 🔹 ステップ②：φ(n) の計算
+
+```
+φ(n) = (p - 1) × (q - 1)
+     = 59358 × 67308 = 3995620776
+```
+
+#### 図：
+
+```
++--------------------------------+
+|      オイラー関数 φ(n)         |
++--------------------------------+
+| φ(n) = (p - 1)(q - 1)          |
+|      = 59358 × 67308           |
+|      = 3995620776              |
++--------------------------------+
+```
+
+---
+
+## 🔹 ステップ③：秘密鍵 d の計算
+
+秘密鍵 `d` は以下を満たす逆元：
+
+```
+d ≡ e⁻¹ mod φ(n)
+```
+
+`e = 3007`、`φ(n) = 3995620776` に対して、
+
+```
+d = 1899220895
+```
+
+これは拡張ユークリッド互除法で求めます。
+
+#### 図：
+
+```
++---------------------------------------------------+
+|              秘密鍵 d の計算（逆元）              |
++---------------------------------------------------+
+|     e × d ≡ 1 mod φ(n)                            |
+| → 3007 × d ≡ 1 mod 3995620776                     |
+| → d = 1899220895                                  |
++---------------------------------------------------+
+```
+
+---
+
+## 🔹 ステップ④：復号 `M = E^d mod n`
+
+与えられた `E = 602607029` を復号します：
+
+```
+M = E^d mod n
+  = 602607029^1899220895 mod 3995747143
+  = 1347701416
+```
+
+（繰り返し二乗法を使って効率的に計算）
+
+#### 図：
+
+```
++-----------------------------------------+
+|       復号処理：M = E^d mod n           |
++-----------------------------------------+
+|   E = 602607029                          |
+|   d = 1899220895                         |
+|   n = 3995747143                         |
+| → M = 1347701416                         |
++-----------------------------------------+
+```
+
+---
+
+## 🔹 ステップ⑤：28ビット → 7ビット × 4 分割
+
+28ビット表現の `M = 1347701416` は 2進数で：
+
+```
+M = 01010000 01000001 01001001 01011010
+        P        A       I       Z
+```
+
+上位から7ビットずつ分割：
+
+| S\[0] | S\[1] | S\[2] | S\[3] |
+| ----- | ----- | ----- | ----- |
+| 80    | 65    | 73    | 90    |
+| 'P'   | 'A'   | 'I'   | 'Z'   |
+
+#### 図：
+
+```
++-----------------------------------------------------+
+|   28ビット分解： 1347701416                         |
++-----------------------------------------------------+
+| 2進数：01010000 01000001 01001001 01011010          |
+|         ^        ^        ^        ^                |
+|       S[0]     S[1]     S[2]     S[3]               |
+|       80        65       73        90               |
+|       'P'       'A'      'I'       'Z'              |
++-----------------------------------------------------+
+```
+
+---
+
+## ✅ 最終出力
+
+```txt
+PAIZ
+```
+
+---
+
+## 🧠 処理全体まとめ（再掲）
+
+```mermaid
+graph LR
+  A1[n, e, E 入力] --> A2[素因数分解 → p, q]
+  A2 --> A3[φ(n) 計算]
+  A3 --> A4[秘密鍵 d 計算（mod逆元）]
+  A4 --> A5[復号 M = E^d mod n]
+  A5 --> A6[28ビットを 7ビット × 4 分割]
+  A6 --> A7[ASCIIコード → 文字列]
+  A7 --> A8[出力：PAIZ]
+```
+
+---