leetcode 31. Next Permutation

Author: myoshi2891

Algorithm/Other/leetcode/31. Next Permutation/Next-Permutation.js

@@ -0,0 +1,72 @@
+// 以下は、Node.js 18.16.1 / LeetCode 実行環境で動作する **関数ベース** の JavaScript 実装例です。
+
+// * **処理時間**: O(n)
+// * **追加メモリ**: O(1)（定数）
+// * **in-place** で次の順列を求めます。
+
+// ```javascript
+/**
+ * 次の辞書順順列を計算し、numsを直接変更する
+ * @param {number[]} nums - 整数配列（1 <= nums.length <= 100）
+ * @returns {void} - 配列を直接変更するため返却値はなし
+ *
+ * アルゴリズム:
+ * 1. 後ろから探索して、最初に nums[i] < nums[i+1] となる位置を探す (i が "転換点")
+ * 2. さらに後ろから nums[i] より大きい最小の要素 nums[j] を探す
+ * 3. nums[i] と nums[j] をスワップ
+ * 4. i+1 以降を昇順に反転（reverse）する
+ *
+ * 時間計算量: O(n) （最大100要素）
+ * 空間計算量: O(1) （定数メモリでin-place処理）
+ */
+function nextPermutationJs(nums) {
+    // 1. 後ろから転換点を探す
+    let i = nums.length - 2;
+    while (i >= 0 && nums[i] >= nums[i + 1]) {
+        i--;
+    }
+
+    if (i >= 0) {
+        // 2. 後ろから nums[i] より大きい最小の要素を探す
+        let j = nums.length - 1;
+        while (j >= 0 && nums[j] <= nums[i]) {
+            j--;
+        }
+        // 3. スワップ
+        [nums[i], nums[j]] = [nums[j], nums[i]];
+    }
+
+    // 4. i+1 以降を反転
+    let left = i + 1;
+    let right = nums.length - 1;
+    while (left < right) {
+        [nums[left], nums[right]] = [nums[right], nums[left]];
+        left++;
+        right--;
+    }
+}
+// ```
+
+// ---
+
+// ### **動作例**
+
+// ```javascript
+// let nums1 = [1,2,3];
+// nextPermutation(nums1);
+// console.log(nums1); // [1,3,2]
+
+// let nums2 = [3,2,1];
+// nextPermutation(nums2);
+// console.log(nums2); // [1,2,3]
+
+// let nums3 = [1,1,5];
+// nextPermutation(nums3);
+// console.log(nums3); // [1,5,1]
+// ```
+
+// ---
+
+// この方法は **LeetCodeの`Next Permutation`問題（31番）** にそのまま提出可能です。
+// 処理は **最大100要素** なので O(n) で十分高速、かつ追加配列を作らず **定数メモリ** で完結します。
+

Algorithm/Other/leetcode/31. Next Permutation/Next-Permutation.py

@@ -0,0 +1,89 @@
+# 以下に、**Python (CPython 3.11.4)** で動作する、**LeetCode形式 (class Solution + メソッド)** の解答例を示します。
+
+# * **処理時間**: O(n)（最大 n=100 で高速）
+# * **メモリ消費量**: O(1)（in-place 処理）
+# * **型アノテーション付き**
+# * **関数ベースだが LeetCode の仕様に合わせて class Solution を使用**
+
+from typing import List
+
+class Solution:
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        次の辞書順順列を nums に対して in-place で生成する
+        :param nums: List[int] - 配列 (1 <= len(nums) <= 100)
+        :return: None - 配列を直接変更するため返却値なし
+        
+        処理手順:
+        1. 後ろから転換点 i (nums[i] < nums[i+1]) を探索
+        2. さらに後ろから nums[i] より大きい最小の要素 nums[j] を探索
+        3. nums[i] と nums[j] をスワップ
+        4. i+1 以降を反転 (昇順化)
+
+        時間計算量: O(n)
+        空間計算量: O(1)
+        """
+        n: int = len(nums)
+        
+        # Step 1: 後ろから転換点を探す
+        i: int = n - 2
+        while i >= 0 and nums[i] >= nums[i + 1]:
+            i -= 1
+
+        if i >= 0:
+            # Step 2: 後ろから nums[i] より大きい要素を探す
+            j: int = n - 1
+            while j >= 0 and nums[j] <= nums[i]:
+                j -= 1
+            # Step 3: スワップ
+            nums[i], nums[j] = nums[j], nums[i]
+
+        # Step 4: 転換点以降を反転
+        left, right = i + 1, n - 1
+        while left < right:
+            nums[left], nums[right] = nums[right], nums[left]
+            left += 1
+            right -= 1
+# ```
+
+# ---
+
+# ### **動作確認例**
+
+# ```python
+# nums1 = [1, 2, 3]
+# Solution().nextPermutation(nums1)
+# print(nums1)  # [1, 3, 2]
+
+# nums2 = [3, 2, 1]
+# Solution().nextPermutation(nums2)
+# print(nums2)  # [1, 2, 3]
+
+# nums3 = [1, 1, 5]
+# Solution().nextPermutation(nums3)
+# print(nums3)  # [1, 5, 1]
+# ```
+
+# ---
+
+# ### **解析**
+
+# * **時間計算量**
+
+#   * 転換点探索 O(n)
+#   * 後ろから j 探索 O(n)
+#   * 反転 O(n)
+#     → 合計 **O(n)** （最大 n=100 なので高速）
+
+# * **メモリ消費量**
+
+#   * 定数個の変数のみ使用し、配列は in-place 更新
+#     → **O(1)**
+
+# ---
+
+# このアルゴリズムは **LeetCode 31. Next Permutation** にそのまま提出可能です。
+
+# ---
+
+# 次に、**この Python 実装の各処理を図解して解析したバージョン** も作成できますが、必要ですか？

Algorithm/Other/leetcode/31. Next Permutation/Next-Permutation.ts

@@ -0,0 +1,76 @@
+// 以下は、**TypeScript 5.1 (Node.js 18.16.1)** で動作する **関数ベースのLeetCode解答** です。
+
+// * **処理時間**: O(n)
+// * **メモリ消費量**: O(1)（in-place処理）
+// * **クラス非使用**、関数と明示的な型注釈付き
+
+// ---
+
+// ```typescript
+/**
+ * 次の辞書順順列を計算し、numsを直接変更する
+ * @param nums 整数配列 (1 <= nums.length <= 100)
+ * @returns void 配列を直接変更するため返却値なし
+ *
+ * アルゴリズム概要:
+ * 1. 後ろから探索して、nums[i] < nums[i+1] となる最初の位置 i を探す
+ * 2. さらに後ろから nums[i] より大きい最小の要素 nums[j] を探す
+ * 3. nums[i] と nums[j] をスワップ
+ * 4. i+1 以降を反転して昇順にする
+ *
+ * 時間計算量: O(n) （最大100要素）
+ * 空間計算量: O(1) （定数メモリでin-place処理）
+ */
+function nextPermutation(nums: number[]): void {
+    // 1. 後ろから転換点を探す
+    let i: number = nums.length - 2;
+    while (i >= 0 && nums[i] >= nums[i + 1]) {
+        i--;
+    }
+
+    if (i >= 0) {
+        // 2. 後ろから nums[i] より大きい要素を探す
+        let j: number = nums.length - 1;
+        while (j >= 0 && nums[j] <= nums[i]) {
+            j--;
+        }
+        // 3. スワップ
+        [nums[i], nums[j]] = [nums[j], nums[i]];
+    }
+
+    // 4. i+1 以降を反転
+    let left: number = i + 1;
+    let right: number = nums.length - 1;
+    while (left < right) {
+        [nums[left], nums[right]] = [nums[right], nums[left]];
+        left++;
+        right--;
+    }
+}
+// ```
+
+// ---
+
+// ### **使用例（ローカルテスト用）**
+
+// ```typescript
+// const nums1: number[] = [1, 2, 3];
+// nextPermutation(nums1);
+// console.log(nums1); // [1, 3, 2]
+
+// const nums2: number[] = [3, 2, 1];
+// nextPermutation(nums2);
+// console.log(nums2); // [1, 2, 3]
+
+// const nums3: number[] = [1, 1, 5];
+// nextPermutation(nums3);
+// console.log(nums3); // [1, 5, 1]
+// ```
+
+// ---
+
+// この実装は **LeetCode 31. Next Permutation** に直接提出可能です。
+
+// * **O(n)** で最大 100 要素まで高速に処理
+// * **O(1)** 追加メモリで in-place 処理
+