From 111ea3dbd30a5c596143a3b69bfd356bbc870d7a Mon Sep 17 00:00:00 2001
From: Arpit Goyal <50814175+Arpitgoyalgg@users.noreply.github.com>
Date: Sat, 9 Mar 2024 21:32:29 +0530
Subject: [PATCH 01/22] Update README.md (#1093)
---
src/data-structures/tree/README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/data-structures/tree/README.md b/src/data-structures/tree/README.md
index 7eb7ec1db1..e492257d33 100644
--- a/src/data-structures/tree/README.md
+++ b/src/data-structures/tree/README.md
@@ -23,7 +23,7 @@ together with a list of references to nodes (the "children"),
with the constraints that no reference is duplicated, and none
points to the root.
-A simple unordered tree; in this diagram, the node labeled 7 has
+A simple unordered tree; in this diagram, the node labeled 3 has
two children, labeled 2 and 6, and one parent, labeled 2. The
root node, at the top, has no parent.
From 8d1f473610f173713179fcfd4f628b3d67591ac3 Mon Sep 17 00:00:00 2001
From: Vi Truong <103717482+vivitruong@users.noreply.github.com>
Date: Sat, 9 Mar 2024 10:06:47 -0600
Subject: [PATCH 02/22] Vietsub (#1088)
* translate readme from linked list
* add linked list for viet sub
* add vietnamese readme translation for queue
* add readme in vietnamese for Stack
---
.../linked-list/README.vi-VN.md | 155 ++++++++++++++++++
src/data-structures/queue/README.vi-VN.md | 22 +++
src/data-structures/stack/README.vi-VN.md | 27 +++
3 files changed, 204 insertions(+)
create mode 100644 src/data-structures/linked-list/README.vi-VN.md
create mode 100644 src/data-structures/queue/README.vi-VN.md
create mode 100644 src/data-structures/stack/README.vi-VN.md
diff --git a/src/data-structures/linked-list/README.vi-VN.md b/src/data-structures/linked-list/README.vi-VN.md
new file mode 100644
index 0000000000..005838c6c1
--- /dev/null
+++ b/src/data-structures/linked-list/README.vi-VN.md
@@ -0,0 +1,155 @@
+# Danh sách liên kết (Linked List)
+
+_Đọc bằng ngôn ngữ khác:_
+[_简体中文_](README.zh-CN.md),
+[_Русский_](README.ru-RU.md),
+[_日本語_](README.ja-JP.md),
+[_Português_](README.pt-BR.md),
+[_한국어_](README.ko-KR.md),
+[_Español_](README.es-ES.md),
+[_Türkçe_](README.tr-TR.md),
+[_Українська_](README.uk-UA.md)
+
+
+Trong khoa học máy tính, một danh sách liên kết là một bộ sưu tập tuyến tính
+các phần tử dữ liệu, trong đó thứ tự tuyến tính không được xác định bởi
+vị trí vật lý của chúng trong bộ nhớ. Thay vào đó, mỗi
+phần tử trỏ đến phần tử tiếp theo. Đây là một cấu trúc dữ liệu
+bao gồm một nhóm các nút cùng đại diện cho
+một chuỗi. Dưới dạng đơn giản nhất, mỗi nút
+bao gồm dữ liệu và một tham chiếu (nói cách khác,
+một liên kết) đến nút tiếp theo trong chuỗi. Cấu trúc này
+cho phép việc chèn hoặc loại bỏ các phần tử một cách hiệu quả
+từ bất kỳ vị trí nào trong chuỗi trong quá trình lặp.
+Các biến thể phức tạp hơn thêm các liên kết bổ sung, cho phép
+việc chèn hoặc loại bỏ một cách hiệu quả từ bất kỳ phần tử nào
+trong chuỗi dựa trên tham chiếu. Một nhược điểm của danh sách liên kết
+là thời gian truy cập tuyến tính (và khó điều chỉnh). Truy cập nhanh hơn,
+như truy cập ngẫu nhiên, là không khả thi. Mảng
+có độ tương phản cache tốt hơn so với danh sách liên kết.
+
+
+*Được làm từ [okso.app](https://okso.app)*
+
+## Mã giải (Pseudocode) cho Các Hoạt Động Cơ Bản
+ *head = đầu,
+ *tail = đuôi,
+ *next = kế tiếp,
+ *node = nút,
+ *value = giá trị
+
+### Chèn (Insert)
+
+```
+ThêmGiáTrị(giá trị) (Add(value))
+ Trước(Pre): giá trị là giá trị muốn thêm vào danh sách
+ Sau(Post): giá trị đã được đặt ở cuối danh sách
+
+ n ← node(value)
+ if head = ø
+ head ← n
+ tail ← n
+ else
+ tail.next ← n
+ tail ← n
+ end if
+end ThêmGiáTrị(Add)
+```
+
+```
+ChènVàoĐầu(giá trị)
+ Trước(Pre): giá trị là giá trị muốn thêm vào danh sách
+ Sau(Post): giá trị đã được đặt ở đầu danh sách
+
+ n ← node(value)
+ n.next ← head
+ head ← n
+ if tail = ø
+ tail ← n
+ end
+end ChènVàoĐầu
+```
+
+### Tìm Kiếm (Search)
+```
+Chứa(đầu, giá trị)
+ Trước: đầu là nút đầu trong danh sách
+ giá trị là giá trị cần tìm kiếm
+ Sau: mục đó có thể ở trong danh sách liên kết, true; nếu không, là false
+ n ← head
+ while n != ø and n.value != value
+ n ← n.next
+ end while
+ if n = ø
+ return false
+ end if
+ return true
+end Contains
+```
+
+### Xóa (Delete)
+```
+Xóa(đầu, giá trị)
+ Trước: đầu là nút đầu trong danh sách
+ giá trị là giá trị cần xóa khỏi danh sách
+ Sau: giá trị đã được xóa khỏi danh sách, true; nếu không, là false
+ if head = ø
+ return false
+ end if
+ n ← head
+ if n.value = value
+ if head = tail
+ head ← ø
+ tail ← ø
+ else
+ head ← head.next
+ end if
+ return true
+ end if
+ while n.next != ø and n.next.value != value
+ n ← n.next
+ end while
+ if n.next != ø
+ if n.next = tail
+ tail ← n
+ tail.next = null
+ else
+ n.next ← n.next.next
+ end if
+ return true
+ end if
+ return false
+end Remove
+```
+
+### Duyệt(raverse)
+Duyệt(đầu)
+ Trước: đầu là nút đầu trong danh sách
+ Sau: các mục trong danh sách đã được duyệt
+ n ← head
+ while n != ø
+ yield n.value
+ n ← n.next
+ end while
+end Traverse
+
+### Duyệt Ngược (Traverse in Reverse)
+DuyệtNgược(đầu, đuôi)
+ Trước: đầu và đuôi thuộc cùng một danh sách
+ Sau: các mục trong danh sách đã được duyệt theo thứ tự ngược lại
+
+## Độ Phức Tạp
+
+### Độ Phức Tạp Thời Gian (Time Complexity)
+
+| Access | Search | Insertion | Deletion |
+| :-------: | :-------: | :-------: | :-------: |
+| O(n) | O(n) | O(1) | O(n) |
+
+## Độ Phức Tạp Không Gian (Space Complexity)
+O(n)
+
+## Tham Khảo
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)
+- [YouTube](https://www.youtube.com/watch?v=njTh_OwMljA&index=2&t=1s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/data-structures/queue/README.vi-VN.md b/src/data-structures/queue/README.vi-VN.md
new file mode 100644
index 0000000000..84b3bdbfa6
--- /dev/null
+++ b/src/data-structures/queue/README.vi-VN.md
@@ -0,0 +1,22 @@
+# Hàng đợi (Queue)
+
+_Đọc bằng ngôn ngữ khác:_
+[_简体中文_](README.zh-CN.md),
+[_Русский_](README.ru-RU.md),
+[_日本語_](README.ja-JP.md),
+[_Português_](README.pt-BR.md),
+[_한국어_](README.ko-KR.md),
+[_Українська_](README.uk-UA.md)
+
+Trong khoa học máy tính, một **hàng đợi** là một loại cụ thể của kiểu dữ liệu trừu tượng hoặc bộ sưu tập trong đó các phần tử trong bộ sưu tập được giữ theo thứ tự và nguyên tắc (hoặc chỉ) các hoạt động trên bộ sưu tập là thêm các phần tử vào vị trí cuối cùng, được gọi là đưa vào hàng đợi (enqueue), và loại bỏ các phần tử từ vị trí đầu tiên, được gọi là đưa ra khỏi hàng đợi (dequeue). Điều này khiến cho hàng đợi trở thành một cấu trúc dữ liệu First-In-First-Out (FIFO). Trong cấu trúc dữ liệu FIFO, phần tử đầu tiên được thêm vào hàng đợi sẽ là phần tử đầu tiên được loại bỏ. Điều này tương đương với yêu cầu rằng sau khi một phần tử mới được thêm vào, tất cả các phần tử đã được thêm vào trước đó phải được loại bỏ trước khi có thể loại bỏ phần tử mới. Thường thì cũng có thêm một hoạt động nhìn hay lấy phần đầu, trả về giá trị của phần tử đầu tiên mà không loại bỏ nó. Hàng đợi là một ví dụ về cấu trúc dữ liệu tuyến tính, hoặc trừu tượng hơn là một bộ sưu tập tuần tự.
+
+Hàng đợi FIFO (First-In-First-Out) có thể được biểu diễn như sau:
+
+
+
+*Made with [okso.app](https://okso.app)*
+
+## Tham Khảo
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Queue_(abstract_data_type))
+- [YouTube](https://www.youtube.com/watch?v=wjI1WNcIntg&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=3&)
diff --git a/src/data-structures/stack/README.vi-VN.md b/src/data-structures/stack/README.vi-VN.md
new file mode 100644
index 0000000000..f051f3201f
--- /dev/null
+++ b/src/data-structures/stack/README.vi-VN.md
@@ -0,0 +1,27 @@
+# Ngăn xếp (stack)
+
+_Đọc bằng ngôn ngữ khác:_
+[_简体中文_](README.zh-CN.md),
+[_Русский_](README.ru-RU.md),
+[_日本語_](README.ja-JP.md),
+[_Português_](README.pt-BR.md),
+[_한국어_](README.ko-KR.md),
+[_Español_](README.es-ES.md),
+[_Українська_](README.uk-UA.md)
+
+Trong khoa học máy tính, một ngăn xếp (stack) là một kiểu dữ liệu trừu tượng phục vụ như một bộ sưu tập các phần tử, với hai hoạt động chính:
+
+đẩy (push), thêm một phần tử vào bộ sưu tập, và
+lấy (pop), loại bỏ phần tử được thêm gần nhất mà chưa được loại bỏ.
+Thứ tự mà các phần tử được lấy ra khỏi ngăn xếp dẫn đến tên gọi thay thế của nó, là LIFO (last in, first out). Ngoài ra, một hoạt động nhìn có thể cung cấp quyền truy cập vào phần trên mà không làm thay đổi ngăn xếp. Tên "ngăn xếp" cho loại cấu trúc này đến từ sự tương tự với một bộ sưu tập các vật phẩm vật lý được xếp chồng lên nhau, điều này làm cho việc lấy một vật phẩm ra khỏi đỉnh của ngăn xếp dễ dàng, trong khi để đến được một vật phẩm sâu hơn trong ngăn xếp có thể đòi hỏi việc lấy ra nhiều vật phẩm khác trước đó.
+
+Biểu diễn đơn giản về thời gian chạy của một ngăn xếp với các hoạt động đẩy và lấy.
+
+
+
+*Made with [okso.app](https://okso.app)*
+
+## Tham Khảo
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)
+- [YouTube](https://www.youtube.com/watch?v=njTh_OwMljA&index=2&t=1s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
From 729bc4d78a2e7f15204bcc406a00605c6251c727 Mon Sep 17 00:00:00 2001
From: Vi Truong <103717482+vivitruong@users.noreply.github.com>
Date: Sat, 9 Mar 2024 10:09:21 -0600
Subject: [PATCH 03/22] Add Vietnamese translation for LinkedList (#1086)
* translate readme from linked list
* add linked list for viet sub
---------
Co-authored-by: Oleksii Trekhleb <trehleb@gmail.com>
From 8959566a36b3b7c28064da04c1522f3920956e22 Mon Sep 17 00:00:00 2001
From: "irene (Irene Tomaini)" <irene.tomaini@gmail.com>
Date: Sat, 9 Mar 2024 17:11:53 +0100
Subject: [PATCH 04/22] fix binary search typo (#1079)
Co-authored-by: Oleksii Trekhleb <trehleb@gmail.com>
---
src/algorithms/search/binary-search/binarySearch.js | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/algorithms/search/binary-search/binarySearch.js b/src/algorithms/search/binary-search/binarySearch.js
index b9e18aab7b..5c8d48fbea 100644
--- a/src/algorithms/search/binary-search/binarySearch.js
+++ b/src/algorithms/search/binary-search/binarySearch.js
@@ -11,7 +11,7 @@ import Comparator from '../../../utils/comparator/Comparator';
export default function binarySearch(sortedArray, seekElement, comparatorCallback) {
// Let's create comparator from the comparatorCallback function.
- // Comparator object will give us common comparison methods like equal() and lessThen().
+ // Comparator object will give us common comparison methods like equal() and lessThan().
const comparator = new Comparator(comparatorCallback);
// These two indices will contain current array (sub-array) boundaries.
From ac78353e3cbc73befb7db1ffd748764ec59d6a50 Mon Sep 17 00:00:00 2001
From: Mira Kwak <kk5448599@gmail.com>
Date: Sun, 10 Mar 2024 01:13:54 +0900
Subject: [PATCH 05/22] feat: added korean translation for trie (#1071)
Co-authored-by: Oleksii Trekhleb <trehleb@gmail.com>
---
src/data-structures/trie/README.ko-KO.md | 19 +++++++++++++++++++
src/data-structures/trie/README.md | 3 ++-
2 files changed, 21 insertions(+), 1 deletion(-)
create mode 100644 src/data-structures/trie/README.ko-KO.md
diff --git a/src/data-structures/trie/README.ko-KO.md b/src/data-structures/trie/README.ko-KO.md
new file mode 100644
index 0000000000..e57142ece4
--- /dev/null
+++ b/src/data-structures/trie/README.ko-KO.md
@@ -0,0 +1,19 @@
+# Trie
+
+_Read this in other languages:_
+[_简体中文_](README.zh-CN.md),
+[_Русский_](README.ru-RU.md),
+[_Português_](README.pt-BR.md),
+[_Українська_](README.uk-UA.md),
+[_한국어_](README.ko-KO.md)
+
+컴퓨터 과학에서 **트라이**는 디지털 트리라고도 불리며 때로는 기수 트리 또는 접두사 트리(접두사로 검색할 수 있기 때문에)라고도 불리며 일종의 검색 트리입니다. 키가 보통 문자열인 동적 집합 또는 연관 배열을 저장하는 데 사용되는 순서가 지정된 트리 데이터 구조입니다. 이진 검색 트리와 달리 트리의 어떤 노드도 해당 노드와 연결된 키를 저장하지 않으며 대신 트리의 위치가 해당 노드와 연결된 키를 정의합니다. 노드의 모든 하위 항목은 해당 노드와 연결된 문자열의 공통 접두사를 가지며 루트는 빈 문자열과 연결됩니다. 값은 모든 노드와 반드시 연결되지는 않습니다. 오히려 값은 나뭇잎과 관심 있는 키에 해당하는 일부 내부 노드에만 연결되는 경향이 있습니다. 접두사 트리의 공간에 최적화된 표현은 콤팩트 접두사 트리를 참조하십시오.
+
+
+
+_Made with [okso.app](https://okso.app)_
+
+## 참조
+
+- [Wikipedia](<https://ko.wikipedia.org/wiki/%ED%8A%B8%EB%9D%BC%EC%9D%B4_(%EC%BB%B4%ED%93%A8%ED%8C%85)>)
+- [YouTube](https://www.youtube.com/watch?v=zIjfhVPRZCg&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=7&t=0s)
diff --git a/src/data-structures/trie/README.md b/src/data-structures/trie/README.md
index 2082fed903..b3bba5de1e 100644
--- a/src/data-structures/trie/README.md
+++ b/src/data-structures/trie/README.md
@@ -4,7 +4,8 @@ _Read this in other languages:_
[_简体中文_](README.zh-CN.md),
[_Русский_](README.ru-RU.md),
[_Português_](README.pt-BR.md),
-[_Українська_](README.uk-UA.md)
+[_Українська_](README.uk-UA.md),
+[_한국어_](README.ko-KO.md)
In computer science, a **trie**, also called digital tree and sometimes
radix tree or prefix tree (as they can be searched by prefixes),
From 2c67b48c21eed86aafbb4d09065ffe391b4fc7e4 Mon Sep 17 00:00:00 2001
From: Oleksii Trekhleb <trehleb@gmail.com>
Date: Sat, 9 Mar 2024 17:15:19 +0100
Subject: [PATCH 06/22] Ad hoc versions of MinHeap, MaxHeap, and DisjointSet
(#1117)
* Add DisjointSetMinimalistic
* Add MinHeapMinimalistic and MaxHeapMinimalistic
* Rename minimalistic to adhoc
* Update README
---
.../disjoint-set/DisjointSetAdhoc.js | 78 ++++++++++++
src/data-structures/disjoint-set/README.md | 5 +
.../__test__/DisjointSetAdhoc.test.js | 50 ++++++++
src/data-structures/heap/MaxHeapAdhoc.js | 115 +++++++++++++++++
src/data-structures/heap/MinHeapAdhoc.js | 117 ++++++++++++++++++
src/data-structures/heap/README.md | 5 +
.../heap/__test__/MaxHeapAdhoc.test.js | 91 ++++++++++++++
.../heap/__test__/MinHeapAdhoc.test.js | 91 ++++++++++++++
8 files changed, 552 insertions(+)
create mode 100644 src/data-structures/disjoint-set/DisjointSetAdhoc.js
create mode 100644 src/data-structures/disjoint-set/__test__/DisjointSetAdhoc.test.js
create mode 100644 src/data-structures/heap/MaxHeapAdhoc.js
create mode 100644 src/data-structures/heap/MinHeapAdhoc.js
create mode 100644 src/data-structures/heap/__test__/MaxHeapAdhoc.test.js
create mode 100644 src/data-structures/heap/__test__/MinHeapAdhoc.test.js
diff --git a/src/data-structures/disjoint-set/DisjointSetAdhoc.js b/src/data-structures/disjoint-set/DisjointSetAdhoc.js
new file mode 100644
index 0000000000..9653418042
--- /dev/null
+++ b/src/data-structures/disjoint-set/DisjointSetAdhoc.js
@@ -0,0 +1,78 @@
+/**
+ * The minimalistic (ad hoc) version of a DisjointSet (or a UnionFind) data structure
+ * that doesn't have external dependencies and that is easy to copy-paste and
+ * use during the coding interview if allowed by the interviewer (since many
+ * data structures in JS are missing).
+ *
+ * Time Complexity:
+ *
+ * - Constructor: O(N)
+ * - Find: O(α(N))
+ * - Union: O(α(N))
+ * - Connected: O(α(N))
+ *
+ * Where N is the number of vertices in the graph.
+ * α refers to the Inverse Ackermann function.
+ * In practice, we assume it's a constant.
+ * In other words, O(α(N)) is regarded as O(1) on average.
+ */
+class DisjointSetAdhoc {
+ /**
+ * Initializes the set of specified size.
+ * @param {number} size
+ */
+ constructor(size) {
+ // The index of a cell is an id of the node in a set.
+ // The value of a cell is an id (index) of the root node.
+ // By default, the node is a parent of itself.
+ this.roots = new Array(size).fill(0).map((_, i) => i);
+
+ // Using the heights array to record the height of each node.
+ // By default each node has a height of 1 because it has no children.
+ this.heights = new Array(size).fill(1);
+ }
+
+ /**
+ * Finds the root of node `a`
+ * @param {number} a
+ * @returns {number}
+ */
+ find(a) {
+ if (a === this.roots[a]) return a;
+ this.roots[a] = this.find(this.roots[a]);
+ return this.roots[a];
+ }
+
+ /**
+ * Joins the `a` and `b` nodes into same set.
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+ union(a, b) {
+ const aRoot = this.find(a);
+ const bRoot = this.find(b);
+
+ if (aRoot === bRoot) return;
+
+ if (this.heights[aRoot] > this.heights[bRoot]) {
+ this.roots[bRoot] = aRoot;
+ } else if (this.heights[aRoot] < this.heights[bRoot]) {
+ this.roots[aRoot] = bRoot;
+ } else {
+ this.roots[bRoot] = aRoot;
+ this.heights[aRoot] += 1;
+ }
+ }
+
+ /**
+ * Checks if `a` and `b` belong to the same set.
+ * @param {number} a
+ * @param {number} b
+ */
+ connected(a, b) {
+ return this.find(a) === this.find(b);
+ }
+}
+
+export default DisjointSetAdhoc;
diff --git a/src/data-structures/disjoint-set/README.md b/src/data-structures/disjoint-set/README.md
index 44bcfa2769..772f68191b 100644
--- a/src/data-structures/disjoint-set/README.md
+++ b/src/data-structures/disjoint-set/README.md
@@ -19,6 +19,11 @@ _MakeSet_ creates 8 singletons.
After some operations of _Union_, some sets are grouped together.
+## Implementation
+
+- [DisjointSet.js](./DisjointSet.js)
+- [DisjointSetAdhoc.js](./DisjointSetAdhoc.js) - The minimalistic (ad hoc) version of a DisjointSet (or a UnionFind) data structure that doesn't have external dependencies and that is easy to copy-paste and use during the coding interview if allowed by the interviewer (since many data structures in JS are missing).
+
## References
- [Wikipedia](https://en.wikipedia.org/wiki/Disjoint-set_data_structure)
diff --git a/src/data-structures/disjoint-set/__test__/DisjointSetAdhoc.test.js b/src/data-structures/disjoint-set/__test__/DisjointSetAdhoc.test.js
new file mode 100644
index 0000000000..f7be0fcde9
--- /dev/null
+++ b/src/data-structures/disjoint-set/__test__/DisjointSetAdhoc.test.js
@@ -0,0 +1,50 @@
+import DisjointSetAdhoc from '../DisjointSetAdhoc';
+
+describe('DisjointSetAdhoc', () => {
+ it('should create unions and find connected elements', () => {
+ const set = new DisjointSetAdhoc(10);
+
+ // 1-2-5-6-7 3-8-9 4
+ set.union(1, 2);
+ set.union(2, 5);
+ set.union(5, 6);
+ set.union(6, 7);
+
+ set.union(3, 8);
+ set.union(8, 9);
+
+ expect(set.connected(1, 5)).toBe(true);
+ expect(set.connected(5, 7)).toBe(true);
+ expect(set.connected(3, 8)).toBe(true);
+
+ expect(set.connected(4, 9)).toBe(false);
+ expect(set.connected(4, 7)).toBe(false);
+
+ // 1-2-5-6-7 3-8-9-4
+ set.union(9, 4);
+
+ expect(set.connected(4, 9)).toBe(true);
+ expect(set.connected(4, 3)).toBe(true);
+ expect(set.connected(8, 4)).toBe(true);
+
+ expect(set.connected(8, 7)).toBe(false);
+ expect(set.connected(2, 3)).toBe(false);
+ });
+
+ it('should keep the height of the tree small', () => {
+ const set = new DisjointSetAdhoc(10);
+
+ // 1-2-6-7-9 1 3 4 5
+ set.union(7, 6);
+ set.union(1, 2);
+ set.union(2, 6);
+ set.union(1, 7);
+ set.union(9, 1);
+
+ expect(set.connected(1, 7)).toBe(true);
+ expect(set.connected(6, 9)).toBe(true);
+ expect(set.connected(4, 9)).toBe(false);
+
+ expect(Math.max(...set.heights)).toBe(3);
+ });
+});
diff --git a/src/data-structures/heap/MaxHeapAdhoc.js b/src/data-structures/heap/MaxHeapAdhoc.js
new file mode 100644
index 0000000000..b9d69c59e0
--- /dev/null
+++ b/src/data-structures/heap/MaxHeapAdhoc.js
@@ -0,0 +1,115 @@
+/**
+ * The minimalistic (ad hoc) version of a MaxHeap data structure that doesn't have
+ * external dependencies and that is easy to copy-paste and use during the
+ * coding interview if allowed by the interviewer (since many data
+ * structures in JS are missing).
+ */
+class MaxHeapAdhoc {
+ constructor(heap = []) {
+ this.heap = [];
+ heap.forEach(this.add);
+ }
+
+ add(num) {
+ this.heap.push(num);
+ this.heapifyUp();
+ }
+
+ peek() {
+ return this.heap[0];
+ }
+
+ poll() {
+ if (this.heap.length === 0) return undefined;
+ const top = this.heap[0];
+ this.heap[0] = this.heap[this.heap.length - 1];
+ this.heap.pop();
+ this.heapifyDown();
+ return top;
+ }
+
+ isEmpty() {
+ return this.heap.length === 0;
+ }
+
+ toString() {
+ return this.heap.join(',');
+ }
+
+ heapifyUp() {
+ let nodeIndex = this.heap.length - 1;
+ while (nodeIndex > 0) {
+ const parentIndex = this.getParentIndex(nodeIndex);
+ if (this.heap[parentIndex] >= this.heap[nodeIndex]) break;
+ this.swap(parentIndex, nodeIndex);
+ nodeIndex = parentIndex;
+ }
+ }
+
+ heapifyDown() {
+ let nodeIndex = 0;
+
+ while (
+ (
+ this.hasLeftChild(nodeIndex) && this.heap[nodeIndex] < this.leftChild(nodeIndex)
+ )
+ || (
+ this.hasRightChild(nodeIndex) && this.heap[nodeIndex] < this.rightChild(nodeIndex)
+ )
+ ) {
+ const leftIndex = this.getLeftChildIndex(nodeIndex);
+ const rightIndex = this.getRightChildIndex(nodeIndex);
+ const left = this.leftChild(nodeIndex);
+ const right = this.rightChild(nodeIndex);
+
+ if (this.hasLeftChild(nodeIndex) && this.hasRightChild(nodeIndex)) {
+ if (left >= right) {
+ this.swap(leftIndex, nodeIndex);
+ nodeIndex = leftIndex;
+ } else {
+ this.swap(rightIndex, nodeIndex);
+ nodeIndex = rightIndex;
+ }
+ } else if (this.hasLeftChild(nodeIndex)) {
+ this.swap(leftIndex, nodeIndex);
+ nodeIndex = leftIndex;
+ }
+ }
+ }
+
+ getLeftChildIndex(parentIndex) {
+ return (2 * parentIndex) + 1;
+ }
+
+ getRightChildIndex(parentIndex) {
+ return (2 * parentIndex) + 2;
+ }
+
+ getParentIndex(childIndex) {
+ return Math.floor((childIndex - 1) / 2);
+ }
+
+ hasLeftChild(parentIndex) {
+ return this.getLeftChildIndex(parentIndex) < this.heap.length;
+ }
+
+ hasRightChild(parentIndex) {
+ return this.getRightChildIndex(parentIndex) < this.heap.length;
+ }
+
+ leftChild(parentIndex) {
+ return this.heap[this.getLeftChildIndex(parentIndex)];
+ }
+
+ rightChild(parentIndex) {
+ return this.heap[this.getRightChildIndex(parentIndex)];
+ }
+
+ swap(indexOne, indexTwo) {
+ const tmp = this.heap[indexTwo];
+ this.heap[indexTwo] = this.heap[indexOne];
+ this.heap[indexOne] = tmp;
+ }
+}
+
+export default MaxHeapAdhoc;
diff --git a/src/data-structures/heap/MinHeapAdhoc.js b/src/data-structures/heap/MinHeapAdhoc.js
new file mode 100644
index 0000000000..c70692f3de
--- /dev/null
+++ b/src/data-structures/heap/MinHeapAdhoc.js
@@ -0,0 +1,117 @@
+/**
+ * The minimalistic (ad hoc) version of a MinHeap data structure that doesn't have
+ * external dependencies and that is easy to copy-paste and use during the
+ * coding interview if allowed by the interviewer (since many data
+ * structures in JS are missing).
+ */
+class MinHeapAdhoc {
+ constructor(heap = []) {
+ this.heap = [];
+ heap.forEach(this.add);
+ }
+
+ add(num) {
+ this.heap.push(num);
+ this.heapifyUp();
+ }
+
+ peek() {
+ return this.heap[0];
+ }
+
+ poll() {
+ if (this.heap.length === 0) return undefined;
+ const top = this.heap[0];
+ this.heap[0] = this.heap[this.heap.length - 1];
+ this.heap.pop();
+ this.heapifyDown();
+ return top;
+ }
+
+ isEmpty() {
+ return this.heap.length === 0;
+ }
+
+ toString() {
+ return this.heap.join(',');
+ }
+
+ heapifyUp() {
+ let nodeIndex = this.heap.length - 1;
+ while (nodeIndex > 0) {
+ const parentIndex = this.getParentIndex(nodeIndex);
+ if (this.heap[parentIndex] <= this.heap[nodeIndex]) break;
+ this.swap(parentIndex, nodeIndex);
+ nodeIndex = parentIndex;
+ }
+ }
+
+ heapifyDown() {
+ let nodeIndex = 0;
+
+ while (
+ (
+ this.hasLeftChild(nodeIndex)
+ && this.heap[nodeIndex] > this.leftChild(nodeIndex)
+ )
+ || (
+ this.hasRightChild(nodeIndex)
+ && this.heap[nodeIndex] > this.rightChild(nodeIndex)
+ )
+ ) {
+ const leftIndex = this.getLeftChildIndex(nodeIndex);
+ const rightIndex = this.getRightChildIndex(nodeIndex);
+ const left = this.leftChild(nodeIndex);
+ const right = this.rightChild(nodeIndex);
+
+ if (this.hasLeftChild(nodeIndex) && this.hasRightChild(nodeIndex)) {
+ if (left <= right) {
+ this.swap(leftIndex, nodeIndex);
+ nodeIndex = leftIndex;
+ } else {
+ this.swap(rightIndex, nodeIndex);
+ nodeIndex = rightIndex;
+ }
+ } else if (this.hasLeftChild(nodeIndex)) {
+ this.swap(leftIndex, nodeIndex);
+ nodeIndex = leftIndex;
+ }
+ }
+ }
+
+ getLeftChildIndex(parentIndex) {
+ return 2 * parentIndex + 1;
+ }
+
+ getRightChildIndex(parentIndex) {
+ return 2 * parentIndex + 2;
+ }
+
+ getParentIndex(childIndex) {
+ return Math.floor((childIndex - 1) / 2);
+ }
+
+ hasLeftChild(parentIndex) {
+ return this.getLeftChildIndex(parentIndex) < this.heap.length;
+ }
+
+ hasRightChild(parentIndex) {
+ return this.getRightChildIndex(parentIndex) < this.heap.length;
+ }
+
+ leftChild(parentIndex) {
+ return this.heap[this.getLeftChildIndex(parentIndex)];
+ }
+
+ rightChild(parentIndex) {
+ return this.heap[this.getRightChildIndex(parentIndex)];
+ }
+
+ swap(indexOne, indexTwo) {
+ const tmp = this.heap[indexTwo];
+ this.heap[indexTwo] = this.heap[indexOne];
+ this.heap[indexOne] = tmp;
+ }
+}
+
+export default MinHeapAdhoc;
diff --git a/src/data-structures/heap/README.md b/src/data-structures/heap/README.md
index 824d646043..392c5c96bc 100644
--- a/src/data-structures/heap/README.md
+++ b/src/data-structures/heap/README.md
@@ -58,6 +58,11 @@ Where:
> In this repository, the [MaxHeap.js](./MaxHeap.js) and [MinHeap.js](./MinHeap.js) are examples of the **Binary** heap.
+## Implementation
+
+- [MaxHeap.js](./MaxHeap.js) and [MinHeap.js](./MinHeap.js)
+- [MaxHeapAdhoc.js](./MaxHeapAdhoc.js) and [MinHeapAdhoc.js](./MinHeapAdhoc.js) - The minimalistic (ad hoc) version of a MinHeap/MaxHeap data structure that doesn't have external dependencies and that is easy to copy-paste and use during the coding interview if allowed by the interviewer (since many data structures in JS are missing).
+
## References
- [Wikipedia](https://en.wikipedia.org/wiki/Heap_(data_structure))
diff --git a/src/data-structures/heap/__test__/MaxHeapAdhoc.test.js b/src/data-structures/heap/__test__/MaxHeapAdhoc.test.js
new file mode 100644
index 0000000000..0217a98ddf
--- /dev/null
+++ b/src/data-structures/heap/__test__/MaxHeapAdhoc.test.js
@@ -0,0 +1,91 @@
+import MaxHeap from '../MaxHeapAdhoc';
+
+describe('MaxHeapAdhoc', () => {
+ it('should create an empty max heap', () => {
+ const maxHeap = new MaxHeap();
+
+ expect(maxHeap).toBeDefined();
+ expect(maxHeap.peek()).toBe(undefined);
+ expect(maxHeap.isEmpty()).toBe(true);
+ });
+
+ it('should add items to the heap and heapify it up', () => {
+ const maxHeap = new MaxHeap();
+
+ maxHeap.add(5);
+ expect(maxHeap.isEmpty()).toBe(false);
+ expect(maxHeap.peek()).toBe(5);
+ expect(maxHeap.toString()).toBe('5');
+
+ maxHeap.add(3);
+ expect(maxHeap.peek()).toBe(5);
+ expect(maxHeap.toString()).toBe('5,3');
+
+ maxHeap.add(10);
+ expect(maxHeap.peek()).toBe(10);
+ expect(maxHeap.toString()).toBe('10,3,5');
+
+ maxHeap.add(1);
+ expect(maxHeap.peek()).toBe(10);
+ expect(maxHeap.toString()).toBe('10,3,5,1');
+
+ maxHeap.add(1);
+ expect(maxHeap.peek()).toBe(10);
+ expect(maxHeap.toString()).toBe('10,3,5,1,1');
+
+ expect(maxHeap.poll()).toBe(10);
+ expect(maxHeap.toString()).toBe('5,3,1,1');
+
+ expect(maxHeap.poll()).toBe(5);
+ expect(maxHeap.toString()).toBe('3,1,1');
+
+ expect(maxHeap.poll()).toBe(3);
+ expect(maxHeap.toString()).toBe('1,1');
+ });
+
+ it('should poll items from the heap and heapify it down', () => {
+ const maxHeap = new MaxHeap();
+
+ maxHeap.add(5);
+ maxHeap.add(3);
+ maxHeap.add(10);
+ maxHeap.add(11);
+ maxHeap.add(1);
+
+ expect(maxHeap.toString()).toBe('11,10,5,3,1');
+
+ expect(maxHeap.poll()).toBe(11);
+ expect(maxHeap.toString()).toBe('10,3,5,1');
+
+ expect(maxHeap.poll()).toBe(10);
+ expect(maxHeap.toString()).toBe('5,3,1');
+
+ expect(maxHeap.poll()).toBe(5);
+ expect(maxHeap.toString()).toBe('3,1');
+
+ expect(maxHeap.poll()).toBe(3);
+ expect(maxHeap.toString()).toBe('1');
+
+ expect(maxHeap.poll()).toBe(1);
+ expect(maxHeap.toString()).toBe('');
+
+ expect(maxHeap.poll()).toBe(undefined);
+ expect(maxHeap.toString()).toBe('');
+ });
+
+ it('should heapify down through the right branch as well', () => {
+ const maxHeap = new MaxHeap();
+
+ maxHeap.add(3);
+ maxHeap.add(12);
+ maxHeap.add(10);
+
+ expect(maxHeap.toString()).toBe('12,3,10');
+
+ maxHeap.add(11);
+ expect(maxHeap.toString()).toBe('12,11,10,3');
+
+ expect(maxHeap.poll()).toBe(12);
+ expect(maxHeap.toString()).toBe('11,3,10');
+ });
+});
diff --git a/src/data-structures/heap/__test__/MinHeapAdhoc.test.js b/src/data-structures/heap/__test__/MinHeapAdhoc.test.js
new file mode 100644
index 0000000000..766b307ff0
--- /dev/null
+++ b/src/data-structures/heap/__test__/MinHeapAdhoc.test.js
@@ -0,0 +1,91 @@
+import MinHeapAdhoc from '../MinHeapAdhoc';
+
+describe('MinHeapAdhoc', () => {
+ it('should create an empty min heap', () => {
+ const minHeap = new MinHeapAdhoc();
+
+ expect(minHeap).toBeDefined();
+ expect(minHeap.peek()).toBe(undefined);
+ expect(minHeap.isEmpty()).toBe(true);
+ });
+
+ it('should add items to the heap and heapify it up', () => {
+ const minHeap = new MinHeapAdhoc();
+
+ minHeap.add(5);
+ expect(minHeap.isEmpty()).toBe(false);
+ expect(minHeap.peek()).toBe(5);
+ expect(minHeap.toString()).toBe('5');
+
+ minHeap.add(3);
+ expect(minHeap.peek()).toBe(3);
+ expect(minHeap.toString()).toBe('3,5');
+
+ minHeap.add(10);
+ expect(minHeap.peek()).toBe(3);
+ expect(minHeap.toString()).toBe('3,5,10');
+
+ minHeap.add(1);
+ expect(minHeap.peek()).toBe(1);
+ expect(minHeap.toString()).toBe('1,3,10,5');
+
+ minHeap.add(1);
+ expect(minHeap.peek()).toBe(1);
+ expect(minHeap.toString()).toBe('1,1,10,5,3');
+
+ expect(minHeap.poll()).toBe(1);
+ expect(minHeap.toString()).toBe('1,3,10,5');
+
+ expect(minHeap.poll()).toBe(1);
+ expect(minHeap.toString()).toBe('3,5,10');
+
+ expect(minHeap.poll()).toBe(3);
+ expect(minHeap.toString()).toBe('5,10');
+ });
+
+ it('should poll items from the heap and heapify it down', () => {
+ const minHeap = new MinHeapAdhoc();
+
+ minHeap.add(5);
+ minHeap.add(3);
+ minHeap.add(10);
+ minHeap.add(11);
+ minHeap.add(1);
+
+ expect(minHeap.toString()).toBe('1,3,10,11,5');
+
+ expect(minHeap.poll()).toBe(1);
+ expect(minHeap.toString()).toBe('3,5,10,11');
+
+ expect(minHeap.poll()).toBe(3);
+ expect(minHeap.toString()).toBe('5,11,10');
+
+ expect(minHeap.poll()).toBe(5);
+ expect(minHeap.toString()).toBe('10,11');
+
+ expect(minHeap.poll()).toBe(10);
+ expect(minHeap.toString()).toBe('11');
+
+ expect(minHeap.poll()).toBe(11);
+ expect(minHeap.toString()).toBe('');
+
+ expect(minHeap.poll()).toBe(undefined);
+ expect(minHeap.toString()).toBe('');
+ });
+
+ it('should heapify down through the right branch as well', () => {
+ const minHeap = new MinHeapAdhoc();
+
+ minHeap.add(3);
+ minHeap.add(12);
+ minHeap.add(10);
+
+ expect(minHeap.toString()).toBe('3,12,10');
+
+ minHeap.add(11);
+ expect(minHeap.toString()).toBe('3,11,10,12');
+
+ expect(minHeap.poll()).toBe(3);
+ expect(minHeap.toString()).toBe('10,11,12');
+ });
+});
From e5b5944c6849389bbfc39f476fa7a1f97d8ce4c6 Mon Sep 17 00:00:00 2001
From: Alexander Cyon <Sajjon@users.noreply.github.com>
Date: Sat, 13 Jul 2024 20:56:39 +0200
Subject: [PATCH 07/22] Fix four typos (#1139)
---
.../uncategorized/best-time-to-buy-sell-stocks/README.md | 2 +-
src/algorithms/uncategorized/n-queens/README.md | 2 +-
src/data-structures/bloom-filter/README.md | 2 +-
src/data-structures/heap/Heap.js | 2 +-
4 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md b/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
index 9446993e98..975eade3a4 100644
--- a/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
+++ b/src/algorithms/uncategorized/best-time-to-buy-sell-stocks/README.md
@@ -46,7 +46,7 @@ Let's say we have an array of prices `[7, 6, 4, 3, 1]` and we're on the _1st_ da
1. _Option 1: Keep the money_ → profit would equal to the profit from buying/selling the rest of the stocks → `keepProfit = profit([6, 4, 3, 1])`.
2. _Option 2: Buy/sell at current price_ → profit in this case would equal to the profit from buying/selling the rest of the stocks plus (or minus, depending on whether we're selling or buying) the current stock price → `buySellProfit = -7 + profit([6, 4, 3, 1])`.
-The overall profit would be equal to → `overalProfit = Max(keepProfit, buySellProfit)`.
+The overall profit would be equal to → `overallProfit = Max(keepProfit, buySellProfit)`.
As you can see the `profit([6, 4, 3, 1])` task is being solved in the same recursive manner.
diff --git a/src/algorithms/uncategorized/n-queens/README.md b/src/algorithms/uncategorized/n-queens/README.md
index 077e26d73d..399256768e 100644
--- a/src/algorithms/uncategorized/n-queens/README.md
+++ b/src/algorithms/uncategorized/n-queens/README.md
@@ -59,7 +59,7 @@ and return false.
queen here leads to a solution.
b) If placing queen in [row, column] leads to a solution then return
true.
- c) If placing queen doesn't lead to a solution then umark this [row,
+ c) If placing queen doesn't lead to a solution then unmark this [row,
column] (Backtrack) and go to step (a) to try other rows.
3) If all rows have been tried and nothing worked, return false to trigger
backtracking.
diff --git a/src/data-structures/bloom-filter/README.md b/src/data-structures/bloom-filter/README.md
index e156310cb4..7880a7f7be 100644
--- a/src/data-structures/bloom-filter/README.md
+++ b/src/data-structures/bloom-filter/README.md
@@ -93,7 +93,7 @@ three factors: the size of the bloom filter, the
number of hash functions we use, and the number
of items that have been inserted into the filter.
-The formula to calculate probablity of a false positive is:
+The formula to calculate probability of a false positive is:
( 1 - e <sup>-kn/m</sup> ) <sup>k</sup>
diff --git a/src/data-structures/heap/Heap.js b/src/data-structures/heap/Heap.js
index 45dfcfa267..b978739ec8 100644
--- a/src/data-structures/heap/Heap.js
+++ b/src/data-structures/heap/Heap.js
@@ -279,7 +279,7 @@ export default class Heap {
/* istanbul ignore next */
pairIsInCorrectOrder(firstElement, secondElement) {
throw new Error(`
- You have to implement heap pair comparision method
+ You have to implement heap pair comparison method
for ${firstElement} and ${secondElement} values.
`);
}
From 9046d80bdb9e5c2e65c87369575a3e47e9c01978 Mon Sep 17 00:00:00 2001
From: Mahdi Azarboon <21277296+azarboon@users.noreply.github.com>
Date: Sun, 14 Jul 2024 02:58:45 +0800
Subject: [PATCH 08/22] Update README.md (#1141)
Before diving into any of the data structures, readers should be reminded of two fundamental laws in software architecture:
1.Everything is a trade-ff
2."Why is more important than the how"
So, readers face the nuances and reality of these data structures from the beginning. These two laws are coined by two thought leaders in software architecture: Mark Richards and Neal Ford. They have explained these two laws in various conference talks and books. For example, here you can read about these two laws here:
https://www.infoq.com/podcasts/software-architecture-hard-parts/
Also, here is a book for reference:
https://a.co/d/fKOodW9
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
README.md | 2 ++
1 file changed, 2 insertions(+)
diff --git a/README.md b/README.md
index e06cfb9075..8fa631425d 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,8 @@ be accessed and modified efficiently. More precisely, a data structure is a coll
values, the relationships among them, and the functions or operations that can be applied to
the data.
+Remember that each data has its own trade-offs. And you need to pay attention more to why you're choosing a certain data structure than to how to implement it.
+
`B` - Beginner, `A` - Advanced
* `B` [Linked List](src/data-structures/linked-list)
From d7a41a64610db25caa4525d61e9f8545fcb491c5 Mon Sep 17 00:00:00 2001
From: Qudratillo <80141037+softXengineer@users.noreply.github.com>
Date: Sun, 14 Jul 2024 00:09:06 +0500
Subject: [PATCH 09/22] feat: added uzbek language (#1082)
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
README.ar-AR.md | 3 +-
README.de-DE.md | 3 +-
README.es-ES.md | 3 +-
README.fr-FR.md | 3 +-
README.id-ID.md | 3 +-
README.it-IT.md | 3 +-
README.ja-JP.md | 3 +-
README.ko-KR.md | 3 +-
README.md | 3 +-
README.pl-PL.md | 3 +-
README.pt-BR.md | 3 +-
README.ru-RU.md | 3 +-
README.tr-TR.md | 3 +-
README.uk-UA.md | 3 +-
README.uz-UZ.md | 358 ++++++++++++++++++++++++++++++++++++++++++++++++
README.zh-CN.md | 3 +-
README.zh-TW.md | 3 +-
17 files changed, 390 insertions(+), 16 deletions(-)
create mode 100644 README.uz-UZ.md
diff --git a/README.ar-AR.md b/README.ar-AR.md
index cbcfd02409..fedd29c0e5 100644
--- a/README.ar-AR.md
+++ b/README.ar-AR.md
@@ -23,7 +23,8 @@ _اقرأ هذا في لغات أخرى:_
[_Türk_](README.tr-TR.md),
[_Italiana_](README.it-IT.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
☝ ملاحضة هذا المشروع مخصص للاستخدام لأغراض التعلم والبحث
فقط ، و ** ليست ** معدة للاستخدام في **الإنتاج**
diff --git a/README.de-DE.md b/README.de-DE.md
index b34ad3563f..9663f7b06b 100644
--- a/README.de-DE.md
+++ b/README.de-DE.md
@@ -24,7 +24,8 @@ _Lies dies in anderen Sprachen:_
[_Italiana_](README.it-IT.md),
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
-[_Arabic_](README.ar-AR.md)
+[_Arabic_](README.ar-AR.md),
+[_Uzbek_](README.uz-UZ.md)
_☝ Beachte, dass dieses Projekt nur für Lern- und Forschungszwecke gedacht ist und **nicht** für den produktiven Einsatz verwendet werden soll_
diff --git a/README.es-ES.md b/README.es-ES.md
index d79baf6022..24d1990a41 100644
--- a/README.es-ES.md
+++ b/README.es-ES.md
@@ -25,7 +25,8 @@ _Léelo en otros idiomas:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Nótese que este proyecto está pensado con fines de aprendizaje e investigación,
y **no** para ser usado en producción.*
diff --git a/README.fr-FR.md b/README.fr-FR.md
index 469a4f52d9..be8258befd 100644
--- a/README.fr-FR.md
+++ b/README.fr-FR.md
@@ -26,7 +26,8 @@ _Lisez ceci dans d'autres langues:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## Data Structures
diff --git a/README.id-ID.md b/README.id-ID.md
index b204f2a8f8..2f4310fee3 100644
--- a/README.id-ID.md
+++ b/README.id-ID.md
@@ -23,7 +23,8 @@ _Baca ini dalam bahasa yang lain:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
_☝ Perhatikan bahwa proyek ini hanya dimaksudkan untuk tujuan pembelajaran dan riset, dan **tidak** dimaksudkan untuk digunakan sebagai produksi._
diff --git a/README.it-IT.md b/README.it-IT.md
index 6ac47fa5bc..a86c52cfbb 100644
--- a/README.it-IT.md
+++ b/README.it-IT.md
@@ -22,7 +22,8 @@ _Leggilo in altre lingue:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Si noti che questo progetto è destinato ad essere utilizzato solo per l'apprendimento e la ricerca e non è destinato ad essere utilizzato per il commercio.*
diff --git a/README.ja-JP.md b/README.ja-JP.md
index e10bb94083..6e3a8b8192 100644
--- a/README.ja-JP.md
+++ b/README.ja-JP.md
@@ -25,7 +25,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## データ構造
diff --git a/README.ko-KR.md b/README.ko-KR.md
index b48c43aa56..9aac387e8d 100644
--- a/README.ko-KR.md
+++ b/README.ko-KR.md
@@ -24,7 +24,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## 자료 구조
diff --git a/README.md b/README.md
index 8fa631425d..a20673989c 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Note that this project is meant to be used for learning and researching purposes
only, and it is **not** meant to be used for production.*
diff --git a/README.pl-PL.md b/README.pl-PL.md
index 52ba75a5e4..9fac028aa3 100644
--- a/README.pl-PL.md
+++ b/README.pl-PL.md
@@ -26,7 +26,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## Struktury Danych
diff --git a/README.pt-BR.md b/README.pt-BR.md
index a937e8c0bf..edb2bd4417 100644
--- a/README.pt-BR.md
+++ b/README.pt-BR.md
@@ -26,7 +26,8 @@ _Leia isto em outros idiomas:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## Estrutura de Dados
diff --git a/README.ru-RU.md b/README.ru-RU.md
index 541e1d2703..b926b5eab3 100644
--- a/README.ru-RU.md
+++ b/README.ru-RU.md
@@ -23,7 +23,8 @@ _Читать на других языках:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Замечание: этот репозиторий предназначен для учебно-исследовательских целей (**не** для использования в продакшн-системах).*
diff --git a/README.tr-TR.md b/README.tr-TR.md
index 805bf7b431..fada4e0b48 100644
--- a/README.tr-TR.md
+++ b/README.tr-TR.md
@@ -23,7 +23,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Not, bu proje araştırma ve öğrenme amacı ile yapılmış
olup üretim için **yapılmamıştır**.*
diff --git a/README.uk-UA.md b/README.uk-UA.md
index dd129b2c3c..e79a8ae845 100644
--- a/README.uk-UA.md
+++ b/README.uk-UA.md
@@ -23,7 +23,8 @@ _Вивчення матеріалу на інших мовах:_
[_Bahasa Indonesia_](README.id-ID.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*☝ Зверніть увагу! Даний проект призначений лише для навчальних та дослідницьких цілей, і він **не** призначений для виробництва (продакшн).*
diff --git a/README.uz-UZ.md b/README.uz-UZ.md
new file mode 100644
index 0000000000..130c1f99d3
--- /dev/null
+++ b/README.uz-UZ.md
@@ -0,0 +1,358 @@
+# JavaScript algoritmlari va ma'lumotlar tuzilmalari
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+
+Bu repozitoriyada JavaScript-ga asoslangan ko'plab mashhur algoritmlar
+va ma'lumotlar tuzilmalarining namunalari mavjud.
+
+Har bir algoritm va ma'lumotlar tuzilmasining alohida README fayli
+bo'lib, unda tegishli tushuntirishlar va qo'shimcha o'qish uchun
+havolalar (shu jumladan YouTube videolariga ham havolalar) mavjud.
+
+_Read this in other languages:_
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_Polski_](README.pl-PL.md),
+[_Français_](README.fr-FR.md),
+[_Español_](README.es-ES.md),
+[_Português_](README.pt-BR.md),
+[_Русский_](README.ru-RU.md),
+[_Türkçe_](README.tr-TR.md),
+[_Italiana_](README.it-IT.md),
+[_Bahasa Indonesia_](README.id-ID.md),
+[_Українська_](README.uk-UA.md),
+[_Arabic_](README.ar-AR.md),
+[_Tiếng Việt_](README.vi-VN.md),
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+
+Yodda tuting, bu loyiha faqat o'quv va tadqiqot maqsadida ishlatilishi
+uchun mo'ljallangan va ishlab chiqarishda ishlatilishi **mumkin emas**.
+
+## Ma'lumotlar tuzilmalari
+
+Ma'lumotlar tuzilmasi - bu kompyuterda ma'lumotlarni samarali tarzda
+olish va o'zgartirish uchun ularni tashkil etish va saqlashning ma'lum
+bir usuli. Ayniqsa, ma'lumotlar tuzilmasi ma'lumot qiymatlarining
+to'plami, ular orasidagi munosabatlar va ma'lumotlarga qo'llanilishi
+mumkin bo'lgan funksiyalar yoki operatsiyalardir.
+
+`B` - Boshlang'ich, `A` - Ilg'or
+
+- `B` [Bog'langan ro'yxat](src/data-structures/linked-list)
+- `B` [Ikki marta bog'langan ro'yxat](src/data-structures/doubly-linked-list)
+- `B` [Navbat](src/data-structures/queue)
+- `B` [Stek](src/data-structures/stack)
+- `B` [Hash jadvali](src/data-structures/hash-table)
+- `B` [Heap](src/data-structures/heap) - maksimal va minimal heap versiyalari
+- `B` [Ustuvor navbat](src/data-structures/priority-queue)
+- `A` [Trie](src/data-structures/trie)
+- `A` [Daraxt](src/data-structures/tree)
+ - `A` [Ikkilik qidiruv daraxt](src/data-structures/tree/binary-search-tree)
+ - `A` [AVL daraxt](src/data-structures/tree/avl-tree)
+ - `A` [Qizil-qora daraxt](src/data-structures/tree/red-black-tree)
+ - `A` [Segment daraxt](src/data-structures/tree/segment-tree) - min/max/sum diapazon so'rovlari bilan misollar
+ - `A` [Fenwick daraxt](src/data-structures/tree/fenwick-tree) (ikkilik indeksli daraxt)
+- `A` [Graf](src/data-structures/graph) (yo'naltirilgan hamda yo'naltirilmagan)
+- `A` [Ajratilgan to'plam](src/data-structures/disjoint-set) - union-find ma'lumotlar strukturasi yoki merge-find to'plami
+- `A` [Bloom filtri](src/data-structures/bloom-filter)
+- `A` [LRU keshi](src/data-structures/lru-cache/) - Eng kam ishlatilgan (LRU) keshi
+
+## Algoritmlar
+
+Algoritm muammolar sinfini qanday hal qilishning aniq spetsifikatsiyasi. Bu operatsiyalar ketma-ketligini aniqlaydigan qoidalar to'plami.
+
+`B` - Boshlang'ich, `A` - Ilg'or
+
+### Mavzu bo'yicha algoritmlar
+
+- **Matematika**
+ - `B` [Bit manipulatsiyasi](src/algorithms/math/bits) - bitlarni qo'yish/olish/yangilash/tozalash, ikkilikka ko'paytirish/bo'lish, manfiy qilish va hokazo.
+ - `B` [Ikkilik suzuvchi nuqta](src/algorithms/math/binary-floating-point) - suzuvchi nuqtali sonlarning ikkilik tasviri.
+ - `B` [Faktorial](src/algorithms/math/factorial)
+ - `B` [Fibonachchi raqam](src/algorithms/math/fibonacci) - klassik va yopiq shakldagi versiyalar
+ - `B` [Asosiy omillar](src/algorithms/math/prime-factors) - tub omillarni topish va ularni Xardi-Ramanujan teoremasi yordamida sanash
+ - `B` [Birlamchilik testi](src/algorithms/math/primality-test) (sinov bo'linish usuli)
+ - `B` [Evklid algoritmi](src/algorithms/math/euclidean-algorithm) - eng katta umumiy bo'luvchini (EKUB) hisoblash
+ - `B` [Eng kichik umumiy karrali](src/algorithms/math/least-common-multiple) (EKUK)
+ - `B` [Eratosfen elagi](src/algorithms/math/sieve-of-eratosthenes) - berilgan chegaragacha barcha tub sonlarni topish
+ - `B` [Ikkining darajasimi](src/algorithms/math/is-power-of-two) - raqamning ikkining darajasi ekanligini tekshirish (sodda va bitli algoritmlar)
+ - `B` [Paskal uchburchagi](src/algorithms/math/pascal-triangle)
+ - `B` [Kompleks sonlar](src/algorithms/math/complex-number) - kompleks sonlar va ular bilan asosiy amallar
+ - `B` [Radian & Daraja](src/algorithms/math/radian) - radianlarni darajaga va orqaga aylantirish
+ - `B` [Tez ko'tarish](src/algorithms/math/fast-powering)
+ - `B` [Horner metodi](src/algorithms/math/horner-method) - polinomlarni baholash
+ - `B` [Matritsalar](src/algorithms/math/matrix) - matritsalar va asosiy matritsa operatsiyalari (ko'paytirish, transpozitsiya va boshqalar).
+ - `B` [Evklid masofasi](src/algorithms/math/euclidean-distance) - ikki nuqta/vektor/matritsa orasidagi masofa
+ - `A` [Butun sonlarni bo'lish](src/algorithms/math/integer-partition)
+ - `A` [Kvadrat ildiz](src/algorithms/math/square-root) - Nyuton metodi
+ - `A` [Liu Hui π algoritmi](src/algorithms/math/liu-hui) - N-gonlarga asoslangan π ning taxminiy hisoblari
+ - `A` [Diskret Furye transformatsiyasi](src/algorithms/math/fourier-transform) - vaqt funksiyasini (signalni) uni tashkil etuvchi chastotalarga ajratish
+- **Sets**
+ - `B` [Karteziya maxsuloti](src/algorithms/sets/cartesian-product) - bir nechta to'plamlarning ko'paytmasi
+ - `B` [Fisher–Yates Shuffle](src/algorithms/sets/fisher-yates) - chekli ketma-ketlikni tasodifiy almashtirish
+ - `A` [Power Set](src/algorithms/sets/power-set) - to'plamning barcha kichik to'plamlari (bitwise, backtracking va kaskadli echimlar)
+ - `A` [Permutatsiyalar](src/algorithms/sets/permutations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Kombinatsiyalar](src/algorithms/sets/combinations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Eng uzun umumiy ketma-ketlik](src/algorithms/sets/longest-common-subsequence) (LCS)
+ - `A` [Eng uzun ortib boruvchi ketma-ketlik](src/algorithms/sets/longest-increasing-subsequence)
+ - `A` [Eng qisqa umumiy ketma-ketlik](src/algorithms/sets/shortest-common-supersequence) (SCS)
+ - `A` [Knapsack muammosi](src/algorithms/sets/knapsack-problem) - "0/1" va "Bir-biriga bog'lanmagan"
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray) - Toʻliq kuch va dinamik dasturlash (Kadane usuli) versiyalari
+ - `A` [Kombinatsiya yig'indisi](src/algorithms/sets/combination-sum) - ma'lum summani tashkil etuvchi barcha kombinatsiyalarni topish
+- **Stringlar**
+ - `B` [Hamming masofasi](src/algorithms/string/hamming-distance) - belgilarning bir-biridan farq qiladigan pozitsiyalar soni
+ - `B` [Palindrom](src/algorithms/string/palindrome) - satrning teskari tomoni ham bir xil ekanligini tekshirish
+ - `A` [Levenshtein masofasi](src/algorithms/string/levenshtein-distance) - ikki ketma-ketlik o'rtasidagi minimal tahrirlash masofasi
+ - `A` [Knuth–Morris–Pratt Algoritmi](src/algorithms/string/knuth-morris-pratt) (KMP Algoritmi) - kichik qatorlarni qidirish (mosh keluvchi naqshni qidirish)
+ - `A` [Z Algoritmi](src/algorithms/string/z-algorithm) - kichik qatorlarni qidirish (mosh keluvchi naqshni qidirish)
+ - `A` [Rabin Karp Algoritmi](src/algorithms/string/rabin-karp) - kichik qatorlarni qidirish
+ - `A` [Eng uzun umumiy kichik matn](src/algorithms/string/longest-common-substring)
+ - `A` [Regulyar ifoda moslashuvi](src/algorithms/string/regular-expression-matching) (RegEx)
+- **Qidiruvlar**
+ - `B` [Linear qidirish](src/algorithms/search/linear-search)
+ - `B` [Jump qidirish](src/algorithms/search/jump-search) (yoki Blok qidirish) - saralangan qatorda qidirish
+ - `B` [Ikkilik qidirish](src/algorithms/search/binary-search) - saralangan qatorda qidirish
+ - `B` [Interpolatsiya qidirish](src/algorithms/search/interpolation-search) - bir tekis taqsimlangan saralangan qatorda qidirish
+- **Tartiblash**
+ - `B` [Pufakcha tartiblash](src/algorithms/sorting/bubble-sort)
+ - `B` [Tanlash tartibi](src/algorithms/sorting/selection-sort)
+ - `B` [Kiritish tartibi](src/algorithms/sorting/insertion-sort)
+ - `B` [Heap tartibi](src/algorithms/sorting/heap-sort)
+ - `B` [Birlashtirish tartibi](src/algorithms/sorting/merge-sort)
+ - `B` [Tezkor saralash](src/algorithms/sorting/quick-sort) - joyida va joyida bo'lmagan amalga oshirish
+ - `B` [Shell tartiblash](src/algorithms/sorting/shell-sort)
+ - `B` [Sanash tartibi](src/algorithms/sorting/counting-sort)
+ - `B` [Radiksli tartiblash](src/algorithms/sorting/radix-sort)
+ - `B` [Bucket tartiblash](src/algorithms/sorting/bucket-sort)
+- **Bog'langan ro'yhatlar**
+ - `B` [To'g'ri traversal](src/algorithms/linked-list/traversal)
+ - `B` [Teskari traversal](src/algorithms/linked-list/reverse-traversal)
+- **Daraxtlar**
+ - `B` [Birinchi-pastga qarab qidirish](src/algorithms/tree/depth-first-search) (Depth-First Search)
+ - `B` [Birinchi-yonga qarab qidirish](src/algorithms/tree/breadth-first-search) (Breadth-First Search)
+- **Grafiklar**
+ - `B` [Birinchi-pastga qarab qidirish](src/algorithms/graph/depth-first-search) (Depth-First Search)
+ - `B` [Birinchi-yonga qarab qidirish](src/algorithms/graph/breadth-first-search) (Breadth-First Search)
+ - `B` [Kruskal Algoritmi](src/algorithms/graph/kruskal) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Dijkstra Algoritmi](src/algorithms/graph/dijkstra) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Bellman-Ford Algoritmi](src/algorithms/graph/bellman-ford) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Floyd-Warshall Algoritmi](src/algorithms/graph/floyd-warshall) - grafikning barcha uchlari orasidagi eng qisqa masofalarni topish
+ - `A` [Siklni aniqlash](src/algorithms/graph/detect-cycle) - yo'naltirilgan va yo'naltirilmagan grafiklar uchun (DFS va Disjoint Set-ga asoslangan versiyalar)
+ - `A` [Prim Algoritmi](src/algorithms/graph/prim) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Topologik saralash](src/algorithms/graph/topological-sorting) - DFS metodi
+ - `A` [Artikulyatsiya nuqtalari](src/algorithms/graph/articulation-points) - Tarjan algoritmi (DFS asosida)
+ - `A` [Ko'priklar](src/algorithms/graph/bridges) - DFS asosidagi algoritm
+ - `A` [Eyler yo'li va Eyler sxemasi](src/algorithms/graph/eulerian-path) - Fleury algoritmi - Har bir chekkaga bir marta tashrif buyurish
+ - `A` [Gamilton sikli](src/algorithms/graph/hamiltonian-cycle) - Har bir cho'qqiga bir marta tashrif buyurish
+ - `A` [Kuchli bog'langan komponentlar](src/algorithms/graph/strongly-connected-components) - Kosaraju algoritmi
+ - `A` [Sayohatchi sotuvchi muammosi](src/algorithms/graph/travelling-salesman) - har bir shaharga tashrif buyuradigan va kelib chiqqan shaharga qaytib keladigan eng qisqa yo'l
+- **Kriptografiya**
+ - `B` [Polynomial Hash](src/algorithms/cryptography/polynomial-hash) - polinomga asoslangan hash funktsiyasi
+ - `B` [Rail Fence Cipher](src/algorithms/cryptography/rail-fence-cipher) - xabarlarni kodlash uchun transpozitsiya shifrlash algoritmi
+ - `B` [Caesar Cipher](src/algorithms/cryptography/caesar-cipher) - oddiy almashtirish shifridir
+ - `B` [Hill Cipher](src/algorithms/cryptography/hill-cipher) - chiziqli algebraga asoslangan almashtirish shifri
+- **Machine Learning**
+ - `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - Mashinalar aslida qanday o'rganishi mumkinligini ko'rsatadigan 7 ta oddiy JS funksiyasi (forward/backward tarqalish)
+ - `B` [k-NN](src/algorithms/ml/knn) - eng yaqin qo'shnilarni tasniflash algoritmi
+ - `B` [k-Means](src/algorithms/ml/k-means) - k-Means kalsterlash algoritmi
+- **Tasvirga ishlov berish**
+ - `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - kontentga moslashuvchan rasm o'lchamini o'zgartirish algoritmi
+- **Statistikalar**
+ - `B` [Weighted Random](src/algorithms/statistics/weighted-random) - elementlarning og'irligi asosida ro'yxatdan tasodifiy elementni tanlash
+- **Evolyutsion algoritmlar**
+ - `A` [Genetik algoritm](https://github.com/trekhleb/self-parking-car-evolution) - avtoturargohni o'rgatish uchun genetik algoritm qanday qo'llanilishiga misol.
+- **Kategoriyasiz**
+ - `B` [Xanoy minorasi](src/algorithms/uncategorized/hanoi-tower)
+ - `B` [Kvadrat matritsaning aylanishi](src/algorithms/uncategorized/square-matrix-rotation) - joyidagi algoritm
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game) - orqaga qaytish, dinamik dasturlash (yuqoridan pastga + pastdan yuqoriga) va ochko'z misollar
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths) - orqaga qaytish, dinamik dasturlash va Paskal uchburchagiga asoslangan misolla
+ - `B` [Yomg'ir teraslari](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini ushlab turish muammosi (dinamik dasturlash va qo'pol kuch versiyalari)
+ - `B` [Rekursiv zinapoya](src/algorithms/uncategorized/recursive-staircase) - yuqoriga chiqish yo'llari sonini hisoblash (4 ta echim)
+ - `B` [Aksiyalarni sotib olish va sotish uchun eng yaxshi vaqt](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - bo'linib-zabt etish va bir marta o'tish misollari
+ - `A` [N-Queens Muommosi](src/algorithms/uncategorized/n-queens)
+ - `A` [Ritsar sayohati](src/algorithms/uncategorized/knight-tour)
+
+### Paradigma bo'yicha algoritmlar
+
+Algorithmic paradigm - bu algoritmlar sinfini loyihalashtirishga asos bo'lib xizmat qiladigan umumiy usul yoki yondashuv. Bu algoritm tushunchasidan yuqori darajadagi abstraktsiya bo'lib, algoritm kompyuter dasturi tushunchasidan yuqori darajadagi abstraktsiya bo'lgani kabi.
+
+- **Brute Force** - barcha imkoniyatlarni ko'rib chiqib va eng yaxshi echimni tanlash
+ - `B` [Chiziqli qidirish](src/algorithms/search/linear-search)
+ - `B` [Yomg'irli teraslar](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini to'plash muammosi
+ - `B` [Rekursiv zinapoya](src/algorithms/uncategorized/recursive-staircase) - cho'qqiga chiqish yo'llari sonini hisoblash
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+ - `A` [Sayohatchi sotuvchi muammosi](src/algorithms/graph/travelling-salesman) - har bir shaharga tashrif buyuradigan va kelib chiqqan shaharga qaytib keladigan eng qisqa yo'l
+ - `A` [Diskret Furye transformatsiyasi](src/algorithms/math/fourier-transform) - vaqt funksiyasini (signalni) uni tashkil etuvchi chastotalarga ajratish
+- **Greedy** - kelajakni o'ylamasdan, hozirgi vaqtda eng yaxshi variantni tanlash
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `A` [Bog'lanmagan yukxalta muammosi](src/algorithms/sets/knapsack-problem)
+ - `A` [Dijkstra Algoritmi](src/algorithms/graph/dijkstra) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Prim Algoritmi](src/algorithms/graph/prim) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+ - `A` [Kruskal Algoritmi](src/algorithms/graph/kruskal) - og'irlikdagi yo'naltirilmagan grafik uchun Minimal kengayuvchi daraxtni (MST) topish
+- **Divide and Conquer** - muammoni kichikroq qismlarga bo'lib va keyin bu qismlarni hal qilish
+
+ - `B` [Ikkilik qidiruv](src/algorithms/search/binary-search)
+ - `B` [Xanoy minorasi](src/algorithms/uncategorized/hanoi-tower)
+ - `B` [Paskal uchburchagi](src/algorithms/math/pascal-triangle)
+ - `B` [Evklid Algoritmi](src/algorithms/math/euclidean-algorithm) - eng katta umumiy bo'luvchini (EKUB) hisoblash
+ - `B` [Birlashtirish tartibi](src/algorithms/sorting/merge-sort)
+ - `B` [Tezkor saralash](src/algorithms/sorting/quick-sort)
+ - `B` [Birinchi-pastga qarab qidirish daraxti](src/algorithms/tree/depth-first-search) (DFS)
+ - `B` [Birinchi-pastga qarab qidirish grafigi](src/algorithms/graph/depth-first-search) (DFS)
+ - `B` [Matritsalar](src/algorithms/math/matrix) - turli shakldagi matritsalarni hosil qilish va kesib o'tish
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Tez ko'tarish](src/algorithms/math/fast-powering)
+ - `B` [Aksiyalarni sotib olish va sotish uchun eng yaxshi vaqt](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - bo'linib-zabt etish va bir marta o'tish misollari
+ - `A` [Permutatsiyalar](src/algorithms/sets/permutations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Kombinatsiyalar](src/algorithms/sets/combinations) (takroriyalash bilan va takroriyalashsiz)
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+
+- **Dinamik dasturlash** - ilgari topilgan kichik yechimlar yordamida yechim yaratish
+ - `B` [Fibonachchi raqam](src/algorithms/math/fibonacci)
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths)
+ - `B` [Yomg'ir teraslari](src/algorithms/uncategorized/rain-terraces) - yomg'ir suvini to'plash muammosi
+ - `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ - `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - kontentga moslashuvchan rasm o'lchamini o'zgartirish algoritmi
+ - `A` [Levenshtein masofasi](src/algorithms/string/levenshtein-distance) - ikki ketma-ketlik o'rtasidagi minimal tahrirlash masofasi
+ - `A` [Eng uzun umumiy ketma-ketlik](src/algorithms/sets/longest-common-subsequence) (LCS)
+ - `A` [Eng uzun umumiy kichik matn](src/algorithms/string/longest-common-substring)
+ - `A` [Eng uzun ortib boruvchi ketma-ketlik](src/algorithms/sets/longest-increasing-subsequence)
+ - `A` [Eng qisqa umumiy ketma-ketlik](src/algorithms/sets/shortest-common-supersequence)
+ - `A` [0/1 Knapsak muommosi](src/algorithms/sets/knapsack-problem)
+ - `A` [Butun sonlarni bo'lish](src/algorithms/math/integer-partition)
+ - `A` [Maksimal kichik massiv](src/algorithms/sets/maximum-subarray)
+ - `A` [Bellman-Ford Algoritmi](src/algorithms/graph/bellman-ford) - grafikning bir cho'qqisidan qolgan barcha nuqtalarga eng qisqa yo'llarni topish
+ - `A` [Floyd-Warshall Algoritmi](src/algorithms/graph/floyd-warshall) -grafikning barcha uchlari orasidagi eng qisqa masofalarni topish
+ - `A` [Regulyar ifoda moslashuvi](src/algorithms/string/regular-expression-matching)
+- **Backtracking** - brute forcega o'xshab, barcha mumkin bo'lgan yechimlarni generatsiya qilishga harakat qiladi, lekin har safar keyingi yechimni yaratganingizda, yechim barcha shartlarga javob beradimi yoki yo'qligini tekshirasiz va shundan keyingina keyingi yechimlarni ishlab chiqarishni davom ettirasiz. Aks holda, orqaga qaytib, yechim topishning boshqa yo'liga o'tasiz. Odatda state-space ning DFS-qidiruvi ishlatiladi.
+ - `B` [Sakrash o'yini](src/algorithms/uncategorized/jump-game)
+ - `B` [Noyob yo'llar](src/algorithms/uncategorized/unique-paths)
+ - `B` [Power Set](src/algorithms/sets/power-set) - to'plamning barcha kichik to'plamlari
+ - `A` [Gamilton sikli](src/algorithms/graph/hamiltonian-cycle) - Har bir cho'qqiga bir marta tashrif buyurish
+ - `A` [N-Queens muommosi](src/algorithms/uncategorized/n-queens)
+ - `A` [Ritsar sayohati](src/algorithms/uncategorized/knight-tour)
+ - `A` [Kombinatsiya yig'indisi](src/algorithms/sets/combination-sum) - ma'lum summani tashkil etuvchi barcha kombinatsiyalarni topish
+- **Branch & Bound** - shu paytgacha topilgan eng arzon echimdan kattaroq xarajatlarga ega qisman echimlarni bekor qilish uchun, backtracking qidiruvining har bir bosqichida topilgan eng arzon echimni eslab qoling va shu paytgacha topilgan eng arzon yechim narxidan muammoni eng kam xarajatli yechim narxining past chegarasi sifatida foydalaning. Odatda state-space daraxtining DFS o'tishi bilan birgalikda BFS traversal qo'llaniladi.
+
+## Ushbu repozitoriyadan qanday foydalanish kerak
+
+**Barcha dependensiylarni o'rnating**
+
+```
+npm install
+```
+
+**ESLint ni ishga tushiring**
+
+Kod sifatini tekshirish uchun ESLint ni ishga tushirishingiz mumkin.
+
+```
+npm run lint
+```
+
+**Barcha testlarni ishga tushuring**
+
+```
+npm test
+```
+
+**Testlarni nom bo'yicha ishga tushirish**
+
+```
+npm test -- 'LinkedList'
+```
+
+**Muammolarni bartaraf qilish (Troubleshooting)**
+
+Agar linting yoki sinov muvaffaqiyatsiz bo'lsa, `node_modules` papkasini o'chirib, npm paketlarini qayta o'rnatishga harakat qiling:
+
+```
+rm -rf ./node_modules
+npm i
+```
+
+Shuningdek, to'g'ri Node versiyasidan foydalanayotganingizga ishonch hosil qiling (`>=16`). Agar Node versiyasini boshqarish uchun [nvm](https://github.com/nvm-sh/nvm) dan foydalanayotgan bo'lsangiz, loyihaning ildiz papkasidan `nvm use` ni ishga tushiring va to'g'ri versiya tanlanadi.
+
+**O'yin maydoni (Playground)**
+
+`./src/playground/playground.js` faylida ma'lumotlar strukturalari va algoritmlar bilan o'ynashingiz, `./src/playground/test/playground.test.js` faylida esa ular uchun testlar yozishingiz mumkin.
+
+Shundan so'ng, playground kodingiz kutilgandek ishlashini tekshirish uchun quyidagi buyruqni ishga tushirishingiz kifoya:
+
+```
+npm test -- 'playground'
+```
+
+## Foydali ma'lumotlar
+
+### Manbalar
+
+- [▶ Data Structures and Algorithms on YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [✍🏻 Data Structure Sketches](https://okso.app/showcase/data-structures)
+
+### Big O Notation
+
+_Big O notation_ algoritmlarni kirish hajmi oshgani sayin ularning ishlash vaqti yoki bo'sh joy talablari qanday o'sishiga qarab tasniflash uchun ishlatiladi. Quyidagi jadvalda siz Big O notatsiyasida ko'rsatilgan algoritmlarning o'sishining eng keng tarqalgan tartiblarini topishingiz mumkin.
+
+
+
+Manba: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+Quyida eng ko'p qo'llaniladigan Big O notatsiyalarining ro'yxati va ularning kirish ma'lumotlarining turli o'lchamlariga nisbatan ishlashini taqqoslash keltirilgan.
+
+| Big O Notatsiya | Turi | 10 ta element uchun hisob-kitoblar | 100 ta element uchun hisob-kitoblar | 1000 ta element uchun hisob-kitoblar |
+| --------------- | ------------ | ---------------------------------- | ----------------------------------- | ------------------------------------ |
+| **O(1)** | O'zgarmas | 1 | 1 | 1 |
+| **O(log N)** | Logarifmik | 3 | 6 | 9 |
+| **O(N)** | Chiziqli | 10 | 100 | 1000 |
+| **O(N log N)** | n log(n) | 30 | 600 | 9000 |
+| **O(N^2)** | Kvadrat | 100 | 10000 | 1000000 |
+| **O(2^N)** | Eksponensial | 1024 | 1.26e+29 | 1.07e+301 |
+| **O(N!)** | Faktorial | 3628800 | 9.3e+157 | 4.02e+2567 |
+
+### Ma'lumotlar tuzilmalarining operatsiyalari murakkabligi
+
+| Ma'lumotlar tuzilmalari | Kirish | Qidirish | Kiritish | O'chirish | Izohlar |
+| --------------------------- | :----: | :------: | :------: | :-------: | :--------------------------------------------------------- |
+| **Massiv** | 1 | n | n | n | |
+| **Stak** | n | n | 1 | 1 | |
+| **Navbat** | n | n | 1 | 1 | |
+| **Bog'langan ro'yhat** | n | n | 1 | n | |
+| **Hash jadval** | - | n | n | n | Mukammal xash funksiyasi bo'lsa, xarajatlar O (1) bo'ladi. |
+| **Ikkilik qidiruv daraxti** | n | n | n | n | Balanslangan daraxt narxida O(log(n)) bo'ladi. |
+| **B-daraxti** | log(n) | log(n) | log(n) | log(n) | |
+| **Qizil-qora daraxt** | log(n) | log(n) | log(n) | log(n) | |
+| **AVL Daraxt** | log(n) | log(n) | log(n) | log(n) | |
+| **Bloom filtri** | - | 1 | 1 | - | Qidiruv paytida noto'g'ri pozitivlar bo'lishi mumkin |
+
+### Massivlarni saralash algoritmlarining murakkabligi
+
+| Nomi | Eng yaxshi | O'rta | Eng yomon | Xotira | Barqaror | Izohlar |
+| ------------------------- | :-----------: | :---------------------: | :-------------------------: | :----: | :------: | :--------------------------------------------------------------------------- |
+| **Pufakcha tartiblash** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Ha | |
+| **Kiritish tartibi** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Ha | |
+| **Tanlash tartibi** | n<sup>2</sup> | n<sup>2</sup> | n<sup>2</sup> | 1 | Yo'q | |
+| **Heap tartibi** | n log(n) | n log(n) | n log(n) | 1 | Yo'q | |
+| **Birlashtirish tartibi** | n log(n) | n log(n) | n log(n) | n | Ha | |
+| **Tezkor saralash** | n log(n) | n log(n) | n<sup>2</sup> | log(n) | Yo'q | Tezkor saralash odatda O(log(n)) stek maydoni bilan joyida amalga oshiriladi |
+| **Shell tartiblash** | n log(n) | depends on gap sequence | n (log(n))<sup>2</sup> | 1 | Yo'q | |
+| **Sanash tartibi** | n + r | n + r | n + r | n + r | Ha | r - massivdagi eng katta raqam |
+| **Radiksli tartiblash** | n \* k | n \* k | n \* k | n + k | Ha | k - eng uzun kalitning uzunligi |
+
+## Loyihani qo'llab-quvvatlovchilar
+
+> Siz ushbu loyihani ❤️️ [GitHub](https://github.com/sponsors/trekhleb) yoki ❤️️ [Patreon](https://www.patreon.com/trekhleb) orqali qo'llab-quvvatlashingiz mumkin.
+
+[Ushbu loyihani qo'llab-quvvatlagan odamlar](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 1`
+
+## Muallif
+
+[@trekhleb](https://trekhleb.dev)
+
+A few more [projects](https://trekhleb.dev/projects/) and [articles](https://trekhleb.dev/blog/) about JavaScript and algorithms on [trekhleb.dev](https://trekhleb.dev)
diff --git a/README.zh-CN.md b/README.zh-CN.md
index cdef9cabea..27982c6553 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -23,7 +23,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
*注意：这个项目仅用于学习和研究，**不是**用于生产环境。*
diff --git a/README.zh-TW.md b/README.zh-TW.md
index 20d4381a2a..aeb0547d2e 100644
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -22,7 +22,8 @@ _Read this in other languages:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
-[_Deutsch_](README.de-DE.md)
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
## 資料結構
From 09afeb58d820ae32d6f3ccfa4042981fae4e1a9d Mon Sep 17 00:00:00 2001
From: Stanislav Dolgachov <s.dolgachov@gmail.com>
Date: Sat, 13 Jul 2024 22:13:11 +0300
Subject: [PATCH 10/22] Update .eslintrc, improve UK translation for LinkedList
(#1128)
* Add ignore patterns to eslint config
* Improve UK translation for LinkedList
---------
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
.eslintrc | 1 +
.../linked-list/README.uk-UA.md | 26 +++++++++----------
2 files changed, 14 insertions(+), 13 deletions(-)
diff --git a/.eslintrc b/.eslintrc
index cf3245bf37..88af3ecf32 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -12,6 +12,7 @@
"arrow-body-style": "off",
"no-loop-func": "off"
},
+ "ignorePatterns": ["*.md", "*.png", "*.jpeg", "*.jpg"],
"settings": {
"react": {
"version": "18.2.0"
diff --git a/src/data-structures/linked-list/README.uk-UA.md b/src/data-structures/linked-list/README.uk-UA.md
index 5424c58db4..9b34a6d828 100644
--- a/src/data-structures/linked-list/README.uk-UA.md
+++ b/src/data-structures/linked-list/README.uk-UA.md
@@ -1,10 +1,10 @@
# Зв'язаний список
-Зв'язаний список — базова динамічна структура даних в інформатиці, що складається з вузлів, кожен з яких містить як дані, так посилання («зв'язку») на наступний вузол списку. Дана структура дозволяє ефективно додавати та видаляти елементи на довільній позиції у послідовності у процесі ітерації. Більш складні варіанти включають додаткові посилання, що дозволяють ефективно додавати та видаляти довільні елементи.
+Зв'язаний список — базова динамічна структура даних в інформатиці, що складається з вузлів, кожен з яких містить як дані, так і посилання («зв'язку») на наступний вузол списку. Ця структура даних дозволяє ефективно додавати та видаляти елементи на довільній позиції у послідовності у процесі ітерації. Більш складні варіанти включають додаткові посилання, що дозволяють ефективно додавати та видаляти довільні елементи.
-Принциповою перевагою перед масивом є структурна гнучкість: порядок елементів зв'язкового списку може збігатися з порядком розташування елементів даних у пам'яті комп'ютера, а порядок обходу списку завжди явно задається його внутрішніми зв'язками. Суть переваги у тому, що у багатьох мовах створення масиву вимагає вказати його заздалегідь. Зв'язковий список дозволяє обійти це обмеження.
+Принциповою перевагою перед масивом є структурна гнучкість: порядок елементів зв'язаного списку може збігатися з порядком розташування елементів даних у пам'яті комп'ютера, а порядок обходу списку завжди явно задається його внутрішніми зв'язками. Це важливо, бо у багатьох мовах створення масиву вимагає вказати його розмір заздалегідь. Зв'язаний список дозволяє обійти це обмеження.
-Недоліком зв'язкових списків є те, що час доступу є лінійним (і важко для реалізації конвеєрів). Неможливий швидкий доступ (випадковий).
+Недоліком зв'язаних списків є те, що час доступу є лінійним (і важко для реалізації конвеєрів). Неможливий швидкий доступ (випадковий).
@@ -17,7 +17,7 @@
```text
Add(value)
Pre: value - значення, що додається
- Post: value поміщено в кінець списку
+ Post: value додано в кінець списку
n ← node(value)
if head = ø
head ← n
@@ -32,7 +32,7 @@ end Add
```text
Prepend(value)
Pre: value - значення, що додається
- Post: value поміщено на початок списку
+ Post: value додано на початку списку
n ← node(value)
n.next ← head
head ← n
@@ -42,7 +42,7 @@ Prepend(value)
end Prepend
```
-### Поиск
+### Пошук
```text
Contains(head, value)
@@ -60,7 +60,7 @@ Contains(head, value)
end Contains
```
-### Вилучення
+### Видалення
```text
Remove(head, value)
@@ -94,7 +94,7 @@ Remove(head, value)
end Remove
```
-### Обход
+### Обхід
```text
Traverse(head)
@@ -108,12 +108,12 @@ Traverse(head)
end Traverse
```
-### Зворотний обхід
+### Зворотній обхід
```text
ReverseTraversal(head, tail)
- Pre: head и tail відносяться до одного списку
- Post: елементи списку пройдено у зворотному порядку
+ Pre: head і tail відносяться до одного списку
+ Post: елементи списку пройдено у зворотньому порядку
if tail != ø
curr ← tail
while curr != head
@@ -131,7 +131,7 @@ end ReverseTraversal
## Складність
-### Тимчасова складність
+### Часова складність
| Читання | Пошук | Вставка | Вилучення |
| :--------: | :-------: | :--------: | :-------: |
@@ -143,5 +143,5 @@ O(n)
## Посилання
-- [Wikipedia](https://uk.wikipedia.org/wiki/%D0%97%D0%B2%27%D1%8F%D0%B7%D0%B0%D0%BD%D0%B8%D0%B9_%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA)
+- [Wikipedia](https://uk.wikipedia.org/wiki/Зв'язаний_список)
- [YouTube](https://www.youtube.com/watch?v=6snsMa4E1Os)
From 6509304ff613f88191155f1f9834aace8db1c149 Mon Sep 17 00:00:00 2001
From: JungHyunLah <leahincom@gmail.com>
Date: Sun, 14 Jul 2024 04:20:23 +0900
Subject: [PATCH 11/22] update LRU Cache translation for ko-KR (#987)
* feat: LRU cache translation in ko-KR
* chore: add readInAnotherLan for ko-KR
---------
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
src/data-structures/lru-cache/README.ko-KR.md | 51 +++++++++++++++++++
src/data-structures/lru-cache/README.md | 15 +++---
2 files changed, 60 insertions(+), 6 deletions(-)
create mode 100644 src/data-structures/lru-cache/README.ko-KR.md
diff --git a/src/data-structures/lru-cache/README.ko-KR.md b/src/data-structures/lru-cache/README.ko-KR.md
new file mode 100644
index 0000000000..93957bc0ed
--- /dev/null
+++ b/src/data-structures/lru-cache/README.ko-KR.md
@@ -0,0 +1,51 @@
+# LRU 캐시 알고리즘
+
+**LRU 캐시 알고리즘** 은 사용된 순서대로 아이템을 정리함으로써, 오랜 시간 동안 사용되지 않은 아이템을 빠르게 찾아낼 수 있도록 한다.
+
+한방향으로만 옷을 걸 수 있는 옷걸이 행거를 생각해봅시다. 가장 오랫동안 입지 않은 옷을 찾기 위해서는, 행거의 반대쪽 끝을 보면 됩니다.
+
+## 문제 정의
+
+LRUCache 클래스를 구현해봅시다:
+
+- `LRUCache(int capacity)` LRU 캐시를 **양수** 의 `capacity` 로 초기화합니다.
+- `int get(int key)` `key` 가 존재할 경우 `key` 값을 반환하고, 그렇지 않으면 `undefined` 를 반환합니다.
+- `void set(int key, int value)` `key` 가 존재할 경우 `key` 값을 업데이트 하고, 그렇지 않으면 `key-value` 쌍을 캐시에 추가합니다. 만약 이 동작으로 인해 키 개수가 `capacity` 를 넘는 경우, 가장 오래된 키 값을 **제거** 합니다.
+
+`get()` 과 `set()` 함수는 무조건 평균 `O(1)` 의 시간 복잡도 내에 실행되어야 합니다.
+
+## 구현
+
+### 버전 1: 더블 링크드 리스트 + 해시맵
+
+[LRUCache.js](./LRUCache.js) 에서 `LRUCache` 구현체 예시를 확인할 수 있습니다. 예시에서는 (평균적으로) 빠른 `O(1)` 캐시 아이템 접근을 위해 `HashMap` 을 사용했고, (평균적으로) 빠른 `O(1)` 캐시 아이템 수정과 제거를 위해 `DoublyLinkedList` 를 사용했습니다. (허용된 최대의 캐시 용량을 유지하기 위해)
+
+
+
+_[okso.app](https://okso.app) 으로 만듦_
+
+LRU 캐시가 어떻게 작동하는지 더 많은 예시로 확인하고 싶다면 LRUCache.test.js](./**test**/LRUCache.test.js) 파일을 참고하세요.
+
+### 버전 2: 정렬된 맵
+
+더블 링크드 리스트로 구현한 첫번째 예시는 어떻게 평균 `O(1)` 시간 복잡도가 `set()` 과 `get()` 으로 나올 수 있는지 학습 목적과 이해를 돕기 위해 좋은 예시입니다.
+
+그러나, 더 쉬운 방법은 자바스크립트의 [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) 객체를 사용하는 것입니다. 이 `Map` 객체는 키-값 쌍과 키를 **추가하는 순서 원본** 을 지닙니다. 우리는 이걸 아이템을 제거하거나 다시 추가하면서 맵의 "가장 마지막" 동작에서 최근에 사용된 아이템을 유지하기 위해 사용할 수 있습니다. `Map` 의 시작점에 있는 아이템은 캐시 용량이 넘칠 경우 가장 먼저 제거되는 대상입니다. 아이템의 순서는 `map.keys()` 와 같은 `IterableIterator` 을 사용해 확인할 수 있습니다.
+
+해당 구현체는 [LRUCacheOnMap.js](./LRUCacheOnMap.js) 의 `LRUCacheOnMap` 예시에서 확인할 수 있습니다.
+
+이 LRU 캐시 방식이 어떻게 작동하는지 더 많은 테스트 케이스를 확인하고 싶다면 [LRUCacheOnMap.test.js](./__test__/LRUCacheOnMap.test.js) 파일을 참고하세요.
+
+## 복잡도
+
+| | 평균 |
+| --------------- | ------ |
+| 공간 | `O(n)` |
+| 아이템 찾기 | `O(1)` |
+| 아이템 설정하기 | `O(1)` |
+
+## 참조
+
+- [LRU Cache on LeetCode](https://leetcode.com/problems/lru-cache/solutions/244744/lru-cache/)
+- [LRU Cache on InterviewCake](https://www.interviewcake.com/concept/java/lru-cache)
+- [LRU Cache on Wiki](https://en.wikipedia.org/wiki/Cache_replacement_policies)
diff --git a/src/data-structures/lru-cache/README.md b/src/data-structures/lru-cache/README.md
index 05bcc0a0f7..eaa075f809 100644
--- a/src/data-structures/lru-cache/README.md
+++ b/src/data-structures/lru-cache/README.md
@@ -1,5 +1,8 @@
# Least Recently Used (LRU) Cache
+_Read this in other languages:_
+[한국어](README.ko-KR.md),
+
A **Least Recently Used (LRU) Cache** organizes items in order of use, allowing you to quickly identify which item hasn't been used for the longest amount of time.
Picture a clothes rack, where clothes are always hung up on one side. To find the least-recently used item, look at the item on the other end of the rack.
@@ -22,7 +25,7 @@ See the `LRUCache` implementation example in [LRUCache.js](./LRUCache.js). The s
-*Made with [okso.app](https://okso.app)*
+_Made with [okso.app](https://okso.app)_
You may also find more test-case examples of how the LRU Cache works in [LRUCache.test.js](./__test__/LRUCache.test.js) file.
@@ -38,11 +41,11 @@ You may also find more test-case examples of how the LRU Cache works in [LRUCach
## Complexities
-| | Average |
-|---|---|
-| Space |`O(n)`|
-| Get item | `O(1)` |
-| Set item | `O(1)` |
+| | Average |
+| -------- | ------- |
+| Space | `O(n)` |
+| Get item | `O(1)` |
+| Set item | `O(1)` |
## References
From 0c054f782aa57f4dbc56975452406b73cba8dc09 Mon Sep 17 00:00:00 2001
From: Youssef Rabei <youssefrabei2003@gmail.com>
Date: Sat, 13 Jul 2024 22:22:10 +0300
Subject: [PATCH 12/22] Update README.ar-AR.md (#959)
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
README.ar-AR.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.ar-AR.md b/README.ar-AR.md
index fedd29c0e5..81c9c91a6f 100644
--- a/README.ar-AR.md
+++ b/README.ar-AR.md
@@ -3,7 +3,7 @@
[](https://travis-ci.org/trekhleb/javascript-algorithms)
[](https://codecov.io/gh/trekhleb/javascript-algorithms)
-تحتوي هذا مقالة على أمثلة عديدة تستند إلى الخوارزميات الشائعة وهياكل البيانات في الجافا سكريبت.
+تحتوي هذه المقالة على أمثلة عديدة تستند إلى الخوارزميات الشائعة وهياكل البيانات في الجافا سكريبت.
كل خوارزمية وهياكل البيانات لها برنامج README منفصل خاص بها
مع التفسيرات والروابط ذات الصلة لمزيد من القراءة (بما في ذلك تلك
From 0e2b2574f83d94adfe5822b1f09203ee60a34a31 Mon Sep 17 00:00:00 2001
From: Nikita Gurskiy <85452618+lilipops@users.noreply.github.com>
Date: Sat, 13 Jul 2024 21:23:02 +0200
Subject: [PATCH 13/22] update the ES README a lenguage correction (#952)
---
README.es-ES.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.es-ES.md b/README.es-ES.md
index 24d1990a41..e6879a19cd 100644
--- a/README.es-ES.md
+++ b/README.es-ES.md
@@ -70,7 +70,7 @@ definen con precisión una secuencia de operaciones.
* **Matemáticas**
* `P` [Manipulación de bits](src/algorithms/math/bits) - asignar/obtener/actualizar/limpiar bits, multiplicación/división por dos, hacer negativo, etc.
* `P` [Factorial](src/algorithms/math/factorial)
- * `P` [Número de Fibonacci](src/algorithms/math/fibonacci)
+ * `P` [Sucesión de Fibonacci](src/algorithms/math/fibonacci)
* `P` [Prueba de primalidad](src/algorithms/math/primality-test) (método de división de prueba)
* `P` [Algoritmo de Euclides](src/algorithms/math/euclidean-algorithm) - calcular el Máximo común divisor (MCD)
* `P` [Mínimo común múltiplo](src/algorithms/math/least-common-multiple) (MCM)
From 351a63a59fdea2e27eb69d50be897c7416a5951a Mon Sep 17 00:00:00 2001
From: Alaz Tetik <alaztetik@gmail.com>
Date: Sat, 13 Jul 2024 22:25:58 +0300
Subject: [PATCH 14/22] Update README.md by correcting Turkish lang name (#904)
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
From 471e6d0791167756d0a7f35a2a197e235bca73f7 Mon Sep 17 00:00:00 2001
From: Enzo <enzovivallo05@hotmail.com>
Date: Sat, 13 Jul 2024 15:27:09 -0400
Subject: [PATCH 15/22] Add es-ES translation to search/binary-search (#893)
---
.../search/binary-search/README.es-ES.md | 27 +++++++++++++++++++
src/algorithms/search/binary-search/README.md | 17 ++++++------
.../search/binary-search/README.pt-BR.md | 1 +
3 files changed, 37 insertions(+), 8 deletions(-)
create mode 100644 src/algorithms/search/binary-search/README.es-ES.md
diff --git a/src/algorithms/search/binary-search/README.es-ES.md b/src/algorithms/search/binary-search/README.es-ES.md
new file mode 100644
index 0000000000..f14aef985f
--- /dev/null
+++ b/src/algorithms/search/binary-search/README.es-ES.md
@@ -0,0 +1,27 @@
+# Búsqueda binaria
+
+_Lea esto en otros idiomas:_
+[English](README.md)
+[Português brasileiro](README.pt-BR.md).
+
+En informática, la búsqueda binaria, también conocida como búsqueda de medio intervalo
+búsqueda, búsqueda logarítmica, o corte binario, es un algoritmo de búsqueda
+que encuentra la posición de un valor objetivo dentro de una matriz
+ordenada. La búsqueda binaria compara el valor objetivo con el elemento central
+de la matriz; si son desiguales, se elimina la mitad en la que
+la mitad en la que no puede estar el objetivo se elimina y la búsqueda continúa
+en la mitad restante hasta que tenga éxito. Si la búsqueda
+termina con la mitad restante vacía, el objetivo no está
+en la matriz.
+
+
+
+## Complejidad
+
+**Complejidad de tiempo**: `O(log(n))` - ya que dividimos el área de búsqueda en dos para cada
+siguiente iteración.
+
+## Referencias
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+- [YouTube](https://www.youtube.com/watch?v=P3YID7liBug&index=29&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
diff --git a/src/algorithms/search/binary-search/README.md b/src/algorithms/search/binary-search/README.md
index ebf3e123e0..34d1bd7a40 100644
--- a/src/algorithms/search/binary-search/README.md
+++ b/src/algorithms/search/binary-search/README.md
@@ -2,15 +2,16 @@
_Read this in other languages:_
[Português brasileiro](README.pt-BR.md).
+[Español](README.es-ES.md).
-In computer science, binary search, also known as half-interval
-search, logarithmic search, or binary chop, is a search algorithm
-that finds the position of a target value within a sorted
-array. Binary search compares the target value to the middle
-element of the array; if they are unequal, the half in which
-the target cannot lie is eliminated and the search continues
-on the remaining half until it is successful. If the search
-ends with the remaining half being empty, the target is not
+In computer science, binary search, also known as half-interval
+search, logarithmic search, or binary chop, is a search algorithm
+that finds the position of a target value within a sorted
+array. Binary search compares the target value to the middle
+element of the array; if they are unequal, the half in which
+the target cannot lie is eliminated and the search continues
+on the remaining half until it is successful. If the search
+ends with the remaining half being empty, the target is not
in the array.
diff --git a/src/algorithms/search/binary-search/README.pt-BR.md b/src/algorithms/search/binary-search/README.pt-BR.md
index 14445a048e..4f9de9f199 100644
--- a/src/algorithms/search/binary-search/README.pt-BR.md
+++ b/src/algorithms/search/binary-search/README.pt-BR.md
@@ -2,6 +2,7 @@
_Leia isso em outras línguas:_
[english](README.md).
+[Español](README.es-ES.md).
Em ciência da computação, busca binária, também conhecida como busca de meio-intervalo, busca logarítmica ou corte binário, é um algoritmo de pesquisa
que encontra a posição de um elemento alvo dentro de um
From e7f30a7bf76ffcbcd37a3163f2a5c8f346aea2e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vicente=20Guti=C3=A9rrez?= <gtz.rvera@gmail.com>
Date: Sat, 13 Jul 2024 13:28:02 -0600
Subject: [PATCH 16/22] Fix typos README.es-ES for linked list (#850)
---
src/data-structures/linked-list/README.es-ES.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/data-structures/linked-list/README.es-ES.md b/src/data-structures/linked-list/README.es-ES.md
index c21c48cded..6c6ba7ee87 100644
--- a/src/data-structures/linked-list/README.es-ES.md
+++ b/src/data-structures/linked-list/README.es-ES.md
@@ -7,9 +7,9 @@ _Lee este artículo en otros idiomas:_
[_Português_](README.pt-BR.md)
[_English_](README.md)
-En ciencias de la computaciòn una **lista enlazada** es una coleccion linear
-de elementos de datos, en los cuales el orden linear no es dado por
-su posciòn fisica en memoria. En cambio, cada
+En ciencias de la computación una **lista enlazada** es una colección lineal
+de elementos, en los cuales el orden lineal no es dado por
+su posición física en memoria. En cambio, cada
elemento señala al siguiente. Es una estructura de datos
que consiste en un grupo de nodos los cuales juntos representan
una secuencia. En su forma más sencilla, cada nodo está
@@ -19,10 +19,10 @@ permite la inserción o eliminación de elementos
desde cualquier posición en la secuencia durante la iteración.
Las variantes más complejas agregan enlaces adicionales, permitiendo
una eficiente inserción o eliminación desde referencias arbitrarias
-del elemento. Una desventaja de las listas lazadas es que el tiempo de
+del elemento. Una desventaja de las listas enlazadas es que el tiempo de
acceso es lineal (y difícil de canalizar). Un acceso
más rápido, como un acceso aleatorio, no es factible. Los arreglos
-tienen una mejor locazion en caché comparados con las listas lazadas.
+tienen una mejor localización en caché comparados con las listas enlazadas.
@@ -112,7 +112,7 @@ Remove(head, value)
end Remove
```
-### Atrevesar
+### Atravesar
```text
Traverse(head)
From ca3d16dcce7a493ae12c03ca20ede4fd7801f7a2 Mon Sep 17 00:00:00 2001
From: Vlad Sosnov <vladsosnov2001@gmail.com>
Date: Sat, 13 Jul 2024 21:28:34 +0200
Subject: [PATCH 17/22] Update README.uk-UA.md (#991)
Co-authored-by: Oleksii Trekhleb <3000285+trekhleb@users.noreply.github.com>
---
src/data-structures/stack/README.uk-UA.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/data-structures/stack/README.uk-UA.md b/src/data-structures/stack/README.uk-UA.md
index 9941114f5b..f71d2274eb 100644
--- a/src/data-structures/stack/README.uk-UA.md
+++ b/src/data-structures/stack/README.uk-UA.md
@@ -10,8 +10,8 @@
Додаткова операція для читання головного елемента (peek) дає доступ
до останнього елементу стека без зміни самого стека.
-Найчастіше принцип роботи стека порівнюють зі чаркою тарілок: щоб узяти другу
-зверху потрібно зняти верхню.
+Найчастіше принцип роботи стека порівнюють із стопкою тарілок: щоб узяти другу
+зверху потрібно спочатку зняти верхню.
Ілюстрація роботи зі стеком.
From ae869ef3faf4f7547e6b047a1d48f45927dd76a4 Mon Sep 17 00:00:00 2001
From: Omotayo Obafemi <obafemitayor@gmail.com>
Date: Sun, 1 Oct 2023 13:21:29 +0100
Subject: [PATCH 18/22] Added algorithm problem that can be solved using stack
data structure
---
README.md | 2 +
.../stack/valid-parentheses/README.md | 44 +++++++++++++++++++
.../__test__/validParentheses.test.js | 23 ++++++++++
.../valid-parentheses/validParentheses.js | 42 ++++++++++++++++++
4 files changed, 111 insertions(+)
create mode 100644 src/algorithms/stack/valid-parentheses/README.md
create mode 100644 src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js
create mode 100644 src/algorithms/stack/valid-parentheses/validParentheses.js
diff --git a/README.md b/README.md
index a20673989c..da1d9dda10 100644
--- a/README.md
+++ b/README.md
@@ -143,6 +143,8 @@ a set of rules that precisely define a sequence of operations.
* **Linked Lists**
* `B` [Straight Traversal](src/algorithms/linked-list/traversal)
* `B` [Reverse Traversal](src/algorithms/linked-list/reverse-traversal)
+* **Stack**
+ * `B` [Valid Parentheses](src/algorithms/stack/valid-parentheses) - check if a string has valid parentheses in the correct order
* **Trees**
* `B` [Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
* `B` [Breadth-First Search](src/algorithms/tree/breadth-first-search) (BFS)
diff --git a/src/algorithms/stack/valid-parentheses/README.md b/src/algorithms/stack/valid-parentheses/README.md
new file mode 100644
index 0000000000..31d7fd60f3
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/README.md
@@ -0,0 +1,44 @@
+# Valid Parentheses Problem
+
+Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+
+An input string is valid if:
+
+Open brackets must be closed by the same type of brackets.
+Open brackets must be closed in the correct order.
+Every close bracket has a corresponding open bracket of the same type.
+
+
+Example 1:
+
+`Input: s = "()"`
+
+Output: true
+
+Example 2:
+
+`Input: s = "()[]{}"`
+
+Output: true
+
+Example 3:
+
+`Input: s = "(]"`
+
+Output: false
+
+This is actually a very common interview question and a very good example of how to use a stack data structure to solve problems.
+
+## Solution
+The problem can be solved in two ways
+
+### Bruteforce Approach
+We can iterate through the string and then for each character in the string, we check for it's last closing character in the the string. Once we find the last closing character in the string, we remove both characters and then repeat the iteration, if we don't find a closing character for an opening character, then the string is invalid. The time complexity of this would be O(n^2) which is not so efficient.
+
+### Using a Stack
+We can use a hashtable to store all opening characters and the value would be the respective closing character. We can then iterate through the string and if we encounter an opening parantheses, we push it's closing character to the stack. If we ecounter a closing paraentheses, then we pop the stack and confirm that the popped element is equal to the current closing parentheses character. If it is not then the string is invalid. At the end of the iteration, we also need to check that the stack is empty. If it is not then the string is invalid. If it is, then the string is valid. This is a more efficient approach with a Time complexity and Space complexity of O(n).
+
+
+## References
+
+- [Leetcode](https://leetcode.com/problems/valid-parentheses/)
diff --git a/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js b/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js
new file mode 100644
index 0000000000..e286688dfd
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/__test__/validParentheses.test.js
@@ -0,0 +1,23 @@
+import isValid from '../validParentheses';
+
+describe('validParentheses', () => {
+ it('should return false when string is empty', () => {
+ expect(isValid('')).toBe(false);
+ });
+
+ it('should return true when string contains valid parentheses in correct order', () => {
+ expect(isValid('()')).toBe(true);
+ expect(isValid('()[]{}')).toBe(true);
+ expect(isValid('((({[]})))')).toBe(true);
+ });
+
+ it('should return false when string contains invalid parentheses', () => {
+ expect(isValid('(]')).toBe(false);
+ expect(isValid('()[]{} }')).toBe(false);
+ expect(isValid('((({[(]})))')).toBe(false);
+ });
+
+ it('should return false when string contains valid parentheses in wrong order', () => {
+ expect(isValid('({)}')).toBe(false);
+ });
+});
diff --git a/src/algorithms/stack/valid-parentheses/validParentheses.js b/src/algorithms/stack/valid-parentheses/validParentheses.js
new file mode 100644
index 0000000000..a327780768
--- /dev/null
+++ b/src/algorithms/stack/valid-parentheses/validParentheses.js
@@ -0,0 +1,42 @@
+import Stack from '../../../data-structures/stack/Stack';
+import HashTable from '../../../data-structures/hash-table/HashTable';
+
+// Declare hashtable containg opening parentheses as key and it's closing parentheses as value.
+const hashTable = new HashTable(3);
+hashTable.set('{', '}');
+hashTable.set('(', ')');
+hashTable.set('[', ']');
+
+/**
+ * Check if string has valid parentheses.
+ *
+ * @param {string} parenthesesString
+ * @return {boolean}
+ */
+export default function isValid(parenthesesString) {
+ // If string is empty return false
+ if (parenthesesString.length === 0) {
+ return false;
+ }
+ // Create stack
+ const stack = new Stack();
+
+ // Loop through each character of string
+ for (let i = 0; i < parenthesesString.length; i += 1) {
+ const currentCharacter = parenthesesString[i];
+ // If character is opening parentheses push it's closing parentheses to stack
+ if (hashTable.has(currentCharacter)) {
+ stack.push(hashTable.get(currentCharacter));
+ } else {
+ /* If character is a closing parentheses then,:
+ check If stack is empty, if it is return false.
+ if stack is not empty, pop from stack and compare it with current character.
+ If they are not same return false. */
+ if (stack.isEmpty() || stack.pop() !== currentCharacter) {
+ return false;
+ }
+ }
+ }
+ // If stack is empty return true else return false
+ return stack.isEmpty();
+}
From 49e0814c434d52c66403a19f0c8c05bd2dfa6628 Mon Sep 17 00:00:00 2001
From: Gianfranco P <899175+gianpaj@users.noreply.github.com>
Date: Fri, 20 Dec 2024 19:35:01 +0000
Subject: [PATCH 19/22] "Italiano" is "italian" in italian :)
---
README.md | 22 +++++++++++-----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/README.md b/README.md
index da1d9dda10..ace86b9c0b 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ _Read this in other languages:_
[_Português_](README.pt-BR.md),
[_Русский_](README.ru-RU.md),
[_Türkçe_](README.tr-TR.md),
-[_Italiana_](README.it-IT.md),
+[_Italiano_](README.it-IT.md),
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
@@ -199,7 +199,7 @@ algorithm is an abstraction higher than a computer program.
* **Brute Force** - look at all the possibilities and selects the best solution
* `B` [Linear Search](src/algorithms/search/linear-search)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
- * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray)
* `A` [Travelling Salesman Problem](src/algorithms/graph/travelling-salesman) - shortest possible route that visits each city and returns to the origin city
* `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up
@@ -230,7 +230,7 @@ algorithm is an abstraction higher than a computer program.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem
- * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top
+ * `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach the top
* `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - content-aware image resizing algorithm
* `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
* `A` [Longest Common Subsequence](src/algorithms/sets/longest-common-subsequence) (LCS)
@@ -243,9 +243,9 @@ algorithm is an abstraction higher than a computer program.
* `A` [Bellman-Ford Algorithm](src/algorithms/graph/bellman-ford) - finding the shortest path to all graph vertices
* `A` [Floyd-Warshall Algorithm](src/algorithms/graph/floyd-warshall) - find the shortest paths between all pairs of vertices
* `A` [Regular Expression Matching](src/algorithms/string/regular-expression-matching)
-* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate next solution you test
-if it satisfies all conditions, and only then continue generating subsequent solutions. Otherwise, backtrack, and go on a
-different path of finding a solution. Normally the DFS traversal of state-space is being used.
+* **Backtracking** - similarly to brute force, try to generate all possible solutions, but each time you generate the next solution, you test
+if it satisfies all conditions and only then continue generating subsequent solutions. Otherwise, backtrack and go on a
+different path to finding a solution. Normally the DFS traversal of state-space is being used.
* `B` [Jump Game](src/algorithms/uncategorized/jump-game)
* `B` [Unique Paths](src/algorithms/uncategorized/unique-paths)
* `B` [Power Set](src/algorithms/sets/power-set) - all subsets of a set
@@ -255,8 +255,8 @@ different path of finding a solution. Normally the DFS traversal of state-space
* `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
* **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
-a least-cost solution to the problem, in order to discard partial solutions with costs larger than the
-lowest-cost solution found so far. Normally BFS traversal in combination with DFS traversal of state-space
+a least-cost solution to the problem in order to discard partial solutions with costs larger than the
+lowest-cost solution found so far. Normally, BFS traversal in combination with DFS traversal of state-space
tree is being used.
## How to use this repository
@@ -296,14 +296,14 @@ rm -rf ./node_modules
npm i
```
-Also make sure that you're using a correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
+Also, make sure that you're using the correct Node version (`>=16`). If you're using [nvm](https://github.com/nvm-sh/nvm) for Node version management you may run `nvm use` from the root folder of the project and the correct version will be picked up.
**Playground**
You may play with data-structures and algorithms in `./src/playground/playground.js` file and write
tests for it in `./src/playground/__test__/playground.test.js`.
-Then just simply run the following command to test if your playground code works as expected:
+Then just, simply run the following command to test if your playground code works as expected:
```
npm test -- 'playground'
@@ -319,7 +319,7 @@ npm test -- 'playground'
### Big O Notation
*Big O notation* is used to classify algorithms according to how their running time or space requirements grow as the input size grows.
-On the chart below you may find most common orders of growth of algorithms specified in Big O notation.
+On the chart below, you may find the most common orders of growth of algorithms specified in Big O notation.
From bd4990955bdd4f06a37d3baa16b6a7910a8401dc Mon Sep 17 00:00:00 2001
From: Maxwell Knight <maxwell.knight98@gmail.com>
Date: Tue, 15 Oct 2024 11:04:00 +0300
Subject: [PATCH 20/22] feat: Added hebrew translation to README in all
languages
---
README.ar-AR.md | 1 +
README.de-DE.md | 1 +
README.es-ES.md | 1 +
README.fr-FR.md | 1 +
README.he-HE.md | 370 ++++++++++++++++++++++++++++++++++++++++++++++++
README.id-ID.md | 1 +
README.it-IT.md | 1 +
README.ja-JP.md | 1 +
README.ko-KR.md | 1 +
README.md | 3 +-
README.pl-PL.md | 1 +
README.pt-BR.md | 1 +
README.ru-RU.md | 1 +
README.tr-TR.md | 1 +
README.uk-UA.md | 1 +
README.uz-UZ.md | 1 +
README.vi-VN.md | 41 +++---
README.zh-CN.md | 1 +
README.zh-TW.md | 1 +
19 files changed, 409 insertions(+), 21 deletions(-)
create mode 100644 README.he-HE.md
diff --git a/README.ar-AR.md b/README.ar-AR.md
index 81c9c91a6f..39997e24a5 100644
--- a/README.ar-AR.md
+++ b/README.ar-AR.md
@@ -25,6 +25,7 @@ _اقرأ هذا في لغات أخرى:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
☝ ملاحضة هذا المشروع مخصص للاستخدام لأغراض التعلم والبحث
فقط ، و ** ليست ** معدة للاستخدام في **الإنتاج**
diff --git a/README.de-DE.md b/README.de-DE.md
index 9663f7b06b..e8f1b4b22b 100644
--- a/README.de-DE.md
+++ b/README.de-DE.md
@@ -26,6 +26,7 @@ _Lies dies in anderen Sprachen:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
_☝ Beachte, dass dieses Projekt nur für Lern- und Forschungszwecke gedacht ist und **nicht** für den produktiven Einsatz verwendet werden soll_
diff --git a/README.es-ES.md b/README.es-ES.md
index e6879a19cd..de4d6889f8 100644
--- a/README.es-ES.md
+++ b/README.es-ES.md
@@ -27,6 +27,7 @@ _Léelo en otros idiomas:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*☝ Nótese que este proyecto está pensado con fines de aprendizaje e investigación,
y **no** para ser usado en producción.*
diff --git a/README.fr-FR.md b/README.fr-FR.md
index be8258befd..d24d5db915 100644
--- a/README.fr-FR.md
+++ b/README.fr-FR.md
@@ -28,6 +28,7 @@ _Lisez ceci dans d'autres langues:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## Data Structures
diff --git a/README.he-HE.md b/README.he-HE.md
new file mode 100644
index 0000000000..43ef196e60
--- /dev/null
+++ b/README.he-HE.md
@@ -0,0 +1,370 @@
+# אלגוריתמים ומבני נתונים ב-JavaScript
+
+[](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
+[](https://codecov.io/gh/trekhleb/javascript-algorithms)
+
+
+מאגר זה מכיל דוגמאות מבוססות JavaScript של אלגוריתמים ומבני נתונים פופולריים רבים.
+
+לכל אלגוריתם ומבנה נתונים יש README משלו עם הסברים קשורים וקישורים לקריאה נוספת (כולל קישורים לסרטוני YouTube).
+
+_קרא זאת בשפות אחרות:_
+[_简体中文_](README.zh-CN.md),
+[_繁體中文_](README.zh-TW.md),
+[_한국어_](README.ko-KR.md),
+[_日本語_](README.ja-JP.md),
+[_Polski_](README.pl-PL.md),
+[_Français_](README.fr-FR.md),
+[_Español_](README.es-ES.md),
+[_Português_](README.pt-BR.md),
+[_Русский_](README.ru-RU.md),
+[_Türkçe_](README.tr-TR.md),
+[_Italiana_](README.it-IT.md),
+[_Bahasa Indonesia_](README.id-ID.md),
+[_Українська_](README.uk-UA.md),
+[_Arabic_](README.ar-AR.md),
+[_Tiếng Việt_](README.vi-VN.md),
+[_Deutsch_](README.de-DE.md),
+[_Uzbek_](README.uz-UZ.md)
+
+*☝ שים לב שפרויקט זה מיועד למטרות לימוד ומחקר בלבד, ואינו מיועד לשימוש בייצור.*
+
+## מבני נתונים
+
+מבנה נתונים הוא דרך מסוימת לארגן ולאחסן נתונים במחשב כך שניתן לגשת אליהם ולשנות אותם ביעילות. ליתר דיוק, מבנה נתונים הוא אוסף של ערכי נתונים, היחסים ביניהם, והפונקציות או הפעולות שניתן ליישם על הנתונים.
+
+זכור שלכל מבנה נתונים יש את היתרונות והחסרונות שלו. חשוב לשים לב יותר לסיבה שבגללה אתה בוחר מבנה נתונים מסוים מאשר לאופן היישום שלו.
+
+`B` - מתחיל, `A` - מתקדם
+
+* `B` [רשימה מקושרת](src/data-structures/linked-list)
+* `B` [רשימה מקושרת כפולה](src/data-structures/doubly-linked-list)
+* `B` [תור](src/data-structures/queue)
+* `B` [מחסנית](src/data-structures/stack)
+* `B` [טבלת גיבוב](src/data-structures/hash-table)
+* `B` [ערימה](src/data-structures/heap) - גרסאות מקסימום ומינימום
+* `B` [תור עדיפויות](src/data-structures/priority-queue)
+* `A` [עץ תחיליות](src/data-structures/trie)
+* `A` [עץ](src/data-structures/tree)
+ * `A` [עץ חיפוש בינארי](src/data-structures/tree/binary-search-tree)
+ * `A` [עץ AVL](src/data-structures/tree/avl-tree)
+ * `A` [עץ אדום-שחור](src/data-structures/tree/red-black-tree)
+ * `A` [עץ מקטעים](src/data-structures/tree/segment-tree) - עם דוגמאות לשאילתות מינימום/מקסימום/סכום של טווח
+ * `A` [עץ פנוויק](src/data-structures/tree/fenwick-tree) (עץ בינארי מאונדקס)
+* `A` [גרף](src/data-structures/graph) (מכוון ולא מכוון)
+* `A` [קבוצה מופרדת](src/data-structures/disjoint-set) - מבנה נתונים של איחוד-מציאה או מיזוג-מציאה
+* `A` [מסנן בלום](src/data-structures/bloom-filter)
+* `A` [מטמון LRU](src/data-structures/lru-cache/) - מטמון פחות שימוש לאחרונה (LRU)
+
+## אלגוריתמים
+
+אלגוריתם הוא מפרט חד משמעי כיצד לפתור סוג של בעיות. זוהי קבוצה של כללים המגדירים במדויק רצף של פעולות.
+
+`B` - מתחיל, `A` - מתקדם
+
+### אלגוריתמים לפי נושא
+
+* **מתמטיקה**
+ * `B` [מניפולציה על ביטים](src/algorithms/math/bits) - קביעה/עדכון/ניקוי ביטים, הכפלה/חילוק ב-2, הפיכה לשלילי וכו'
+ * `B` [נקודה צפה בינארית](src/algorithms/math/binary-floating-point) - ייצוג בינארי של מספרים בנקודה צפה
+ * `B` [פקטוריאל](src/algorithms/math/factorial)
+ * `B` [מספר פיבונאצ'י](src/algorithms/math/fibonacci) - גרסאות קלאסיות וסגורות
+ * `B` [גורמים ראשוניים](src/algorithms/math/prime-factors) - מציאת גורמים ראשוניים וספירתם באמצעות משפט הארדי-רמנוג'אן
+ * `B` [בדיקת ראשוניות](src/algorithms/math/primality-test) (שיטת החלוקה הניסיונית)
+ * `B` [אלגוריתם אוקלידס](src/algorithms/math/euclidean-algorithm) - חישוב המחלק המשותף הגדול ביותר (GCD)
+ * `B` [המכפיל המשותף הקטן ביותר](src/algorithms/math/least-common-multiple) (LCM)
+ * `B` [נפה של ארטוסתנס](src/algorithms/math/sieve-of-eratosthenes) - מציאת כל המספרים הראשוניים עד לגבול כלשהו
+ * `B` [האם חזקה של שתיים](src/algorithms/math/is-power-of-two) - בדיקה אם מספר הוא חזקה של שתיים (אלגוריתמים נאיביים וביטיים)
+ * `B` [משולש פסקל](src/algorithms/math/pascal-triangle)
+ * `B` [מספר מרוכב](src/algorithms/math/complex-number) - מספרים מרוכבים ופעולות בסיסיות עליהם
+ * `B` [רדיאן ומעלות](src/algorithms/math/radian) - המרה מרדיאנים למעלות ובחזרה
+ * `B` [חזקה מהירה](src/algorithms/math/fast-powering)
+ * `B` [שיטת הורנר](src/algorithms/math/horner-method) - הערכת פולינום
+ * `B` [מטריצות](src/algorithms/math/matrix) - מטריצות ופעולות בסיסיות על מטריצות (כפל, טרנספוזיציה וכו')
+ * `B` [מרחק אוקלידי](src/algorithms/math/euclidean-distance) - מרחק בין שתי נקודות/וקטורים/מטריצות
+ * `A` [חלוקת מספר שלם](src/algorithms/math/integer-partition)
+ * `A` [שורש ריבועי](src/algorithms/math/square-root) - שיטת ניוטון
+ * `A` [אלגוריתם π של ליו הוי](src/algorithms/math/liu-hui) - חישובי π מקורבים על בסיס N-גונים
+ * `A` [התמרת פורייה הבדידה](src/algorithms/math/fourier-transform) - פירוק פונקציה של זמן (אות) לתדרים המרכיבים אותה
+
+* **קבוצות**
+ * `B` [מכפלה קרטזית](src/algorithms/sets/cartesian-product) - מכפלה של מספר קבוצות
+ * `B` [ערבוב פישר-ייטס](src/algorithms/sets/fisher-yates) - תמורה אקראית של רצף סופי
+ * `A` [קבוצת חזקה](src/algorithms/sets/power-set) - כל תתי הקבוצות של קבוצה (פתרונות ביטיים, מעקב לאחור וקסקדה)
+ * `A` [תמורות](src/algorithms/sets/permutations) (עם ובלי חזרות)
+ * `A` [צירופים](src/algorithms/sets/combinations) (עם ובלי חזרות)
+ * `A` [תת-רצף משותף ארוך ביותר](src/algorithms/sets/longest-common-subsequence) (LCS)
+ * `A` [תת-רצף עולה ארוך ביותר](src/algorithms/sets/longest-increasing-subsequence)
+ * `A` [על-רצף משותף קצר ביותר](src/algorithms/sets/shortest-common-supersequence) (SCS)
+ * `A` [בעיית התרמיל](src/algorithms/sets/knapsack-problem) - "0/1" ו"לא מוגבל"
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray) - "כוח ברוטלי" ו"תכנות דינמי" (Kadane) גרסאות
+ * `A` [סכום צירוף](src/algorithms/sets/combination-sum) - מציאת כל הצירופים שיוצרים סכום ספציפי
+
+* **מחרוזות**
+ * `B` [מרחק המינג](src/algorithms/string/hamming-distance) - מספר העמדות שבהן הסמלים שונים
+ * `B` [פלינדרום](src/algorithms/string/palindrome) - בדיקה אם המחרוזת זהה בקריאה לאחור
+ * `A` [מרחק לוונשטיין](src/algorithms/string/levenshtein-distance) - מרחק העריכה המינימלי בין שתי רצפים
+ * `A` [אלגוריתם קנות'-מוריס-פראט](src/algorithms/string/knuth-morris-pratt) (אלגוריתם KMP) - חיפוש תת-מחרוזת (התאמת תבנית)
+ * `A` [אלגוריתם Z](src/algorithms/string/z-algorithm) - חיפוש תת-מחרוזת (התאמת תבנית)
+ * `A` [אלגוריתם רבין קארפ](src/algorithms/string/rabin-karp) - חיפוש תת-מחרוזת
+ * `A` [תת-מחרוזת משותפת ארוכה ביותר](src/algorithms/string/longest-common-substring)
+ * `A` [התאמת ביטוי רגולרי](src/algorithms/string/regular-expression-matching)
+
+* **חיפושים**
+ * `B` [חיפוש לינארי](src/algorithms/search/linear-search)
+ * `B` [חיפוש קפיצות](src/algorithms/search/jump-search) (או חיפוש בלוקים) - חיפוש במערך ממוין
+ * `B` [חיפוש בינארי](src/algorithms/search/binary-search) - חיפוש במערך ממוין
+ * `B` [חיפוש אינטרפולציה](src/algorithms/search/interpolation-search) - חיפוש במערך ממוין עם התפלגות אחידה
+
+* **מיון**
+ * `B` [מיון בועות](src/algorithms/sorting/bubble-sort)
+ * `B` [מיון בחירה](src/algorithms/sorting/selection-sort)
+ * `B` [מיון הכנסה](src/algorithms/sorting/insertion-sort)
+ * `B` [מיון ערימה](src/algorithms/sorting/heap-sort)
+ * `B` [מיון מיזוג](src/algorithms/sorting/merge-sort)
+ * `B` [מיון מהיר](src/algorithms/sorting/quick-sort) - יישומים במקום ולא במקום
+ * `B` [מיון צדפות](src/algorithms/sorting/shell-sort)
+ * `B` [מיון ספירה](src/algorithms/sorting/counting-sort)
+ * `B` [מיון בסיס](src/algorithms/sorting/radix-sort)
+ * `B` [מיון דלי](src/algorithms/sorting/bucket-sort)
+
+* **רשימות מקושרות**
+ * `B` [מעבר ישר](src/algorithms/linked-list/traversal)
+ * `B` [מעבר הפוך](src/algorithms/linked-list/reverse-traversal)
+
+* **עצים**
+ * `B` [חיפוש לעומק](src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [חיפוש לרוחב](src/algorithms/tree/breadth-first-search) (BFS)
+
+* **גרפים**
+ * `B` [חיפוש לעומק](src/algorithms/graph/depth-first-search) (DFS)
+ * `B` [חיפוש לרוחב](src/algorithms/graph/breadth-first-search) (BFS)
+ * `B` [אלגוריתם קרוסקל](src/algorithms/graph/kruskal) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+ * `A` [אלגוריתם דייקסטרה](src/algorithms/graph/dijkstra) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף מקודקוד יחיד
+ * `A` [אלגוריתם בלמן-פורד](src/algorithms/graph/bellman-ford) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף מקודקוד יחיד
+ * `A` [אלגוריתם פלויד-וורשל](src/algorithms/graph/floyd-warshall) - מציאת המסלולים הקצרים ביותר בין כל זוגות הקודקודים
+ * `A` [זיהוי מעגל](src/algorithms/graph/detect-cycle) - עבור גרפים מכוונים ולא מכוונים (גרסאות מבוססות DFS וקבוצה מופרדת)
+ * `A` [אלגוריתם פרים](src/algorithms/graph/prim) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+ * `A` [מיון טופולוגי](src/algorithms/graph/topological-sorting) - שיטת DFS
+ * `A` [נקודות חיתוך](src/algorithms/graph/articulation-points) - אלגוריתם טרג'ן (מבוסס DFS)
+ * `A` [גשרים](src/algorithms/graph/bridges) - אלגוריתם מבוסס DFS
+ * `A` [מסלול ומעגל אוילר](src/algorithms/graph/eulerian-path) - אלגוריתם פלרי - ביקור בכל קשת בדיוק פעם אחת
+ * `A` [מעגל המילטון](src/algorithms/graph/hamiltonian-cycle) - ביקור בכל קודקוד בדיוק פעם אחת
+ * `A` [רכיבים קשירים חזק](src/algorithms/graph/strongly-connected-components) - אלגוריתם קוסרג'ו
+ * `A` [בעיית הסוכן הנוסע](src/algorithms/graph/travelling-salesman) - המסלול הקצר ביותר האפשרי שמבקר בכל עיר וחוזר לעיר המוצא
+
+* **הצפנה**
+ * `B` [גיבוב פולינומי](src/algorithms/cryptography/polynomial-hash) - פונקציית גיבוב מתגלגלת המבוססת על פולינום
+ * `B` [צופן גדר מסילה](src/algorithms/cryptography/rail-fence-cipher) - אלגוריתם הצפנת טרנספוזיציה להצפנת הודעות
+ * `B` [צופן קיסר](src/algorithms/cryptography/caesar-cipher) - צופן החלפה פשוט
+ * `B` [צופן היל](src/algorithms/cryptography/hill-cipher) - צופן החלפה המבוסס על אלגברה לינארית
+
+* **למידת מכונה**
+ * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 פונקציות JS פשוטות שמדגימות כיצד מכונות יכולות ללמוד באמת (תפוצה קדימה/אחורה)
+ * `B` [k-NN](src/algorithms/ml/knn) - אלגוריתם סיווג k-השכנים הקרובים ביותר
+ * `B` [k-Means](src/algorithms/ml/k-means) - אלגוריתם אשכול k-Means
+
+* **עיבוד תמונה**
+ * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - אלגוריתם שינוי גודל תמונה מודע תוכן
+
+* **סטטיסטיקה**
+ * `B` [משקל אקראי](src/algorithms/statistics/weighted-random) - בחירת פריט אקראי מהרשימה על בסיס משקלי הפריטים
+
+* **אלגוריתמים אבולוציוניים**
+ * `A` [אלגוריתם גנטי](https://github.com/trekhleb/self-parking-car-evolution) - דוגמה לאופן שבו ניתן ליישם אלגוריתם גנטי לאימון מכוניות בחניה עצמית
+
+* **לא מסווג**
+ * `B` [מגדלי האנוי](src/algorithms/uncategorized/hanoi-tower)
+ * `B` [סיבוב מטריצה ריבועית](src/algorithms/uncategorized/square-matrix-rotation) - אלגוריתם במקום
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game) - דוגמאות למעקב לאחור, תכנות דינמי (מלמעלה למטה + מלמטה למעלה) וחמדני
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths) - דוגמאות למעקב לאחור, תכנות דינמי ומבוססות על משולש פסקל
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם (גרסאות תכנות דינמי וכוח ברוטלי)
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש (4 פתרונות)
+ * `B` [הזמן הטוב ביותר לקנות ולמכור מניות](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - דוגמאות לחלוקה וכיבוש ומעבר אחד
+ * `A` [בעיית N-המלכות](src/algorithms/uncategorized/n-queens)
+ * `A` [סיור הפרש](src/algorithms/uncategorized/knight-tour)
+
+### אלגוריתמים לפי פרדיגמה
+
+פרדיגמה אלגוריתמית היא שיטה או גישה כללית המונחת בבסיס התכנון של מחלקת אלגוריתמים. זוהי הפשטה גבוהה יותר מהמושג של אלגוריתם, בדיוק כפי שאלגוריתם הוא הפשטה גבוהה יותר מתוכנית מחשב.
+
+* **כוח ברוטלי** - בודק את כל האפשרויות ובוחר את הפתרון הטוב ביותר
+ * `B` [חיפוש לינארי](src/algorithms/search/linear-search)
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+ * `A` [בעיית הסוכן הנוסע](src/algorithms/graph/travelling-salesman) - המסלול הקצר ביותר האפשרי שמבקר בכל עיר וחוזר לעיר המוצא
+ * `A` [התמרת פורייה הבדידה](src/algorithms/math/fourier-transform) - פירוק פונקציה של זמן (אות) לתדרים המרכיבים אותה
+
+* **חמדני** - בוחר את האפשרות הטובה ביותר בזמן הנוכחי, ללא כל התחשבות בעתיד
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `A` [בעיית התרמיל הלא מוגבל](src/algorithms/sets/knapsack-problem)
+ * `A` [אלגוריתם דייקסטרה](src/algorithms/graph/dijkstra) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף
+ * `A` [אלגוריתם פרים](src/algorithms/graph/prim) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+ * `A` [אלגוריתם קרוסקל](src/algorithms/graph/kruskal) - מציאת עץ פורש מינימלי (MST) עבור גרף לא מכוון משוקלל
+
+* **חלוקה וכיבוש** - מחלק את הבעיה לחלקים קטנים יותר ואז פותר חלקים אלה
+ * `B` [חיפוש בינארי](src/algorithms/search/binary-search)
+ * `B` [מגדלי האנוי](src/algorithms/uncategorized/hanoi-tower)
+ * `B` [משולש פסקל](src/algorithms/math/pascal-triangle)
+ * `B` [אלגוריתם אוקלידס](src/algorithms/math/euclidean-algorithm) - חישוב המחלק המשותף הגדול ביותר (GCD)
+ * `B` [מיון מיזוג](src/algorithms/sorting/merge-sort)
+ * `B` [מיון מהיר](src/algorithms/sorting/quick-sort)
+ * `B` [חיפוש לעומק בעץ](src/algorithms/tree/depth-first-search) (DFS)
+ * `B` [חיפוש לעומק בגרף](src/algorithms/graph/depth-first-search) (DFS)
+ * `B` [מטריצות](src/algorithms/math/matrix) - יצירה ומעבר על מטריצות בצורות שונות
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [חזקה מהירה](src/algorithms/math/fast-powering)
+ * `B` [הזמן הטוב ביותר לקנות ולמכור מניות](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - דוגמאות לחלוקה וכיבוש ומעבר אחד
+ * `A` [תמורות](src/algorithms/sets/permutations) (עם ובלי חזרות)
+ * `A` [צירופים](src/algorithms/sets/combinations) (עם ובלי חזרות)
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+
+* **תכנות דינמי** - בניית פתרון באמצעות תת-פתרונות שנמצאו קודם לכן
+ * `B` [מספר פיבונאצ'י](src/algorithms/math/fibonacci)
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths)
+ * `B` [מדרגות גשם](src/algorithms/uncategorized/rain-terraces) - בעיית לכידת מי גשם
+ * `B` [מדרגות רקורסיביות](src/algorithms/uncategorized/recursive-staircase) - ספירת מספר הדרכים להגיע לראש
+ * `B` [Seam Carving](src/algorithms/image-processing/seam-carving) - אלגוריתם שינוי גודל תמונה מודע תוכן
+ * `A` [מרחק לוונשטיין](src/algorithms/string/levenshtein-distance) - מרחק העריכה המינימלי בין שתי רצפים
+ * `A` [תת-רצף משותף ארוך ביותר](src/algorithms/sets/longest-common-subsequence) (LCS)
+ * `A` [תת-מחרוזת משותפת ארוכה ביותר](src/algorithms/string/longest-common-substring)
+ * `A` [תת-רצף עולה ארוך ביותר](src/algorithms/sets/longest-increasing-subsequence)
+ * `A` [על-רצף משותף קצר ביותר](src/algorithms/sets/shortest-common-supersequence)
+ * `A` [בעיית התרמיל 0/1](src/algorithms/sets/knapsack-problem)
+ * `A` [חלוקת מספר שלם](src/algorithms/math/integer-partition)
+ * `A` [תת-מערך מקסימלי](src/algorithms/sets/maximum-subarray)
+ * `A` [אלגוריתם בלמן-פורד](src/algorithms/graph/bellman-ford) - מציאת המסלולים הקצרים ביותר לכל קודקודי הגרף
+ * `A` [אלגוריתם פלויד-וורשל](src/algorithms/graph/floyd-warshall) - מציאת המסלולים הקצרים ביותר בין כל זוגות הקודקודים
+ * `A` [התאמת ביטוי רגולרי](src/algorithms/string/regular-expression-matching)
+
+* **מעקב לאחור** - בדומה לכוח ברוטלי, מנסה לייצר את כל הפתרונות האפשריים, אך בכל פעם שאתה מייצר פתרון הבא אתה בודק אם הוא עומד בכל התנאים, ורק אז ממשיך לייצר פתרונות הבאים. אחרת, חוזר אחורה, והולך בנתיב אחר של מציאת פתרון. בדרך כלל מעבר DFS של מרחב המצבים משמש.
+ * `B` [משחק הקפיצות](src/algorithms/uncategorized/jump-game)
+ * `B` [מסלולים ייחודיים](src/algorithms/uncategorized/unique-paths)
+ * `B` [קבוצת חזקה](src/algorithms/sets/power-set) - כל תתי הקבוצות של קבוצה
+ * `A` [מעגל המילטון](src/algorithms/graph/hamiltonian-cycle) - ביקור בכל קודקוד בדיוק פעם אחת
+ * `A` [בעיית N-המלכות](src/algorithms/uncategorized/n-queens)
+ * `A` [סיור הפרש](src/algorithms/uncategorized/knight-tour)
+ * `A` [סכום צירוף](src/algorithms/sets/combination-sum) - מציאת כל הצירופים שיוצרים סכום ספציפי
+
+* **סניף וחסום** - זוכר את הפתרון בעלות הנמוכה ביותר שנמצא בכל שלב של החיפוש המעקב לאחור, ומשתמש בעלות של הפתרון בעלות הנמוכה ביותר שנמצא עד כה כגבול תחתון על העלות של פתרון בעלות מינימלית לבעיה, על מנת לפסול פתרונות חלקיים עם עלויות גדולות יותר מהפתרון בעלות הנמוכה ביותר שנמצא עד כה. בדרך כלל מעבר BFS בשילוב עם מעבר DFS של עץ מרחב המצבים משמש.
+
+## כיצד להשתמש במאגר זה
+
+**התקנת כל התלויות**
+
+```
+npm install
+```
+
+**הרצת ESLint**
+
+ייתכן שתרצה להריץ אותו כדי לבדוק את איכות הקוד.
+
+```
+npm run lint
+```
+
+**הרצת כל הבדיקות**
+
+```
+npm test
+```
+
+**הרצת בדיקות לפי שם**
+
+```
+npm test -- 'LinkedList'
+```
+
+**פתרון בעיות**
+
+אם הלינטינג או הבדיקות נכשלים, נסה למחוק את התיקייה `node_modules` ולהתקין מחדש את חבילות npm:
+
+```
+rm -rf ./node_modules
+npm i
+```
+
+בנוסף, ודא שאתה משתמש בגרסת Node נכונה (`>=16`). אם אתה משתמש ב-[nvm](https://github.com/nvm-sh/nvm) לניהול גרסאות Node, תוכל להריץ `nvm use` מתיקיית השורש של הפרויקט והגרסה הנכונה תיבחר.
+
+**שטח משחקים**
+
+אתה יכול לשחק עם מבני נתונים ואלגוריתמים בקובץ `./src/playground/playground.js` ולכתוב
+בדיקות עבורו ב-`./src/playground/__test__/playground.test.js`.
+
+לאחר מכן פשוט הרץ את הפקודה הבאה כדי לבדוק אם קוד שטח המשחקים שלך עובד כמצופה:
+
+```
+npm test -- 'playground'
+```
+
+## מידע שימושי
+
+### הפניות
+
+- [▶ מבני נתונים ואלגוריתמים ב-YouTube](https://www.youtube.com/playlist?list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [✍🏻 סקיצות של מבני נתונים](https://okso.app/showcase/data-structures)
+
+### סימון ה-O הגדול
+
+סימון *ה-O הגדול* משמש לסיווג אלגוריתמים לפי כיצד זמן הריצה או דרישות המרחב שלהם גדלים ככל שגודל הקלט גדל.
+בתרשים שלהלן תוכל למצוא את הסדרים הנפוצים ביותר של צמיחת אלגוריתמים המצוינים בסימון ה-O הגדול.
+
+
+
+מקור: [Big O Cheat Sheet](http://bigocheatsheet.com/).
+
+להלן רשימה של כמה מסימוני ה-O הגדול הנפוצים ביותר והשוואות הביצועים שלהם מול גדלים שונים של נתוני קלט.
+
+| סימון ה-O הגדול | חישובים ל-10 אלמנטים | חישובים ל-100 אלמנטים | חישובים ל-1000 אלמנטים |
+| ---------------- | --------------------- | ---------------------- | ----------------------- |
+| **O(1)** | 1 | 1 | 1 |
+| **O(log N)** | 3 | 6 | 9 |
+| **O(N)** | 10 | 100 | 1000 |
+| **O(N log N)** | 30 | 600 | 9000 |
+| **O(N^2)** | 100 | 10000 | 1000000 |
+| **O(2^N)** | 1024 | 1.26e+29 | 1.07e+301 |
+| **O(N!)** | 3628800 | 9.3e+157 | 4.02e+2567 |
+
+### מורכבות פעולות מבני נתונים
+
+| מבנה נתונים | גישה | חיפוש | הכנסה | מחיקה | הערות |
+| --------------------- | :-----: | :-----: | :-----: | :-----: | :------ |
+| **מערך** | 1 | n | n | n | |
+| **מחסנית** | n | n | 1 | 1 | |
+| **תור** | n | n | 1 | 1 | |
+| **רשימה מקושרת** | n | n | 1 | n | |
+| **טבלת גיבוב** | - | n | n | n | במקרה של פונקציית גיבוב מושלמת, העלויות יהיו O(1) |
+| **עץ חיפוש בינארי** | n | n | n | n | במקרה של עץ מאוזן, העלויות יהיו O(log(n)) |
+| **עץ B** | log(n) | log(n) | log(n) | log(n) | |
+| **עץ אדום-שחור** | log(n) | log(n) | log(n) | log(n) | |
+| **עץ AVL** | log(n) | log(n) | log(n) | log(n) | |
+| **מסנן בלום** | - | 1 | 1 | - | תוצאות חיוביות שגויות אפשריות בעת חיפוש |
+
+### מורכבות אלגוריתמי מיון מערכים
+
+| שם | הטוב ביותר | ממוצע | הגרוע ביותר | זיכרון | יציב | הערות |
+| ------------------- | :----------------: | :-----------------: | :------------------: | :-----: | :-----: | :------ |
+| **מיון בועות** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | כן | |
+| **מיון הכנסה** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | כן | |
+| **מיון בחירה** | n<sup>2</sup> | n<sup>2</sup> | n<sup>2</sup> | 1 | לא | |
+| **מיון ערימה** | n log(n) | n log(n) | n log(n) | 1 | לא | |
+| **מיון מיזוג** | n log(n) | n log(n) | n log(n) | n | כן | |
+| **מיון מהיר** | n log(n) | n log(n) | n<sup>2</sup> | log(n) | לא | מיון מהיר בדרך כלל מבוצע במקום עם O(log(n)) שטח מחסנית |
+| **מיון צדפות** | n log(n) | תלוי ברצף הפער | n (log(n))<sup>2</sup> | 1 | לא | |
+| **מיון ספירה** | n + r | n + r | n + r | n + r | כן | r - המספר הגדול ביותר במערך |
+| **מיון בסיס** | n * k | n * k | n * k | n + k | כן | k - אורך המפתח הארוך ביותר |
+
+## תומכי הפרויקט
+
+> אתה יכול לתמוך בפרויקט זה דרך ❤️️ [GitHub](https://github.com/sponsors/trekhleb) או ❤️️ [Patreon](https://www.patreon.com/trekhleb).
+
+[אנשים שתומכים בפרויקט זה](https://github.com/trekhleb/javascript-algorithms/blob/master/BACKERS.md) `∑ = 1`
+
+## מחבר
+
+[@trekhleb](https://trekhleb.dev)
+
+כמה [פרויקטים](https://trekhleb.dev/projects/) ו[מאמרים](https://trekhleb.dev/blog/) נוספים על JavaScript ואלגוריתמים ב-[trekhleb.dev](https://trekhleb.dev)* `B` [משחק הקפיצות](src/algorithms/uncategor * `B` [חיפוש בינארי](src/algorithms
diff --git a/README.id-ID.md b/README.id-ID.md
index 2f4310fee3..527abb45f2 100644
--- a/README.id-ID.md
+++ b/README.id-ID.md
@@ -25,6 +25,7 @@ _Baca ini dalam bahasa yang lain:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
_☝ Perhatikan bahwa proyek ini hanya dimaksudkan untuk tujuan pembelajaran dan riset, dan **tidak** dimaksudkan untuk digunakan sebagai produksi._
diff --git a/README.it-IT.md b/README.it-IT.md
index a86c52cfbb..63007d80d9 100644
--- a/README.it-IT.md
+++ b/README.it-IT.md
@@ -24,6 +24,7 @@ _Leggilo in altre lingue:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*☝ Si noti che questo progetto è destinato ad essere utilizzato solo per l'apprendimento e la ricerca e non è destinato ad essere utilizzato per il commercio.*
diff --git a/README.ja-JP.md b/README.ja-JP.md
index 6e3a8b8192..fc584780c2 100644
--- a/README.ja-JP.md
+++ b/README.ja-JP.md
@@ -27,6 +27,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## データ構造
diff --git a/README.ko-KR.md b/README.ko-KR.md
index 9aac387e8d..20b6080eda 100644
--- a/README.ko-KR.md
+++ b/README.ko-KR.md
@@ -26,6 +26,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## 자료 구조
diff --git a/README.md b/README.md
index ace86b9c0b..3201136c03 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,8 @@ _Read this in other languages:_
[_Arabic_](README.ar-AR.md),
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
-[_Uzbek_](README.uz-UZ.md)
+[_Uzbek_](README.uz-UZ.md),
+[_עברית_](README.he-HE.md)
*☝ Note that this project is meant to be used for learning and researching purposes
only, and it is **not** meant to be used for production.*
diff --git a/README.pl-PL.md b/README.pl-PL.md
index 9fac028aa3..f95cfaeb99 100644
--- a/README.pl-PL.md
+++ b/README.pl-PL.md
@@ -28,6 +28,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## Struktury Danych
diff --git a/README.pt-BR.md b/README.pt-BR.md
index edb2bd4417..b451e5da5e 100644
--- a/README.pt-BR.md
+++ b/README.pt-BR.md
@@ -28,6 +28,7 @@ _Leia isto em outros idiomas:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## Estrutura de Dados
diff --git a/README.ru-RU.md b/README.ru-RU.md
index b926b5eab3..a14171f260 100644
--- a/README.ru-RU.md
+++ b/README.ru-RU.md
@@ -25,6 +25,7 @@ _Читать на других языках:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*☝ Замечание: этот репозиторий предназначен для учебно-исследовательских целей (**не** для использования в продакшн-системах).*
diff --git a/README.tr-TR.md b/README.tr-TR.md
index fada4e0b48..2075132bda 100644
--- a/README.tr-TR.md
+++ b/README.tr-TR.md
@@ -25,6 +25,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*☝ Not, bu proje araştırma ve öğrenme amacı ile yapılmış
olup üretim için **yapılmamıştır**.*
diff --git a/README.uk-UA.md b/README.uk-UA.md
index e79a8ae845..c636d21b09 100644
--- a/README.uk-UA.md
+++ b/README.uk-UA.md
@@ -25,6 +25,7 @@ _Вивчення матеріалу на інших мовах:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*☝ Зверніть увагу! Даний проект призначений лише для навчальних та дослідницьких цілей, і він **не** призначений для виробництва (продакшн).*
diff --git a/README.uz-UZ.md b/README.uz-UZ.md
index 130c1f99d3..32a8b509bd 100644
--- a/README.uz-UZ.md
+++ b/README.uz-UZ.md
@@ -29,6 +29,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
Yodda tuting, bu loyiha faqat o'quv va tadqiqot maqsadida ishlatilishi
uchun mo'ljallangan va ishlab chiqarishda ishlatilishi **mumkin emas**.
diff --git a/README.vi-VN.md b/README.vi-VN.md
index a5cbb72e07..6fd4deaaa4 100644
--- a/README.vi-VN.md
+++ b/README.vi-VN.md
@@ -25,6 +25,7 @@ _Đọc bằng ngôn ngữ khác:_
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md)
+[_עברית_](README.he-HE.md)
*☝ Dự án này chỉ được sử dụng cho mục đích học tập và nghiên cứu, **không** được dùng
cho mục đích thương mại.*
@@ -97,19 +98,19 @@ quy tắc xác định chính xác một chuỗi phép toán.
* `A` [Dãy con chung ngắn nhất](src/algorithms/sets/shortest-common-supersequence) (SCS)
* `A` [Bài toán xếp ba lô](src/algorithms/sets/knapsack-problem) - dạng 0-1 và không bị chặn
* `A` [Mảng con lớn nhất](src/algorithms/sets/maximum-subarray) - phiên bản vét cạn và quy hoạch động (Kadane)
- * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
+ * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
* **Chuỗi**
- * `B` [Khoảng cách Hamming](src/algorithms/string/hamming-distance) - số các vị trí các ký hiệu khác nhau
+ * `B` [Khoảng cách Hamming](src/algorithms/string/hamming-distance) - số các vị trí các ký hiệu khác nhau
* `A` [Khoảng cách Levenshtein](src/algorithms/string/levenshtein-distance) - khoảng cách thay đổi nhỏ nhất giữa hai chuỗi ký tự
- * `A` [Thuật toán Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (thuật toán KMP) - tìm chuỗi con (đối sánh mẫu)
+ * `A` [Thuật toán Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (thuật toán KMP) - tìm chuỗi con (đối sánh mẫu)
* `A` [Thuật toán Z](src/algorithms/string/z-algorithm) - tìm chuỗi con (đối sánh mẫu)
* `A` [Thuật toán Rabin Karp](src/algorithms/string/rabin-karp) - tìm chuỗi con
* `A` [Xâu con chung dài nhất](src/algorithms/string/longest-common-substring)
* `A` [Phối biểu thức chính quy](src/algorithms/string/regular-expression-matching)
* **Tìm kiếm**
* `B` [Tìm kiếm tuyến tính](src/algorithms/search/linear-search)
- * `B` [Tìm kiếm nhảy](src/algorithms/search/jump-search) (tìm khối) - tìm kiếm trong mảng đã sắp xếp
- * `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search) - tìm kiếm trong mảng đã sắp xếp
+ * `B` [Tìm kiếm nhảy](src/algorithms/search/jump-search) (tìm khối) - tìm kiếm trong mảng đã sắp xếp
+ * `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search) - tìm kiếm trong mảng đã sắp xếp
* `B` [Tìm kiếm nội suy ](src/algorithms/search/interpolation-search) - Tìm kiếm strong mảng có thứ tự được phân phối đồng nhất
* **Sắp xếp**
* `B` [Sắp xếp nổi bọt](src/algorithms/sorting/bubble-sort)
@@ -144,12 +145,12 @@ quy tắc xác định chính xác một chuỗi phép toán.
* `A` [Các thành phần kết nối chặt](src/algorithms/graph/strongly-connected-components) - Thuật toán Kosaraju
* `A` [Bài toán người bán hàng](src/algorithms/graph/travelling-salesman) - tuyến đường ngắn nhất có thể đến thăm từng thành phố và trở về thành phố gốc
* **Mật mã học**
- * `B` [Băm đa thức](src/algorithms/cryptography/polynomial-hash) - lăn hàm băm dựa trên đa thức
- * `B` [Mật mã hàng rào đường sắt](src/algorithms/cryptography/rail-fence-cipher) - một thuật toán mật mã chuyển vị để mã hóa thông điệp
+ * `B` [Băm đa thức](src/algorithms/cryptography/polynomial-hash) - lăn hàm băm dựa trên đa thức
+ * `B` [Mật mã hàng rào đường sắt](src/algorithms/cryptography/rail-fence-cipher) - một thuật toán mật mã chuyển vị để mã hóa thông điệp
* `B` [Mật mã Caesar](src/algorithms/cryptography/caesar-cipher) - mật mã chuyển vị đơn giản
* `B` [Mật mã Hill](src/algorithms/cryptography/hill-cipher) - mật mã chuyển vị đơn giản dựa trên đại số tuyến tính
* **Học máy**
- * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 hàm JS đơn giản minh họa cách máy tính thực sự có thể học (truyền thuận / truyền ngược)
+ * `B` [NanoNeuron](https://github.com/trekhleb/nano-neuron) - 7 hàm JS đơn giản minh họa cách máy tính thực sự có thể học (truyền thuận / truyền ngược)
* `B` [k-NN](src/algorithms/ml/knn) - thuật toán phân loại k láng giềng gần nhất
* `B` [k-Means](src/algorithms/ml/k-means) - thuật toán phân cụm k-Means
* **Khác**
@@ -167,22 +168,22 @@ quy tắc xác định chính xác một chuỗi phép toán.
Mẫu hình thuật toán là một phương pháp hoặc cách tiếp cận chung làm cơ sở cho việc thiết kế một
lớp thuật toán. Nó là một sự trừu tượng cao hơn khái niệm về một thuật toán, cũng giống như
-một thuật toán là một sự trừu tượng cao hơn một chương trình máy tính.
+một thuật toán là một sự trừu tượng cao hơn một chương trình máy tính.
-* **Vét cạn** - xem xét tất cả các khả năng và chọn giải pháp tốt nhất
+* **Vét cạn** - xem xét tất cả các khả năng và chọn giải pháp tốt nhất
* `B` [Tìm kiếm tuyến tính](src/algorithms/search/linear-search)
* `B` [Thu thập nước mưa](src/algorithms/uncategorized/rain-terraces) - bài toán bẫy nước mưa
* `B` [Cầu thang đệ quy](src/algorithms/uncategorized/recursive-staircase) - đếm số cách lên đến đỉnh
* `A` [Mảng con lớn nhất](src/algorithms/sets/maximum-subarray)
* `A` [Bài toán người bán hàng](src/algorithms/graph/travelling-salesman) - tuyến đường ngắn nhất có thể đến thăm từng thành phố và trở về thành phố gốc
* `A` [Biến đổi Fourier rời rạc](src/algorithms/math/fourier-transform) - phân giải tín hiệu thời gian thành các tần số tạo nên tín hiệu đó
-* **Tham lam** - chọn phương án tốt nhất vào thời điểm hiện tại mà không cần cân nhắc đến tương lai
+* **Tham lam** - chọn phương án tốt nhất vào thời điểm hiện tại mà không cần cân nhắc đến tương lai
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `A` [Bài xếp ba lô không bị chặn](src/algorithms/sets/knapsack-problem)
* `A` [Thuật toán Dijkstra](src/algorithms/graph/dijkstra) - tìm những đường ngắn nhất từ một định tới tất cả các đỉnh
* `A` [Thuật toán Prim](src/algorithms/graph/prim) - tìm cây bao trùm nhỏ nhất (MST) cho đồ thị vô hướng có trọng số
* `A` [Thuật toán Kruskal](src/algorithms/graph/kruskal) - tìm cây bao trùm nhỏ nhất (MST) cho đồ thị vô hướng có trọng số
-* **Chia để trị** - chia vấn đề thành các phần nhỏ hơn rồi giải quyết các phần đó
+* **Chia để trị** - chia vấn đề thành các phần nhỏ hơn rồi giải quyết các phần đó
* `B` [Tìm kiếm nhị phân](src/algorithms/search/binary-search)
* `B` [Tháp Hà Nội](src/algorithms/uncategorized/hanoi-tower)
* `B` [Tam giác Pascal](src/algorithms/math/pascal-triangle)
@@ -191,7 +192,7 @@ một thuật toán là một sự trừu tượng cao hơn một chương trìn
* `B` [Sắp xếp nhanh](src/algorithms/sorting/quick-sort)
* `B` [Cây tìm kiếm theo chiều sâu](src/algorithms/tree/depth-first-search) (DFS)
* `B` [Đồ thị tìm kiếm theo chiều sâu](src/algorithms/graph/depth-first-search) (DFS)
- * `B` [Ma trận](src/algorithms/math/matrix) - tạo và duyệt các ma trận có kích thước khác nhau
+ * `B` [Ma trận](src/algorithms/math/matrix) - tạo và duyệt các ma trận có kích thước khác nhau
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `B` [Tính nhanh lũy thừa](src/algorithms/math/fast-powering)
* `B` [Thời điểm tốt nhất để mua bán cổ phiếu](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - ví dụ chia để trị và một đường chuyền
@@ -216,18 +217,18 @@ một thuật toán là một sự trừu tượng cao hơn một chương trìn
* `A` [Phối biểu thức chính quy](src/algorithms/string/regular-expression-matching)
* **Quay lui** - tương tự như vét cạn, cố tạo ra tất cả các giải pháp có thể, nhưng mỗi lần bạn tạo ra giải pháp tiếp theo,
bạn sẽ kiểm tra xem nó có thỏa mãn tất cả các điều kiện hay không và chỉ khi thỏa mãn mới tiếp tục tạo ra các giải pháp tiếp theo.
-Nếu không, hãy quay lại và đi trên một con đường khác để tìm ra giải pháp. Thông thường, truyền DFS của không gian trạng thái được sử dụng.
+Nếu không, hãy quay lại và đi trên một con đường khác để tìm ra giải pháp. Thông thường, truyền DFS của không gian trạng thái được sử dụng.
* `B` [Trò chơi nhảy](src/algorithms/uncategorized/jump-game)
* `B` [Đường đi độc nhất](src/algorithms/uncategorized/unique-paths)
* `B` [Tập lũy thừa](src/algorithms/sets/power-set) - tập hợp chứa tất cả các tập con
* `A` [Chu trình Hamilton](src/algorithms/graph/hamiltonian-cycle) - đi qua các đỉnh một lần duy nhất
* `A` [Bài toán n quân hậu](src/algorithms/uncategorized/n-queens)
* `A` [Mã đi tuần](src/algorithms/uncategorized/knight-tour)
- * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
+ * `A` [Tổ hợp của tổng](src/algorithms/sets/combination-sum) - tìm tất cả các tổ hợp tạo thành tổng cụ thể
* **Branch & Bound** - ghi nhớ giải pháp chi với phí thấp nhất được tìm thấy ở mỗi giai đoạn của quá trình tìm kiếm quay lui,
sử dụng chi phí của giải pháp có chi phí thấp nhất được tìm thấy cho đến nay như một giới hạn dưới về chi phí của
-một giải pháp ít chi phí nhân cho bài toán, để loại bỏ các giải pháp từng phần với chi phí lớn hơn giải pháp chi phí thấp nhất được tìm thấy cho đến nay.
-Thông thường BFS duyệt kết hợp với duyệt DFS của cây không gian trạng thái đang được sử dụng.
+một giải pháp ít chi phí nhân cho bài toán, để loại bỏ các giải pháp từng phần với chi phí lớn hơn giải pháp chi phí thấp nhất được tìm thấy cho đến nay.
+Thông thường BFS duyệt kết hợp với duyệt DFS của cây không gian trạng thái đang được sử dụng.
## Hướng dẫn sử dụng repository
@@ -238,7 +239,7 @@ npm install
**Chạy ESLint**
-Bạn có thể muốn chạy nó để kiểm tra chất lượng code.
+Bạn có thể muốn chạy nó để kiểm tra chất lượng code.
```
npm run lint
@@ -259,7 +260,7 @@ npm test -- 'LinkedList'
Bạn có thể chơi với các cấu trúc dữ liệu và thuật toán trong tệp `./src/playground/playground.js`
và viết các bài kiểm thử cho nó ở `./src/playground/__test__/playground.test.js`.
-Sau đó, chỉ cần chạy lệnh sau để kiểm tra xem sân chơi của bạn có hoạt động như mong đợi hay không:
+Sau đó, chỉ cần chạy lệnh sau để kiểm tra xem sân chơi của bạn có hoạt động như mong đợi hay không:
```
npm test -- 'playground'
@@ -274,7 +275,7 @@ npm test -- 'playground'
### Kí hiệu O lớn
*Kí hiệu O lớn* được dùng để phân loại thuật toán theo thời gian chạy hoặc yêu cầu không gian gia tăng khi kích thước đầu vào gia tăng.
-Trên biểu đồ bên dưới, bạn có thể tìm thấy hầu hết các thứ tự tăng trưởng phổ biến của các thuật toán được chỉ định trong ký hiệu O lớn.
+Trên biểu đồ bên dưới, bạn có thể tìm thấy hầu hết các thứ tự tăng trưởng phổ biến của các thuật toán được chỉ định trong ký hiệu O lớn.
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 27982c6553..59b3488142 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -25,6 +25,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
*注意：这个项目仅用于学习和研究，**不是**用于生产环境。*
diff --git a/README.zh-TW.md b/README.zh-TW.md
index aeb0547d2e..2bfd9134b7 100644
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -24,6 +24,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
+[_עברית_](README.he-HE.md)
## 資料結構
From c5dd0483bfd873e5f53c6d08f12f0b129caef339 Mon Sep 17 00:00:00 2001
From: trekhleb <3000285+trekhleb@users.noreply.github.com>
Date: Wed, 12 Feb 2025 17:17:52 +0100
Subject: [PATCH 21/22] Fix language code
---
README.ar-AR.md | 2 +-
README.de-DE.md | 2 +-
README.es-ES.md | 2 +-
README.fr-FR.md | 2 +-
README.he-HE.md => README.he-IL.md | 0
README.id-ID.md | 2 +-
README.it-IT.md | 2 +-
README.ja-JP.md | 2 +-
README.ko-KR.md | 2 +-
README.md | 2 +-
README.pl-PL.md | 2 +-
README.pt-BR.md | 2 +-
README.ru-RU.md | 2 +-
README.tr-TR.md | 2 +-
README.uk-UA.md | 2 +-
README.uz-UZ.md | 2 +-
README.vi-VN.md | 2 +-
README.zh-CN.md | 2 +-
README.zh-TW.md | 2 +-
19 files changed, 18 insertions(+), 18 deletions(-)
rename README.he-HE.md => README.he-IL.md (100%)
diff --git a/README.ar-AR.md b/README.ar-AR.md
index 39997e24a5..2ff0baddbd 100644
--- a/README.ar-AR.md
+++ b/README.ar-AR.md
@@ -25,7 +25,7 @@ _اقرأ هذا في لغات أخرى:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
☝ ملاحضة هذا المشروع مخصص للاستخدام لأغراض التعلم والبحث
فقط ، و ** ليست ** معدة للاستخدام في **الإنتاج**
diff --git a/README.de-DE.md b/README.de-DE.md
index e8f1b4b22b..019e7d6b39 100644
--- a/README.de-DE.md
+++ b/README.de-DE.md
@@ -26,7 +26,7 @@ _Lies dies in anderen Sprachen:_
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
_☝ Beachte, dass dieses Projekt nur für Lern- und Forschungszwecke gedacht ist und **nicht** für den produktiven Einsatz verwendet werden soll_
diff --git a/README.es-ES.md b/README.es-ES.md
index de4d6889f8..3a15ada4bd 100644
--- a/README.es-ES.md
+++ b/README.es-ES.md
@@ -27,7 +27,7 @@ _Léelo en otros idiomas:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Nótese que este proyecto está pensado con fines de aprendizaje e investigación,
y **no** para ser usado en producción.*
diff --git a/README.fr-FR.md b/README.fr-FR.md
index d24d5db915..cb30d1833d 100644
--- a/README.fr-FR.md
+++ b/README.fr-FR.md
@@ -28,7 +28,7 @@ _Lisez ceci dans d'autres langues:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## Data Structures
diff --git a/README.he-HE.md b/README.he-IL.md
similarity index 100%
rename from README.he-HE.md
rename to README.he-IL.md
diff --git a/README.id-ID.md b/README.id-ID.md
index 527abb45f2..9dd908c2e6 100644
--- a/README.id-ID.md
+++ b/README.id-ID.md
@@ -25,7 +25,7 @@ _Baca ini dalam bahasa yang lain:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
_☝ Perhatikan bahwa proyek ini hanya dimaksudkan untuk tujuan pembelajaran dan riset, dan **tidak** dimaksudkan untuk digunakan sebagai produksi._
diff --git a/README.it-IT.md b/README.it-IT.md
index 63007d80d9..d749a6aa7f 100644
--- a/README.it-IT.md
+++ b/README.it-IT.md
@@ -24,7 +24,7 @@ _Leggilo in altre lingue:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Si noti che questo progetto è destinato ad essere utilizzato solo per l'apprendimento e la ricerca e non è destinato ad essere utilizzato per il commercio.*
diff --git a/README.ja-JP.md b/README.ja-JP.md
index fc584780c2..acf9dee8f0 100644
--- a/README.ja-JP.md
+++ b/README.ja-JP.md
@@ -27,7 +27,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## データ構造
diff --git a/README.ko-KR.md b/README.ko-KR.md
index 20b6080eda..d4b0d4ef14 100644
--- a/README.ko-KR.md
+++ b/README.ko-KR.md
@@ -26,7 +26,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## 자료 구조
diff --git a/README.md b/README.md
index 3201136c03..6a98a76fb0 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md),
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Note that this project is meant to be used for learning and researching purposes
only, and it is **not** meant to be used for production.*
diff --git a/README.pl-PL.md b/README.pl-PL.md
index f95cfaeb99..56617030ab 100644
--- a/README.pl-PL.md
+++ b/README.pl-PL.md
@@ -28,7 +28,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## Struktury Danych
diff --git a/README.pt-BR.md b/README.pt-BR.md
index b451e5da5e..5b16798bc9 100644
--- a/README.pt-BR.md
+++ b/README.pt-BR.md
@@ -28,7 +28,7 @@ _Leia isto em outros idiomas:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## Estrutura de Dados
diff --git a/README.ru-RU.md b/README.ru-RU.md
index a14171f260..939ed46700 100644
--- a/README.ru-RU.md
+++ b/README.ru-RU.md
@@ -25,7 +25,7 @@ _Читать на других языках:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Замечание: этот репозиторий предназначен для учебно-исследовательских целей (**не** для использования в продакшн-системах).*
diff --git a/README.tr-TR.md b/README.tr-TR.md
index 2075132bda..53600480db 100644
--- a/README.tr-TR.md
+++ b/README.tr-TR.md
@@ -25,7 +25,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Not, bu proje araştırma ve öğrenme amacı ile yapılmış
olup üretim için **yapılmamıştır**.*
diff --git a/README.uk-UA.md b/README.uk-UA.md
index c636d21b09..5ee5f7cbcc 100644
--- a/README.uk-UA.md
+++ b/README.uk-UA.md
@@ -25,7 +25,7 @@ _Вивчення матеріалу на інших мовах:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Зверніть увагу! Даний проект призначений лише для навчальних та дослідницьких цілей, і він **не** призначений для виробництва (продакшн).*
diff --git a/README.uz-UZ.md b/README.uz-UZ.md
index 32a8b509bd..114a4de9cc 100644
--- a/README.uz-UZ.md
+++ b/README.uz-UZ.md
@@ -29,7 +29,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
Yodda tuting, bu loyiha faqat o'quv va tadqiqot maqsadida ishlatilishi
uchun mo'ljallangan va ishlab chiqarishda ishlatilishi **mumkin emas**.
diff --git a/README.vi-VN.md b/README.vi-VN.md
index 6fd4deaaa4..4c35f467f8 100644
--- a/README.vi-VN.md
+++ b/README.vi-VN.md
@@ -25,7 +25,7 @@ _Đọc bằng ngôn ngữ khác:_
[_Bahasa Indonesia_](README.id-ID.md),
[_Українська_](README.uk-UA.md),
[_Arabic_](README.ar-AR.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*☝ Dự án này chỉ được sử dụng cho mục đích học tập và nghiên cứu, **không** được dùng
cho mục đích thương mại.*
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 59b3488142..14e0f0e36c 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -25,7 +25,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
*注意：这个项目仅用于学习和研究，**不是**用于生产环境。*
diff --git a/README.zh-TW.md b/README.zh-TW.md
index 2bfd9134b7..aa48b40bd8 100644
--- a/README.zh-TW.md
+++ b/README.zh-TW.md
@@ -24,7 +24,7 @@ _Read this in other languages:_
[_Tiếng Việt_](README.vi-VN.md),
[_Deutsch_](README.de-DE.md),
[_Uzbek_](README.uz-UZ.md)
-[_עברית_](README.he-HE.md)
+[_עברית_](README.he-IL.md)
## 資料結構
From e40a67b5d1aaf006622a90e2bda60043f4f66679 Mon Sep 17 00:00:00 2001
From: trekhleb <3000285+trekhleb@users.noreply.github.com>
Date: Wed, 12 Feb 2025 17:19:46 +0100
Subject: [PATCH 22/22] Move "valid parentheses" to the "Uncategorized" section
---
README.md | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/README.md b/README.md
index 6a98a76fb0..3e5c5cc096 100644
--- a/README.md
+++ b/README.md
@@ -144,8 +144,6 @@ a set of rules that precisely define a sequence of operations.
* **Linked Lists**
* `B` [Straight Traversal](src/algorithms/linked-list/traversal)
* `B` [Reverse Traversal](src/algorithms/linked-list/reverse-traversal)
-* **Stack**
- * `B` [Valid Parentheses](src/algorithms/stack/valid-parentheses) - check if a string has valid parentheses in the correct order
* **Trees**
* `B` [Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
* `B` [Breadth-First Search](src/algorithms/tree/breadth-first-search) (BFS)
@@ -188,6 +186,7 @@ a set of rules that precisely define a sequence of operations.
* `B` [Rain Terraces](src/algorithms/uncategorized/rain-terraces) - trapping rain water problem (dynamic programming and brute force versions)
* `B` [Recursive Staircase](src/algorithms/uncategorized/recursive-staircase) - count the number of ways to reach to the top (4 solutions)
* `B` [Best Time To Buy Sell Stocks](src/algorithms/uncategorized/best-time-to-buy-sell-stocks) - divide and conquer and one-pass examples
+ * `B` [Valid Parentheses](src/algorithms/stack/valid-parentheses) - check if a string has valid parentheses (using stack)
* `A` [N-Queens Problem](src/algorithms/uncategorized/n-queens)
* `A` [Knight's Tour](src/algorithms/uncategorized/knight-tour)