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/python/chapter_stack_and_queue/array_deque.py

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
 
 
 class ArrayDeque:
-    """循環配列ベースの両端キュー"""
+    """循環配列で実装した両端キュー"""
 
     def __init__(self, capacity: int):
         """コンストラクタ"""
@@ -15,115 +15,115 @@ class ArrayDeque:
         self._size: int = 0
 
     def capacity(self) -> int:
-        """両端キューの容量を取得"""
+        """両端キューの容量を取得する"""
         return len(self._nums)
 
     def size(self) -> int:
-        """両端キューの長さを取得"""
+        """両端キューの長さを取得する"""
         return self._size
 
     def is_empty(self) -> bool:
-        """両端キューが空かどうかを判定"""
+        """両端キューが空かどうかを判定する"""
         return self._size == 0
 
     def index(self, i: int) -> int:
-        """循環配列のインデックスを計算"""
-        # 剰余演算により配列の先頭と末尾をつなげる
-        # i が配列の末尾を越えたら先頭に戻る
-        # i が配列の先頭を越えて前に出たら末尾に戻る
+        """循環配列のインデックスを計算する"""
+        # 剰余演算を使い、配列の先頭と末尾をつなぐ
+        # i が配列の末尾を越えたら、先頭に戻る
+        # i が配列の先頭を越えたら、末尾に戻る
         return (i + self.capacity()) % self.capacity()
 
     def push_first(self, num: int):
-        """キュー先頭にエンキュー"""
+        """先頭にエンキューする"""
         if self._size == self.capacity():
-            print("両端キューがいっぱいです")
+            print("両端キューが満杯です")
             return
         # 先頭ポインタを左に 1 つ移動する
-        # 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
+        # 剰余演算により、front が配列の先頭を越えたら末尾に戻るようにする
         self._front = self.index(self._front - 1)
-        # num をキュー先頭に追加
+        # num をキューの先頭に追加する
         self._nums[self._front] = num
         self._size += 1
 
     def push_last(self, num: int):
-        """キュー末尾にエンキュー"""
+        """末尾にエンキューする"""
         if self._size == self.capacity():
-            print("両端キューがいっぱいです")
+            print("両端キューが満杯です")
             return
-        # キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
+        # 末尾のインデックス + 1 を指す末尾ポインタを計算する
         rear = self.index(self._front + self._size)
-        # num をキュー末尾に追加
+        # num をキューの末尾に追加する
         self._nums[rear] = num
         self._size += 1
 
     def pop_first(self) -> int:
-        """キュー先頭からデキュー"""
+        """先頭からデキューする"""
         num = self.peek_first()
-        # 先頭ポインタを 1 つ後ろへ進める
+        # 先頭ポインタを後ろに 1 つ移動する
         self._front = self.index(self._front + 1)
         self._size -= 1
         return num
 
     def pop_last(self) -> int:
-        """キュー末尾からデキュー"""
+        """末尾からデキューする"""
         num = self.peek_last()
         self._size -= 1
         return num
 
     def peek_first(self) -> int:
-        """キュー先頭の要素にアクセス"""
+        """キューの先頭要素にアクセス"""
         if self.is_empty():
             raise IndexError("両端キューが空です")
         return self._nums[self._front]
 
     def peek_last(self) -> int:
-        """キュー末尾の要素にアクセス"""
+        """キューの末尾要素にアクセスする"""
         if self.is_empty():
             raise IndexError("両端キューが空です")
-        # 末尾要素のインデックスを計算
+        # 末尾要素のインデックスを計算する
         last = self.index(self._front + self._size - 1)
         return self._nums[last]
 
     def to_array(self) -> list[int]:
-        """出力用の配列を返す"""
-        # 有効長の範囲内のリスト要素のみを変換
+        """表示用の配列を返す"""
+        # 有効な長さの範囲内にあるリストの要素だけを変換する
         res = []
         for i in range(self._size):
             res.append(self._nums[self.index(self._front + i)])
         return res
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 両端キューを初期化
+    # 両端キューを初期化する
     deque = ArrayDeque(10)
     deque.push_last(3)
     deque.push_last(2)
     deque.push_last(5)
     print("両端キュー deque =", deque.to_array())
 
-    # 要素にアクセス
+    # 要素にアクセスする
     peek_first: int = deque.peek_first()
-    print("先頭要素 peek_first =", peek_first)
+    print("キューの先頭要素 peek_first =", peek_first)
     peek_last: int = deque.peek_last()
-    print("末尾要素 peek_last =", peek_last)
+    print("キューの末尾要素 peek_last =", peek_last)
 
-    # 要素をエンキュー
+    # 要素をエンキューする
     deque.push_last(4)
-    print("要素 4 を末尾に追加した後 deque =", deque.to_array())
+    print("要素 4 を末尾にエンキューした後 deque =", deque.to_array())
     deque.push_first(1)
-    print("要素 1 を先頭に追加した後 deque =", deque.to_array())
+    print("要素 1 を先頭にエンキューした後 deque =", deque.to_array())
 
-    # 要素をデキュー
+    # 要素をデキューする
     pop_last: int = deque.pop_last()
-    print("末尾から取り出した要素 =", pop_last, "、末尾から取り出した後 deque =", deque.to_array())
+    print("末尾からデキューした要素 =", pop_last, "、末尾からデキューした後 deque =", deque.to_array())
     pop_first: int = deque.pop_first()
-    print("先頭から取り出した要素 =", pop_first, "、先頭から取り出した後 deque =", deque.to_array())
+    print("先頭からデキューした要素 =", pop_first, "、先頭からデキューした後 deque =", deque.to_array())
 
-    # 両端キューの長さを取得
+    # 両端キューの長さを取得する
     size: int = deque.size()
     print("両端キューの長さ size =", size)
 
-    # 両端キューが空かどうかを判定
+    # 両端キューが空かどうかを判定する
     is_empty: bool = deque.is_empty()
-    print("両端キューが空かどうか =", is_empty)
+    print("両端キューは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/array_queue.py

@@ -6,16 +6,16 @@ Author: Peng Chen (pengchzn@gmail.com)
 
 
 class ArrayQueue:
-    """循環配列ベースのキュー"""
+    """循環配列で実装したキュー"""
 
     def __init__(self, size: int):
         """コンストラクタ"""
-        self._nums: list[int] = [0] * size  # キュー要素を格納する配列
-        self._front: int = 0  # 先頭ポインタ。先頭要素を指す
+        self._nums: list[int] = [0] * size  # キューの要素を格納する配列
+        self._front: int = 0  # キューの先頭要素を指す先頭ポインタ
         self._size: int = 0  # キューの長さ
 
     def capacity(self) -> int:
-        """キューの容量を取得"""
+        """キューの容量を取得する"""
         return len(self._nums)
 
     def size(self) -> int:
@@ -23,30 +23,30 @@ class ArrayQueue:
         return self._size
 
     def is_empty(self) -> bool:
-        """キューが空かどうかを判定"""
+        """キューが空か判定"""
         return self._size == 0
 
     def push(self, num: int):
         """エンキュー"""
         if self._size == self.capacity():
-            raise IndexError("キューがいっぱいです")
-        # 末尾ポインタを計算し、末尾インデックス + 1 を指す
-        # 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
+            raise IndexError("キューが満杯です")
+        # 末尾のインデックス + 1 を指す末尾ポインタを計算する
+        # 剰余演算で、rear が配列末尾を越えたら先頭へ戻る
         rear: int = (self._front + self._size) % self.capacity()
-        # num をキュー末尾に追加
+        # num をキューの末尾に追加する
         self._nums[rear] = num
         self._size += 1
 
     def pop(self) -> int:
         """デキュー"""
         num: int = self.peek()
-        # 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
+        # 先頭ポインタを後ろに 1 つ移動し、末尾を越えたら配列の先頭に戻す
         self._front = (self._front + 1) % self.capacity()
         self._size -= 1
         return num
 
     def peek(self) -> int:
-        """キュー先頭の要素にアクセス"""
+        """キューの先頭要素にアクセス"""
         if self.is_empty():
             raise IndexError("キューが空です")
         return self._nums[self._front]
@@ -61,12 +61,12 @@ class ArrayQueue:
         return res
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # キューを初期化
+    # キューを初期化する
     queue = ArrayQueue(10)
 
-    # 要素をエンキュー
+    # 要素をエンキューする
     queue.push(1)
     queue.push(3)
     queue.push(2)
@@ -74,25 +74,25 @@ if __name__ == "__main__":
     queue.push(4)
     print("キュー queue =", queue.to_list())
 
-    # キュー先頭の要素にアクセス
+    # キューの先頭要素にアクセス
     peek: int = queue.peek()
-    print("先頭要素 peek =", peek)
+    print("キューの先頭要素 peek =", peek)
 
-    # 要素をデキュー
+    # 要素をデキューする
     pop: int = queue.pop()
-    print("取り出した要素 pop =", pop)
-    print("取り出した後 queue =", queue.to_list())
+    print("デキューした要素 pop =", pop)
+    print("デキュー後 queue =", queue.to_list())
 
     # キューの長さを取得
     size: int = queue.size()
     print("キューの長さ size =", size)
 
-    # キューが空かどうかを判定
+    # キューが空か判定
     is_empty: bool = queue.is_empty()
-    print("キューが空かどうか =", is_empty)
+    print("キューは空か =", is_empty)
 
     # 循環配列をテストする
     for i in range(10):
         queue.push(i)
         queue.pop()
-        print("第", i, "回目の追加 + 取り出し後 queue = ", queue.to_list())
+        print("第", i, "回のエンキューとデキューの後 queue = ", queue.to_list())

ja/codes/python/chapter_stack_and_queue/array_stack.py

@@ -6,18 +6,18 @@ Author: Peng Chen (pengchzn@gmail.com)
 
 
 class ArrayStack:
-    """配列ベースのスタック"""
+    """配列で実装したスタック"""
 
     def __init__(self):
         """コンストラクタ"""
         self._stack: list[int] = []
 
     def size(self) -> int:
-        """スタックの長さを取得"""
+        """スタックの長さを取得する"""
         return len(self._stack)
 
     def is_empty(self) -> bool:
-        """スタックが空かどうかを判定"""
+        """スタックが空かどうかを判定する"""
         return self.size() == 0
 
     def push(self, item: int):
@@ -31,7 +31,7 @@ class ArrayStack:
         return self._stack.pop()
 
     def peek(self) -> int:
-        """スタックトップの要素にアクセス"""
+        """スタックの先頭要素にアクセスする"""
         if self.is_empty():
             raise IndexError("スタックが空です")
         return self._stack[-1]
@@ -41,12 +41,12 @@ class ArrayStack:
         return self._stack
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # スタックを初期化
+    # スタックを初期化する
     stack = ArrayStack()
 
-    # 要素をプッシュ
+    # 要素をプッシュする
     stack.push(1)
     stack.push(3)
     stack.push(2)
@@ -54,19 +54,19 @@ if __name__ == "__main__":
     stack.push(4)
     print("スタック stack =", stack.to_list())
 
-    # スタックトップの要素にアクセス
+    # スタックの先頭要素にアクセスする
     peek: int = stack.peek()
-    print("スタックトップ要素 peek =", peek)
+    print("スタックの先頭要素 peek =", peek)
 
-    # 要素をポップ
+    # 要素をポップする
     pop: int = stack.pop()
     print("ポップした要素 pop =", pop)
     print("ポップ後 stack =", stack.to_list())
 
-    # スタックの長さを取得
+    # スタックの長さを取得する
     size: int = stack.size()
     print("スタックの長さ size =", size)
 
-    # 空かどうかを判定
+    # 空かどうかを判定する
     is_empty: bool = stack.is_empty()
-    print("スタックが空かどうか =", is_empty)
+    print("スタックは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/deque.py

@@ -6,37 +6,37 @@ Author: Peng Chen (pengchzn@gmail.com)
 
 from collections import deque
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 両端キューを初期化
+    # 両端キューを初期化する
     deq: deque[int] = deque()
 
-    # 要素をエンキュー
-    deq.append(2)  # 末尾に追加する
+    # 要素をエンキューする
+    deq.append(2)  # キューの末尾に追加する
     deq.append(5)
     deq.append(4)
-    deq.appendleft(3)  # 先頭に追加する
+    deq.appendleft(3)  # キューの先頭に追加する
     deq.appendleft(1)
     print("両端キュー deque =", deq)
 
-    # 要素にアクセス
-    front: int = deq[0]  # 先頭要素
-    print("先頭要素 front =", front)
-    rear: int = deq[-1]  # 末尾要素
-    print("末尾要素 rear =", rear)
+    # 要素にアクセスする
+    front: int = deq[0]  # キューの先頭要素
+    print("キューの先頭要素 front =", front)
+    rear: int = deq[-1]  # キューの末尾要素
+    print("キューの末尾要素 rear =", rear)
 
-    # 要素をデキュー
-    pop_front: int = deq.popleft()  # 先頭要素を取り出す
-    print("先頭から取り出した要素  pop_front =", pop_front)
-    print("先頭から取り出した後 deque =", deq)
-    pop_rear: int = deq.pop()  # 末尾要素を取り出す
-    print("末尾から取り出した要素  pop_rear =", pop_rear)
-    print("末尾から取り出した後 deque =", deq)
+    # 要素をデキューする
+    pop_front: int = deq.popleft()  # キューの先頭要素をデキューする
+    print("先頭からデキューした要素  pop_front =", pop_front)
+    print("先頭からデキューした後 deque =", deq)
+    pop_rear: int = deq.pop()  # キューの末尾要素をデキューする
+    print("末尾からデキューした要素  pop_rear =", pop_rear)
+    print("末尾からデキューした後 deque =", deq)
 
-    # 両端キューの長さを取得
+    # 両端キューの長さを取得する
     size: int = len(deq)
     print("両端キューの長さ size =", size)
 
-    # 両端キューが空かどうかを判定
+    # 両端キューが空かどうかを判定する
     is_empty: bool = len(deq) == 0
-    print("両端キューが空かどうか =", is_empty)
+    print("両端キューは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/linkedlist_deque.py

@@ -6,17 +6,17 @@ Author: krahets (krahets@163.com)
 
 
 class ListNode:
-    """双方向連結リストノード"""
+    """双方向連結リストのノード"""
 
     def __init__(self, val: int):
         """コンストラクタ"""
         self.val: int = val
         self.next: ListNode | None = None  # 後続ノードへの参照
-        self.prev: ListNode | None = None  # 前駆ノードへの参照
+        self.prev: ListNode | None = None  # 前のノードへの参照
 
 
 class LinkedListDeque:
-    """双方向連結リストベースの両端キュー"""
+    """双方向連結リストで実装した両端キュー"""
 
     def __init__(self):
         """コンストラクタ"""
@@ -25,91 +25,91 @@ class LinkedListDeque:
         self._size: int = 0  # 両端キューの長さ
 
     def size(self) -> int:
-        """両端キューの長さを取得"""
+        """両端キューの長さを取得する"""
         return self._size
 
     def is_empty(self) -> bool:
-        """両端キューが空かどうかを判定"""
+        """両端キューが空かどうかを判定する"""
         return self._size == 0
 
     def push(self, num: int, is_front: bool):
         """エンキュー操作"""
         node = ListNode(num)
-        # 連結リストが空なら、front と rear の両方を node に向ける
+        # 連結リストが空の場合、front と rear の両方が node を指すようにする
         if self.is_empty():
             self._front = self._rear = node
         # 先頭へのエンキュー操作
         elif is_front:
-            # node を連結リストの先頭に追加
+            # node を連結リストの先頭に追加する
             self._front.prev = node
             node.next = self._front
             self._front = node  # 先頭ノードを更新する
         # 末尾へのエンキュー操作
         else:
-            # node を連結リストの末尾に追加
+            # node を連結リストの末尾に追加する
             self._rear.next = node
             node.prev = self._rear
             self._rear = node  # 末尾ノードを更新する
-        self._size += 1  # キューの長さを更新
+        self._size += 1  # キューの長さを更新する
 
     def push_first(self, num: int):
-        """キュー先頭にエンキュー"""
+        """先頭にエンキューする"""
         self.push(num, True)
 
     def push_last(self, num: int):
-        """キュー末尾にエンキュー"""
+        """末尾にエンキューする"""
         self.push(num, False)
 
     def pop(self, is_front: bool) -> int:
         """デキュー操作"""
         if self.is_empty():
             raise IndexError("両端キューが空です")
-        # 要素が1つの場合、先頭と末尾は同じノードを指す
+        # キューの長さが 1 のとき、先頭と末尾は同じノードを指す
         if self._size == 1:
             val: int = self._front.val
             self._front = None
             self._rear = None
-        # キュー先頭からの取り出し
+        # 先頭からのデキュー操作
         elif is_front:
-            val: int = self._front.val  # 先頭ノードの値を一時保存
-            # 先頭ノードを削除
+            val: int = self._front.val  # 先頭ノードの値を一時保存する
+            # 先頭ノードを削除する
             fnext: ListNode | None = self._front.next
             fnext.prev = None
             self._front.next = None
             self._front = fnext  # 先頭ノードを更新する
-        # キュー末尾からの取り出し
+        # 末尾からのデキュー操作
         else:
-            val: int = self._rear.val  # 末尾ノードの値を一時保存
-            # 末尾ノードを削除
+            val: int = self._rear.val  # 末尾ノードの値を一時保存する
+            # 末尾ノードを削除する
             rprev: ListNode | None = self._rear.prev
             rprev.next = None
             self._rear.prev = None
             self._rear = rprev  # 末尾ノードを更新する
-        self._size -= 1  # キューの長さを更新
+        self._size -= 1  # キューの長さを更新する
         return val
 
     def pop_first(self) -> int:
-        """キュー先頭からデキュー"""
+        """先頭からデキューする"""
         return self.pop(True)
 
     def pop_last(self) -> int:
-        """キュー末尾からデキュー"""
+        """末尾からデキューする"""
         return self.pop(False)
 
     def peek_first(self) -> int:
-        """キュー先頭の要素にアクセス"""
+        """キューの先頭要素にアクセス"""
         if self.is_empty():
             raise IndexError("両端キューが空です")
         return self._front.val
 
     def peek_last(self) -> int:
-        """キュー末尾の要素にアクセス"""
+        """キューの末尾要素にアクセスする"""
         if self.is_empty():
             raise IndexError("両端キューが空です")
         return self._rear.val
 
     def to_array(self) -> list[int]:
-        """出力用の配列を返す"""
+        """表示用の配列を返す"""
         node = self._front
         res = [0] * self.size()
         for i in range(self.size()):
@@ -118,37 +118,37 @@ class LinkedListDeque:
         return res
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 両端キューを初期化
+    # 両端キューを初期化する
     deque = LinkedListDeque()
     deque.push_last(3)
     deque.push_last(2)
     deque.push_last(5)
     print("両端キュー deque =", deque.to_array())
 
-    # 要素にアクセス
+    # 要素にアクセスする
     peek_first: int = deque.peek_first()
-    print("先頭要素 peek_first =", peek_first)
+    print("キューの先頭要素 peek_first =", peek_first)
     peek_last: int = deque.peek_last()
-    print("末尾要素 peek_last =", peek_last)
+    print("キューの末尾要素 peek_last =", peek_last)
 
-    # 要素をエンキュー
+    # 要素をエンキューする
     deque.push_last(4)
-    print("要素 4 を末尾に追加した後 deque =", deque.to_array())
+    print("要素 4 を末尾にエンキューした後 deque =", deque.to_array())
     deque.push_first(1)
-    print("要素 1 を先頭に追加した後 deque =", deque.to_array())
+    print("要素 1 を先頭にエンキューした後 deque =", deque.to_array())
 
-    # 要素をデキュー
+    # 要素をデキューする
     pop_last: int = deque.pop_last()
-    print("末尾から取り出した要素 =", pop_last, "、末尾から取り出した後 deque =", deque.to_array())
+    print("末尾からデキューした要素 =", pop_last, "、末尾からデキューした後 deque =", deque.to_array())
     pop_first: int = deque.pop_first()
-    print("先頭から取り出した要素 =", pop_first, "、先頭から取り出した後 deque =", deque.to_array())
+    print("先頭からデキューした要素 =", pop_first, "、先頭からデキューした後 deque =", deque.to_array())
 
-    # 両端キューの長さを取得
+    # 両端キューの長さを取得する
     size: int = deque.size()
     print("両端キューの長さ size =", size)
 
-    # 両端キューが空かどうかを判定
+    # 両端キューが空かどうかを判定する
     is_empty: bool = deque.is_empty()
-    print("両端キューが空かどうか =", is_empty)
+    print("両端キューは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -12,7 +12,7 @@ from modules import ListNode
 
 
 class LinkedListQueue:
-    """連結リストベースのキュー"""
+    """連結リストで実装したキュー"""
 
     def __init__(self):
         """コンストラクタ"""
@@ -25,18 +25,18 @@ class LinkedListQueue:
         return self._size
 
     def is_empty(self) -> bool:
-        """キューが空かどうかを判定"""
+        """キューが空か判定"""
         return self._size == 0
 
     def push(self, num: int):
         """エンキュー"""
-        # 末尾ノードの後ろに num を追加
+        # 末尾ノードの後ろに num を追加する
         node = ListNode(num)
-        # キューが空なら、先頭・末尾ノードをともにそのノードに設定
+        # キューが空の場合、先頭と末尾の両方がこのノードを指すようにする
         if self._front is None:
             self._front = node
             self._rear = node
-        # キューが空でなければ、そのノードを末尾ノードの後ろに追加
+        # キューが空でない場合、このノードを末尾ノードの後ろに追加する
         else:
             self._rear.next = node
             self._rear = node
@@ -45,19 +45,19 @@ class LinkedListQueue:
     def pop(self) -> int:
         """デキュー"""
         num = self.peek()
-        # 先頭ノードを削除
+        # 先頭ノードを削除する
         self._front = self._front.next
         self._size -= 1
         return num
 
     def peek(self) -> int:
-        """キュー先頭の要素にアクセス"""
+        """キューの先頭要素にアクセス"""
         if self.is_empty():
             raise IndexError("キューが空です")
         return self._front.val
 
     def to_list(self) -> list[int]:
-        """表示用にリストへ変換"""
+        """表示用のリストに変換する"""
         queue = []
         temp = self._front
         while temp:
@@ -66,12 +66,12 @@ class LinkedListQueue:
         return queue
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # キューを初期化
+    # キューを初期化する
     queue = LinkedListQueue()
 
-    # 要素をエンキュー
+    # 要素をエンキューする
     queue.push(1)
     queue.push(3)
     queue.push(2)
@@ -79,19 +79,19 @@ if __name__ == "__main__":
     queue.push(4)
     print("キュー queue =", queue.to_list())
 
-    # キュー先頭の要素にアクセス
+    # キューの先頭要素にアクセス
     peek: int = queue.peek()
-    print("先頭要素 front =", peek)
+    print("キューの先頭要素 front =", peek)
 
-    # 要素をデキュー
+    # 要素をデキューする
     pop_front: int = queue.pop()
-    print("取り出した要素 pop =", pop_front)
-    print("取り出した後 queue =", queue.to_list())
+    print("デキューした要素 pop =", pop_front)
+    print("デキュー後 queue =", queue.to_list())
 
     # キューの長さを取得
     size: int = queue.size()
     print("キューの長さ size =", size)
 
-    # キューが空かどうかを判定
+    # キューが空か判定
     is_empty: bool = queue.is_empty()
-    print("キューが空かどうか =", is_empty)
+    print("キューは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -12,7 +12,7 @@ from modules import ListNode
 
 
 class LinkedListStack:
-    """連結リストベースのスタック"""
+    """連結リストで実装したスタック"""
 
     def __init__(self):
         """コンストラクタ"""
@@ -20,11 +20,11 @@ class LinkedListStack:
         self._size: int = 0
 
     def size(self) -> int:
-        """スタックの長さを取得"""
+        """スタックの長さを取得する"""
         return self._size
 
     def is_empty(self) -> bool:
-        """スタックが空かどうかを判定"""
+        """スタックが空かどうかを判定する"""
         return self._size == 0
 
     def push(self, val: int):
@@ -42,13 +42,13 @@ class LinkedListStack:
         return num
 
     def peek(self) -> int:
-        """スタックトップの要素にアクセス"""
+        """スタックの先頭要素にアクセスする"""
         if self.is_empty():
             raise IndexError("スタックが空です")
         return self._peek.val
 
     def to_list(self) -> list[int]:
-        """表示用にリストへ変換"""
+        """表示用のリストに変換する"""
         arr = []
         node = self._peek
         while node:
@@ -58,12 +58,12 @@ class LinkedListStack:
         return arr
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # スタックを初期化
+    # スタックを初期化する
     stack = LinkedListStack()
 
-    # 要素をプッシュ
+    # 要素をプッシュする
     stack.push(1)
     stack.push(3)
     stack.push(2)
@@ -71,19 +71,19 @@ if __name__ == "__main__":
     stack.push(4)
     print("スタック stack =", stack.to_list())
 
-    # スタックトップの要素にアクセス
+    # スタックの先頭要素にアクセスする
     peek: int = stack.peek()
-    print("スタックトップ要素 peek =", peek)
+    print("スタックの先頭要素 peek =", peek)
 
-    # 要素をポップ
+    # 要素をポップする
     pop: int = stack.pop()
     print("ポップした要素 pop =", pop)
     print("ポップ後 stack =", stack.to_list())
 
-    # スタックの長さを取得
+    # スタックの長さを取得する
     size: int = stack.size()
     print("スタックの長さ size =", size)
 
-    # 空かどうかを判定
+    # 空かどうかを判定する
     is_empty: bool = stack.is_empty()
-    print("スタックが空かどうか =", is_empty)
+    print("スタックは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/queue.py

@@ -6,14 +6,14 @@ Author: Peng Chen (pengchzn@gmail.com)
 
 from collections import deque
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     # キューを初期化する
-    # Python では通常、両端キュー deque をキューとして使う
-    # queue.Queue() は正統なキュークラスだが、あまり使いやすくない
+    # Python では一般に、両端キューのクラス deque をキューとして使う
+    # queue.Queue() は専用のキュークラスだが、やや使いづらい
     que: deque[int] = deque()
 
-    # 要素をエンキュー
+    # 要素をエンキューする
     que.append(1)
     que.append(3)
     que.append(2)
@@ -21,19 +21,19 @@ if __name__ == "__main__":
     que.append(4)
     print("キュー que =", que)
 
-    # キュー先頭の要素にアクセス
+    # キューの先頭要素にアクセス
     front: int = que[0]
-    print("先頭要素 front =", front)
+    print("キューの先頭要素 front =", front)
 
-    # 要素をデキュー
+    # 要素をデキューする
     pop: int = que.popleft()
-    print("取り出した要素 pop =", pop)
-    print("取り出し後 que =", que)
+    print("デキューした要素 pop =", pop)
+    print("デキュー後 que =", que)
 
     # キューの長さを取得
     size: int = len(que)
     print("キューの長さ size =", size)
 
-    # キューが空かどうかを判定
+    # キューが空か判定
     is_empty: bool = len(que) == 0
-    print("キューが空かどうか =", is_empty)
+    print("キューは空か =", is_empty)

ja/codes/python/chapter_stack_and_queue/stack.py

@@ -4,13 +4,13 @@ Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 """
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     # スタックを初期化する
     # Python には組み込みのスタッククラスがないため、list をスタックとして使える
     stack: list[int] = []
 
-    # 要素をプッシュ
+    # 要素をプッシュする
     stack.append(1)
     stack.append(3)
     stack.append(2)
@@ -18,19 +18,19 @@ if __name__ == "__main__":
     stack.append(4)
     print("スタック stack =", stack)
 
-    # スタックトップの要素にアクセス
+    # スタックの先頭要素にアクセスする
     peek: int = stack[-1]
-    print("スタックトップ要素 peek =", peek)
+    print("スタックの先頭要素 peek =", peek)
 
-    # 要素をポップ
+    # 要素をポップする
     pop: int = stack.pop()
     print("ポップした要素 pop =", pop)
     print("ポップ後 stack =", stack)
 
-    # スタックの長さを取得
+    # スタックの長さを取得する
     size: int = len(stack)
     print("スタックの長さ size =", size)
 
-    # 空かどうかを判定
+    # 空かどうかを判定する
     is_empty: bool = len(stack) == 0
-    print("スタックが空かどうか =", is_empty)
+    print("スタックは空か =", is_empty)