Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/cpp/chapter_greedy/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(coin_change_greedy coin_change_greedy.cpp)
+add_executable(fractional_knapsack fractional_knapsack.cpp)
+add_executable(max_capacity max_capacity.cpp)

ja/codes/cpp/chapter_greedy/coin_change_greedy.cpp

@@ -6,55 +6,55 @@
 
 #include "../utils/common.hpp"
 
-/* 硬貨両替：貪欲法 */
+/* コイン交換：貪欲法 */
 int coinChangeGreedy(vector<int> &coins, int amt) {
-    // 硬貨リストが順序付けされていると仮定
+    // coins リストはソート済みと仮定する
     int i = coins.size() - 1;
     int count = 0;
-    // 残り金額がなくなるまで貪欲選択をループ
+    // 残額がなくなるまで貪欲選択を繰り返す
     while (amt > 0) {
-        // 残り金額に近く、それ以下の最小硬貨を見つける
+        // 残額以下で最も近い硬貨を見つける
         while (i > 0 && coins[i] > amt) {
             i--;
         }
-        // coins[i] を選択
+        // coins[i] を選択する
         amt -= coins[i];
         count++;
     }
-    // 実行可能な解が見つからない場合、-1 を返す
+    // 実行可能な解が見つからなければ -1 を返す
     return amt == 0 ? count : -1;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
-    // 貪欲法：大域最適解の発見を保証できる
+    // 貪欲法：大域最適解を保証できる
     vector<int> coins = {1, 5, 10, 20, 50, 100};
     int amt = 186;
     int res = coinChangeGreedy(coins, amt);
     cout << "\ncoins = ";
     printVector(coins);
     cout << "amt = " << amt << endl;
-    cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
+    cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
 
-    // 貪欲法：大域最適解の発見を保証できない
+    // 貪欲法：大域最適解を保証できない
     coins = {1, 20, 50};
     amt = 60;
     res = coinChangeGreedy(coins, amt);
     cout << "\ncoins = ";
     printVector(coins);
     cout << "amt = " << amt << endl;
-    cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
-    cout << "実際には、最小必要数は 3 です。つまり、20 + 20 + 20" << endl;
+    cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
+    cout << "実際に必要な最小枚数は 3、つまり 20 + 20 + 20" << endl;
 
-    // 貪欲法：大域最適解の発見を保証できない
+    // 貪欲法：大域最適解を保証できない
     coins = {1, 49, 50};
     amt = 98;
     res = coinChangeGreedy(coins, amt);
     cout << "\ncoins = ";
     printVector(coins);
     cout << "amt = " << amt << endl;
-    cout << amt << " を作るのに必要な最小硬貨数は " << res << " です" << endl;
-    cout << "実際には、最小必要数は 2 です。つまり、49 + 49" << endl;
+    cout << amt << " を作るのに必要な最小硬貨枚数は " << res << endl;
+    cout << "実際に必要な最小枚数は 2、つまり 49 + 49" << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_greedy/fractional_knapsack.cpp

@@ -6,11 +6,11 @@
 
 #include "../utils/common.hpp"
 
-/* アイテム */
+/* 品物 */
 class Item {
   public:
-    int w; // アイテムの重量
-    int v; // アイテムの価値
+    int w; // 品物の重さ
+    int v; // 品物の価値
 
     Item(int w, int v) : w(w), v(v) {
     }
@@ -18,39 +18,39 @@ class Item {
 
 /* 分数ナップサック：貪欲法 */
 double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
-    // アイテムリストを作成、2つの属性を含む：重量、価値
+    // 重さと価値の 2 属性を持つ品物リストを作成
     vector<Item> items;
     for (int i = 0; i < wgt.size(); i++) {
         items.push_back(Item(wgt[i], val[i]));
     }
-    // 単位価値 item.v / item.w で高い順にソート
+    // 単位価値 item.v / item.w の高い順にソートする
     sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
-    // 貪欲選択をループ
+    // 貪欲選択を繰り返す
     double res = 0;
     for (auto &item : items) {
         if (item.w <= cap) {
-            // 残り容量が十分な場合、アイテム全体をナップサックに入れる
+            // 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
             res += item.v;
             cap -= item.w;
         } else {
-            // 残り容量が不十分な場合、アイテムの一部をナップサックに入れる
+            // 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
             res += (double)item.v / item.w * cap;
-            // 残り容量がなくなったため、ループを中断
+            // 残り容量がないため、ループを抜ける
             break;
         }
     }
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> wgt = {10, 20, 30, 40, 50};
     vector<int> val = {50, 120, 150, 210, 240};
     int cap = 50;
 
-    // 貪欲アルゴリズム
+    // 貪欲法
     double res = fractionalKnapsack(wgt, val, cap);
-    cout << "ナップサック容量内での最大値は " << res << " です" << endl;
+    cout << "ナップサック容量を超えない最大価値は " << res << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_greedy/max_capacity.cpp

@@ -8,16 +8,16 @@
 
 /* 最大容量：貪欲法 */
 int maxCapacity(vector<int> &ht) {
-    // i、j を初期化し、配列の両端で分割させる
+    // i, j を初期化し、それぞれ配列の両端に置く
     int i = 0, j = ht.size() - 1;
-    // 初期最大容量は 0
+    // 初期の最大容量は 0
     int res = 0;
-    // 2つの板が出会うまで貪欲選択をループ
+    // 2 枚の板が出会うまで貪欲選択を繰り返す
     while (i < j) {
-        // 最大容量を更新
+        // 最大容量を更新する
         int cap = min(ht[i], ht[j]) * (j - i);
         res = max(res, cap);
-        // より短い板を内側に移動
+        // 短い方を内側へ動かす
         if (ht[i] < ht[j]) {
             i++;
         } else {
@@ -27,13 +27,13 @@ int maxCapacity(vector<int> &ht) {
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> ht = {3, 8, 5, 2, 7, 7, 3, 4};
 
-    // 貪欲アルゴリズム
+    // 貪欲法
     int res = maxCapacity(ht);
-    cout << "最大容量は " << res << " です" << endl;
+    cout << "最大容量は " << res << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_greedy/max_product_cutting.cpp

@@ -6,34 +6,34 @@
 
 #include "../utils/common.hpp"
 
-/* 最大積切断：貪欲法 */
+/* 最大切断積：貪欲法 */
 int maxProductCutting(int n) {
-    // n <= 3 の場合、1 を切り出す必要がある
+    // n <= 3 のときは、必ず 1 を切り出す
     if (n <= 3) {
         return 1 * (n - 1);
     }
-    // 貪欲に 3 を切り出す。a は 3 の個数、b は余り
+    // 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
     int a = n / 3;
     int b = n % 3;
     if (b == 1) {
-        // 余りが 1 の場合、1 * 3 のペアを 2 * 2 に変換
+        // 余りが 1 のときは、1 * 3 を 2 * 2 に変える
         return (int)pow(3, a - 1) * 2 * 2;
     }
     if (b == 2) {
-        // 余りが 2 の場合、何もしない
+        // 余りが 2 のときは、そのままにする
         return (int)pow(3, a) * 2;
     }
-    // 余りが 0 の場合、何もしない
+    // 余りが 0 のときは、そのままにする
     return (int)pow(3, a);
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     int n = 58;
 
-    // 貪欲アルゴリズム
+    // 貪欲法
     int res = maxProductCutting(n);
-    cout << "分割の最大積は " << res << " です" << endl;
+    cout << "最大分割積は" << res << endl;
 
     return 0;
-}
+}