xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-02 11:15:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Yudong Jin
2026-10-30 02:12:26 +08:00
committed by GitHub
parent 455e8c1281
commit 7257641e0e
1987 changed files with 23531 additions and 23261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ja/codes/java/chapter_array_and_linkedlist/array.java
+25 -25
View File
@@ -10,20 +10,20 @@ import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
public class array {
/* 要素へランダムアクセス */
/* 要素にランダムアクセスする */
static int randomAccess(int[] nums) {
// 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
// 区間 [0, nums.length) から数値をランダムに 1 つ選ぶ
int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);
// ランダムな要素を取得して返す
// ランダムに選んだ要素を取得して返す
int randomNum = nums[randomIndex];
return randomNum;
}
/* 配列長を拡張する */
/* 配列の長さを拡張する */
static int[] extend(int[] nums, int enlarge) {
// 拡張後の長さを持つ配列を初期化する
// 拡張後の長さの配列を初期化する
int[] res = new int[nums.length + enlarge];
// 元の配列の全要素を新しい配列にコピー
// 元の配列の全要素を新しい配列にコピーする
for (int i = 0; i < nums.length; i++) {
res[i] = nums[i];
}
@@ -31,38 +31,38 @@ public class array {
return res;
}
/* 配列の index 番目に要素 num を挿入 */
/* 配列のインデックス index に要素 num を挿入する */
static void insert(int[] nums, int num, int index) {
// インデックス index 以降の全要素を 1 つ後ろへ移動する
// インデックス index 以降の全要素を 1 つ後ろにずらす
for (int i = nums.length - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// index の要素に num を代入する
// インデックス index の要素に num を代入する
nums[index] = num;
}
/* index の要素を削除する */
/* インデックス index の要素を削除する */
static void remove(int[] nums, int index) {
// インデックス index より後ろの全要素を 1 つ前へ移動する
// インデックス index より後の全要素を 1 つ前にずらす
for (int i = index; i < nums.length - 1; i++) {
nums[i] = nums[i + 1];
}
}
/* 配列を走査 */
/* 配列を走査する */
static void traverse(int[] nums) {
int count = 0;
// インデックスで配列を走査
// インデックスを使って配列を走査する
for (int i = 0; i < nums.length; i++) {
count += nums[i];
}
// 配列要素を直接走査
// 配列の要素を直接走査する
for (int num : nums) {
count += num;
}
}
/* 配列内で指定要素を探す */
/* 配列から指定した要素を探索する */
static int find(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
if (nums[i] == target)
@@ -71,9 +71,9 @@ public class array {
return -1;
}
/* Driver Code */
/* 実行用コード */
public static void main(String[] args) {
/* 配列を初期化 */
/* 配列を初期化する */
int[] arr = new int[5];
System.out.println("配列 arr = " + Arrays.toString(arr));
int[] nums = { 1, 3, 2, 5, 4 };
@@ -81,25 +81,25 @@ public class array {
/* ランダムアクセス */
int randomNum = randomAccess(nums);
System.out.println("nums からランダムな要素を取得 " + randomNum);
System.out.println("nums からランダムに取得した要素 " + randomNum);
/* 長さを拡張 */
/* 長さの拡張 */
nums = extend(nums, 3);
System.out.println("配列の長さを 8 に拡張し、nums = " + Arrays.toString(nums));
System.out.println("配列の長さを 8 に拡張した結果 nums = " + Arrays.toString(nums));
/* 要素を挿入する */
insert(nums, 6, 3);
System.out.println("インデックス 3 に数値 6 を挿入し、nums = " + Arrays.toString(nums));
System.out.println("インデックス 3 に数値 6 を挿入した結果 nums = " + Arrays.toString(nums));
/* 要素を削除 */
/* 要素を削除する */
remove(nums, 2);
System.out.println("インデックス 2 の要素を削除し、nums = " + Arrays.toString(nums));
System.out.println("インデックス 2 の要素を削除した結果 nums = " + Arrays.toString(nums));
/* 配列を走査 */
/* 配列を走査する */
traverse(nums);
/* 要素を探索する */
int index = find(nums, 3);
System.out.println("nums 内で要素 3 を検索し、インデックス = " + index);
System.out.println("nums から要素 3 を探索した結果のインデックス = " + index);
}
}
ja/codes/java/chapter_array_and_linkedlist/linked_list.java
+16 -16
View File
@@ -9,14 +9,14 @@ package chapter_array_and_linkedlist;
import utils.*;
public class linked_list {
/* 連結リストでノード n0 の後ろにノード P を挿入する */
/* 連結リストのノード n0 の直後にノード P を挿入する */
static void insert(ListNode n0, ListNode P) {
ListNode n1 = n0.next;
P.next = n1;
n0.next = P;
}
/* 連結リストでノード n0 の直後のノードを削除する */
/* 連結リストのノード n0 の直後のノードを削除する */
static void remove(ListNode n0) {
if (n0.next == null)
return;
@@ -26,7 +26,7 @@ public class linked_list {
n0.next = n1;
}
/* 連結リスト内で index 番目のノードにアクセス */
/* 連結リストのインデックス index にあるノードにアクセスする */
static ListNode access(ListNode head, int index) {
for (int i = 0; i < index; i++) {
if (head == null)
@@ -36,7 +36,7 @@ public class linked_list {
return head;
}
/* 連結リストで値が target の最初のノードを探す */
/* 連結リストから値が target である最初のノードを探索する */
static int find(ListNode head, int target) {
int index = 0;
while (head != null) {
@@ -48,39 +48,39 @@ public class linked_list {
return -1;
}
/* Driver Code */
/* 実行用コード */
public static void main(String[] args) {
/* 連結リストを初期化 */
// 各ノードを初期化
/* 連結リストを初期化する */
// 各ノードを初期化する
ListNode n0 = new ListNode(1);
ListNode n1 = new ListNode(3);
ListNode n2 = new ListNode(2);
ListNode n3 = new ListNode(5);
ListNode n4 = new ListNode(4);
// ノード間の参照を構築する
// ノード間の参照を設定する
n0.next = n1;
n1.next = n2;
n2.next = n3;
n3.next = n4;
System.out.println("初期化した連結リストは");
System.out.println("初期化した連結リスト");
PrintUtil.printLinkedList(n0);
/* ノードを挿入 */
/* ノードを挿入する */
insert(n0, new ListNode(0));
System.out.println("ノード挿入後の連結リストは");
System.out.println("ノードを挿入した後の連結リスト");
PrintUtil.printLinkedList(n0);
/* ノードを削除 */
/* ノードを削除する */
remove(n0);
System.out.println("ノード削除後の連結リストは");
System.out.println("ノードを削除した後の連結リスト");
PrintUtil.printLinkedList(n0);
/* ノードにアクセス */
/* ノードにアクセスする */
ListNode node = access(n0, 3);
System.out.println("連結リストのインデックス 3 にあるノードの値 = " + node.val);
/* ノードを探索 */
/* ノードを探索する */
int index = find(n0, 2);
System.out.println("連結リスト内で値 2 のノードのインデックス = " + index);
System.out.println("連結リスト内で値が 2 であるノードのインデックス = " + index);
}
}
ja/codes/java/chapter_array_and_linkedlist/list.java
+16 -16
View File
@@ -10,46 +10,46 @@ import java.util.*;
public class list {
public static void main(String[] args) {
/* リストを初期化 */
// 配列の要素型は `int[]` のラッパークラスである `Integer[]` である点に注意
/* リストを初期化する */
// 配列の要素型には int[] のラッパークラス Integer[] を使うことに注意
Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
List<Integer> nums = new ArrayList<>(Arrays.asList(numbers));
System.out.println("リスト nums = " + nums);
/* 要素にアクセス */
/* 要素にアクセスする */
int num = nums.get(1);
System.out.println("インデックス 1 の要素にアクセスし、num = " + num);
System.out.println("インデックス 1 の要素にアクセスした結果 num = " + num);
/* 要素を更新 */
/* 要素を更新する */
nums.set(1, 0);
System.out.println("インデックス 1 の要素を 0 に更新し、nums = " + nums);
System.out.println("インデックス 1 の要素を 0 に更新した結果 nums = " + nums);
/* リストを空にする */
nums.clear();
System.out.println("リストを空にした後 nums = " + nums);
/* 末尾に要素を追加 */
/* 末尾に要素を追加する */
nums.add(1);
nums.add(3);
nums.add(2);
nums.add(5);
nums.add(4);
System.out.println("要素追加後 nums = " + nums);
System.out.println("要素を追加した後 nums = " + nums);
/* 中間に要素を挿入 */
/* 途中に要素を挿入する */
nums.add(3, 6);
System.out.println("インデックス 3 に数値 6 を挿入し、nums = " + nums);
System.out.println("インデックス 3 に数値 6 を挿入した結果 nums = " + nums);
/* 要素を削除 */
/* 要素を削除する */
nums.remove(3);
System.out.println("インデックス 3 の要素を削除し、nums = " + nums);
System.out.println("インデックス 3 の要素を削除した結果 nums = " + nums);
/* インデックスでリストを走査 */
/* インデックスを使ってリストを走査する */
int count = 0;
for (int i = 0; i < nums.size(); i++) {
count += nums.get(i);
}
/* リスト要素を直接走査 */
/* リストの要素を直接走査する */
for (int x : nums) {
count += x;
}
@@ -57,9 +57,9 @@ public class list {
/* 2 つのリストを連結する */
List<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
nums.addAll(nums1);
System.out.println("リスト nums1 を nums の後ろに連結し、nums = " + nums);
System.out.println("リスト nums の後ろに nums1 を連結した結果 nums = " + nums);
/* リストをソート */
/* リストをソートする */
Collections.sort(nums);
System.out.println("リストをソートした後 nums = " + nums);
}
ja/codes/java/chapter_array_and_linkedlist/my_list.java
+37 -37
View File
@@ -10,94 +10,94 @@ import java.util.*;
/* リストクラス */
class MyList {
private int[] arr; // 配列（リスト要素を格納）
private int capacity = 10; // リスト容量
private int[] arr; // 配列（リストの要素を格納する）
private int capacity = 10; // リストの容量
private int size = 0; // リストの長さ（現在の要素数）
private int extendRatio = 2; // リスト拡張時の増加倍率
private int extendRatio = 2; // リストの容量を拡張する際の倍率
/* コンストラクタ */
public MyList() {
arr = new int[capacity];
}
/* リストの長さを取得（現在の要素数） */
/* リストの長さ（現在の要素数）を取得する */
public int size() {
return size;
}
/* リスト容量を取得する */
/* リストの容量を取得する */
public int capacity() {
return capacity;
}
/* 要素にアクセス */
/* 要素にアクセスする */
public int get(int index) {
// インデックスが範囲外なら例外を送出する。以下同様
// インデックスが範囲外の場合、例外を送出する。以下も同様
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
return arr[index];
}
/* 要素を更新 */
/* 要素を更新する */
public void set(int index, int num) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
arr[index] = num;
}
/* 末尾に要素を追加 */
/* 末尾に要素を追加する */
public void add(int num) {
// 要素数が容量を超えると、拡張機構が発動する
// 要素数が容量を超える場合、容量を拡張する
if (size == capacity())
extendCapacity();
arr[size] = num;
// 要素数を更新
// 要素数を更新する
size++;
}
/* 中間に要素を挿入 */
/* 途中に要素を挿入する */
public void insert(int index, int num) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
// 要素数が容量を超えると、拡張機構が発動する
// 要素数が容量を超える場合、容量を拡張する
if (size == capacity())
extendCapacity();
// index 以降の要素をすべて 1 つ後ろへずらす
// インデックス index 以降の全要素を後ろに 1 つずらす
for (int j = size - 1; j >= index; j--) {
arr[j + 1] = arr[j];
}
arr[index] = num;
// 要素数を更新
// 要素数を更新する
size++;
}
/* 要素を削除 */
/* 要素を削除する */
public int remove(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("インデックスが範囲外です");
int num = arr[index];
// インデックス index より後の要素をすべて 1 つ前に移動する
// インデックス index より後の全要素を前に 1 つずらす
for (int j = index; j < size - 1; j++) {
arr[j] = arr[j + 1];
}
// 要素数を更新
// 要素数を更新する
size--;
// 削除された要素を返す
// 削除した要素を返す
return num;
}
/* リストの拡張 */
/* リストの容量を拡張する */
public void extendCapacity() {
// 元の配列の extendRatio 倍の長さを持つ新しい配列を作成し、元の配列をコピーする
// 元の配列の extendRatio 倍の長さの配列を新たに作成し、元の配列をコピーする
arr = Arrays.copyOf(arr, capacity() * extendRatio);
// リストの容量を更新
// リストの容量を更新する
capacity = arr.length;
}
/* リストを配列に変換する */
public int[] toArray() {
int size = size();
// 有効長の範囲内のリスト要素のみを変換
// 有効な長さの範囲内にあるリストの要素だけを変換する
int[] arr = new int[size];
for (int i = 0; i < size; i++) {
arr[i] = get(i);
@@ -107,11 +107,11 @@ class MyList {
}
public class my_list {
/* Driver Code */
/* 実行用コード */
public static void main(String[] args) {
/* リストを初期化 */
/* リストを初期化する */
MyList nums = new MyList();
/* 末尾に要素を追加 */
/* 末尾に要素を追加する */
nums.add(1);
nums.add(3);
nums.add(2);
@@ -120,28 +120,28 @@ public class my_list {
System.out.println("リスト nums = " + Arrays.toString(nums.toArray()) +
" 、容量 = " + nums.capacity() + " 、長さ = " + nums.size());
/* 中間に要素を挿入 */
/* 途中に要素を挿入する */
nums.insert(3, 6);
System.out.println("インデックス 3 に数値 6 を挿入すると、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 3 に数値 6 を挿入した結果 nums = " + Arrays.toString(nums.toArray()));
/* 要素を削除 */
/* 要素を削除する */
nums.remove(3);
System.out.println("インデックス 3 の要素を削除すると、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 3 の要素を削除した結果 nums = " + Arrays.toString(nums.toArray()));
/* 要素にアクセス */
/* 要素にアクセスする */
int num = nums.get(1);
System.out.println("インデックス 1 の要素にアクセスし、num = " + num);
System.out.println("インデックス 1 の要素にアクセスした結果 num = " + num);
/* 要素を更新 */
/* 要素を更新する */
nums.set(1, 0);
System.out.println("インデックス 1 の要素を 0 に更新すると、nums = " + Arrays.toString(nums.toArray()));
System.out.println("インデックス 1 の要素を 0 に更新した結果 nums = " + Arrays.toString(nums.toArray()));
/* 拡張機構をテストする */
/* 容量の拡張をテストする */
for (int i = 0; i < 10; i++) {
// i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
// i = 5 のときにリストの長さが容量を超えるため、容量が拡張される
nums.add(i);
}
System.out.println("拡張後のリスト nums = " + Arrays.toString(nums.toArray()) +
System.out.println("容量を拡張した後のリスト nums = " + Arrays.toString(nums.toArray()) +
" 、容量 = " + nums.capacity() + " 、長さ = " + nums.size());
}
}