Retranslate the complete Japanese online edition from Chinese (#2008)

* Retranslate the complete Japanese online edition from Chinese

* Fit Japanese homepage labels and localize heading permalinks

* Point Japanese contribution instructions to the Japanese preview

* Replace locale conditionals with multilingual UI tables

ja/codes/java/chapter_divide_and_conquer/binary_search_recur.java

@@ -9,11 +9,11 @@ package chapter_divide_and_conquer;
 public class binary_search_recur {
     /* 二分探索：問題 f(i, j) */
     static int dfs(int[] nums, int target, int i, int j) {
-        // 区間が空なら対象要素は存在しないので -1 を返す
+        // 区間が空なら目的の要素が存在しないため、-1 を返す
         if (i > j) {
             return -1;
         }
-        // 中点インデックス m を計算
+        // 中央のインデックス m を計算する
         int m = (i + j) / 2;
         if (nums[m] < target) {
             // 部分問題 f(m+1, j) を再帰的に解く
@@ -22,7 +22,7 @@ public class binary_search_recur {
             // 部分問題 f(i, m-1) を再帰的に解く
             return dfs(nums, target, i, m - 1);
         } else {
-            // 目標要素が見つかったらそのインデックスを返す
+            // 目的の要素が見つかったので、そのインデックスを返す
             return m;
         }
     }
@@ -38,8 +38,8 @@ public class binary_search_recur {
         int target = 6;
         int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
 
-        // 二分探索（両閉区間）
+        // 二分探索（閉区間）
         int index = binarySearch(nums, target);
-        System.out.println("対象要素 6 のインデックス = " + index);
+        System.out.println("目的の要素 6 のインデックス = " + index);
     }
 }

ja/codes/java/chapter_divide_and_conquer/build_tree.java

@@ -10,24 +10,24 @@ import utils.*;
 import java.util.*;
 
 public class build_tree {
-    /* 二分木を構築：分割統治 */
+    /* 二分木の構築：分割統治法 */
     static TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
-        // 部分木区間が空なら終了する
+        // 部分木の区間が空の場合、終了する
         if (r - l < 0)
             return null;
-        // ルートノードを初期化する
+        // 根ノードを初期化する
         TreeNode root = new TreeNode(preorder[i]);
-        // m を求めて左右部分木を分割する
+        // m を調べ、左右の部分木に分割する
         int m = inorderMap.get(preorder[i]);
-        // 部分問題：左部分木を構築する
+        // 部分問題：左部分木の構築
         root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
-        // 部分問題：右部分木を構築する
+        // 部分問題：右部分木の構築
         root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
         // 根ノードを返す
         return root;
     }
 
-    /* 二分木を構築 */
+    /* 二分木を構築する */
     static TreeNode buildTree(int[] preorder, int[] inorder) {
         // inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
         Map<Integer, Integer> inorderMap = new HashMap<>();
@@ -41,11 +41,11 @@ public class build_tree {
     public static void main(String[] args) {
         int[] preorder = { 3, 9, 2, 1, 7 };
         int[] inorder = { 9, 3, 1, 2, 7 };
-        System.out.println("前順走査 = " + Arrays.toString(preorder));
-        System.out.println("中順走査 = " + Arrays.toString(inorder));
+        System.out.println("行きがけ順走査 = " + Arrays.toString(preorder));
+        System.out.println("通りがけ順走査 = " + Arrays.toString(inorder));
 
         TreeNode root = buildTree(preorder, inorder);
-        System.out.println("構築した二分木は：");
+        System.out.println("構築した二分木：");
         PrintUtil.printTree(root);
     }
 }

ja/codes/java/chapter_divide_and_conquer/fast_power.java

@@ -7,7 +7,7 @@
 package chapter_divide_and_conquer;
 
 public class fast_power {
-    /* 高速べき乗 */
+    /* 高速べき乗法 */
     static int fastPow(int x, int n) {
         if (n == 0) {
             return 1;

ja/codes/java/chapter_divide_and_conquer/hanota.java

@@ -9,38 +9,38 @@ package chapter_divide_and_conquer;
 import java.util.*;
 
 public class hanota {
-    /* 円盤を 1 枚移動 */
+    /* 円盤を 1 枚移動する */
     static void move(List<Integer> src, List<Integer> tar) {
-        // src の上から円盤を1枚取り出す
+        // src の一番上から円盤を 1 枚取り出す
         Integer pan = src.remove(src.size() - 1);
-        // 円盤を tar の上に置く
+        // tar の一番上に円盤を置く
         tar.add(pan);
     }
 
     /* ハノイの塔の問題 f(i) を解く */
     static void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
-        // src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す
+        // src に円盤が 1 枚だけ残っている場合、そのまま tar に移す
         if (i == 1) {
             move(src, tar);
             return;
         }
-        // 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
+        // 部分問題 f(i-1) ：src の上から i-1 枚の円盤を、tar を使って buf に移す
         dfs(i - 1, src, tar, buf);
-        // 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す
+        // 部分問題 f(1) ：src に残った 1 枚の円盤を tar に移す
         move(src, tar);
-        // 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す
+        // 部分問題 f(i-1) ：buf の上から i-1 枚の円盤を、src を使って tar に移す
         dfs(i - 1, buf, src, tar);
     }
 
-    /* ハノイの塔を解く */
+    /* ハノイの塔の問題を解く */
     static void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
         int n = A.size();
-        // A の上から n 枚の円盤を B を介して C へ移す
+        // A の上から n 枚の円盤を、B を使って C に移す
         dfs(n, A, B, C);
     }
 
     public static void main(String[] args) {
-        // リスト末尾が柱の頂上
+        // リストの末尾が棒の一番上に対応する
         List<Integer> A = new ArrayList<>(Arrays.asList(5, 4, 3, 2, 1));
         List<Integer> B = new ArrayList<>();
         List<Integer> C = new ArrayList<>();