Merge branch 'master' of https://github.com/trekhleb/javascript-algorithms

Author: dilane3

README.md

@@ -66,6 +66,7 @@ a set of rules that precisely define a sequence of operations.
   * `B` [Bit Manipulation](src/algorithms/math/bits) - set/get/update/clear bits, multiplication/division by two, make negative etc.
   * `B` [Factorial](src/algorithms/math/factorial) 
   * `B` [Fibonacci Number](src/algorithms/math/fibonacci) - classic and closed-form versions
+  * `B` [Prime Factors](src/algorithms/math/prime-factors) - finding prime factors and counting them using Hardy-Ramanujan's theorem  
   * `B` [Primality Test](src/algorithms/math/primality-test) (trial division method)
   * `B` [Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
   * `B` [Least Common Multiple](src/algorithms/math/least-common-multiple) (LCM)

README.zh-CN.md

@@ -228,7 +228,7 @@ npm test -- 'LinkedList'
 
 你可以在 `./src/playground/playground.js` 文件中操作数据结构与算法，并在 `./src/playground/__test__/playground.test.js` 中编写测试。
 
-然后，只需运行以下命令来测试你的 Playground 是否按无误:
+然后，只需运行以下命令来测试你的 Playground 是否无误:
 
 ```
 npm test -- 'playground'

src/algorithms/math/prime-factors/README.md

@@ -0,0 +1,34 @@
+# Prime Factors
+
+**Prime number** is a whole number greater than `1` that **cannot** be made by multiplying other whole numbers. The first few prime numbers are: `2`, `3`, `5`, `7`, `11`, `13`, `17`, `19` and so on.
+
+If we **can** make it by multiplying other whole numbers it is a **Composite Number**.
+
+![Composite numbers](https://www.mathsisfun.com/numbers/images/prime-composite.svg)
+
+_Image source: [Math is Fun](https://www.mathsisfun.com/prime-factorization.html)_
+
+**Prime factors** are those [prime numbers](https://en.wikipedia.org/wiki/Prime_number) which multiply together to give the original number. For example `39` will have prime factors of `3` and `13` which are also prime numbers. Another example is `15` whose prime factors are `3` and `5`.
+
+![Factors](https://www.mathsisfun.com/numbers/images/factor-2x3.svg)
+
+_Image source: [Math is Fun](https://www.mathsisfun.com/prime-factorization.html)_
+
+## Finding the prime factors and their count accurately
+
+The approach is to keep on dividing the natural number `n` by indexes from `i = 2` to `i = n` (by prime indexes only). The value of `n` is being overridden by `(n / i)` on each iteration.
+
+The time complexity till now is `O(n)` in the worst case scenario since the loop runs from index `i = 2` to `i = n`. This time complexity can be reduced from `O(n)` to `O(sqrt(n))`. The optimisation is achievable when loop runs from `i = 2` to `i = sqrt(n)`. Now, we go only till `O(sqrt(n))` because when `i` becomes greater than `sqrt(n)`, we have the confirmation that there is no index `i` left which can divide `n` completely other than `n` itself.
+
+## Hardy-Ramanujan formula for approximate calculation of prime-factor count
+
+In 1917, a theorem was formulated by G.H Hardy and Srinivasa Ramanujan which states that the normal order of the number `ω(n)` of distinct prime factors of a number `n` is `log(log(n))`.
+
+Roughly speaking, this means that most numbers have about this number of distinct prime factors.
+
+## References
+
+- [Prime numbers on Math is Fun](https://www.mathsisfun.com/prime-factorization.html)
+- [Prime numbers on Wikipedia](https://en.wikipedia.org/wiki/Prime_number)
+- [Hardy–Ramanujan theorem on Wikipedia](https://en.wikipedia.org/wiki/Hardy%E2%80%93Ramanujan_theorem)
+- [Prime factorization of a number on Youtube](https://www.youtube.com/watch?v=6PDtgHhpCHo&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=82)

src/algorithms/math/prime-factors/__test__/primeFactors.test.js

@@ -0,0 +1,87 @@
+import {
+  primeFactors,
+  hardyRamanujan,
+} from '../primeFactors';
+
+/**
+ * Calculates the error between exact and approximate prime factor counts.
+ * @param {number} exactCount
+ * @param {number} approximateCount
+ * @returns {number} - approximation error (percentage).
+ */
+function approximationError(exactCount, approximateCount) {
+  return (Math.abs((exactCount - approximateCount) / exactCount) * 100);
+}
+
+describe('primeFactors', () => {
+  it('should find prime factors', () => {
+    expect(primeFactors(1)).toEqual([]);
+    expect(primeFactors(2)).toEqual([2]);
+    expect(primeFactors(3)).toEqual([3]);
+    expect(primeFactors(4)).toEqual([2, 2]);
+    expect(primeFactors(14)).toEqual([2, 7]);
+    expect(primeFactors(40)).toEqual([2, 2, 2, 5]);
+    expect(primeFactors(54)).toEqual([2, 3, 3, 3]);
+    expect(primeFactors(100)).toEqual([2, 2, 5, 5]);
+    expect(primeFactors(156)).toEqual([2, 2, 3, 13]);
+    expect(primeFactors(273)).toEqual([3, 7, 13]);
+    expect(primeFactors(300)).toEqual([2, 2, 3, 5, 5]);
+    expect(primeFactors(980)).toEqual([2, 2, 5, 7, 7]);
+    expect(primeFactors(1000)).toEqual([2, 2, 2, 5, 5, 5]);
+    expect(primeFactors(52734)).toEqual([2, 3, 11, 17, 47]);
+    expect(primeFactors(343434)).toEqual([2, 3, 7, 13, 17, 37]);
+    expect(primeFactors(456745)).toEqual([5, 167, 547]);
+    expect(primeFactors(510510)).toEqual([2, 3, 5, 7, 11, 13, 17]);
+    expect(primeFactors(8735463)).toEqual([3, 3, 11, 88237]);
+    expect(primeFactors(873452453)).toEqual([149, 1637, 3581]);
+  });
+
+  it('should give approximate prime factors count using Hardy-Ramanujan theorem', () => {
+    expect(hardyRamanujan(2)).toBeCloseTo(-0.366, 2);
+    expect(hardyRamanujan(4)).toBeCloseTo(0.326, 2);
+    expect(hardyRamanujan(40)).toBeCloseTo(1.305, 2);
+    expect(hardyRamanujan(156)).toBeCloseTo(1.6193, 2);
+    expect(hardyRamanujan(980)).toBeCloseTo(1.929, 2);
+    expect(hardyRamanujan(52734)).toBeCloseTo(2.386, 2);
+    expect(hardyRamanujan(343434)).toBeCloseTo(2.545, 2);
+    expect(hardyRamanujan(456745)).toBeCloseTo(2.567, 2);
+    expect(hardyRamanujan(510510)).toBeCloseTo(2.575, 2);
+    expect(hardyRamanujan(8735463)).toBeCloseTo(2.771, 2);
+    expect(hardyRamanujan(873452453)).toBeCloseTo(3.024, 2);
+  });
+
+  it('should give correct deviation between exact and approx counts', () => {
+    expect(approximationError(primeFactors(2).length, hardyRamanujan(2)))
+      .toBeCloseTo(136.651, 2);
+
+    expect(approximationError(primeFactors(4).length, hardyRamanujan(2)))
+      .toBeCloseTo(118.325, 2);
+
+    expect(approximationError(primeFactors(40).length, hardyRamanujan(2)))
+      .toBeCloseTo(109.162, 2);
+
+    expect(approximationError(primeFactors(156).length, hardyRamanujan(2)))
+      .toBeCloseTo(109.162, 2);
+
+    expect(approximationError(primeFactors(980).length, hardyRamanujan(2)))
+      .toBeCloseTo(107.330, 2);
+
+    expect(approximationError(primeFactors(52734).length, hardyRamanujan(52734)))
+      .toBeCloseTo(52.274, 2);
+
+    expect(approximationError(primeFactors(343434).length, hardyRamanujan(343434)))
+      .toBeCloseTo(57.578, 2);
+
+    expect(approximationError(primeFactors(456745).length, hardyRamanujan(456745)))
+      .toBeCloseTo(14.420, 2);
+
+    expect(approximationError(primeFactors(510510).length, hardyRamanujan(510510)))
+      .toBeCloseTo(63.201, 2);
+
+    expect(approximationError(primeFactors(8735463).length, hardyRamanujan(8735463)))
+      .toBeCloseTo(30.712, 2);
+
+    expect(approximationError(primeFactors(873452453).length, hardyRamanujan(873452453)))
+      .toBeCloseTo(0.823, 2);
+  });
+});

src/algorithms/math/prime-factors/primeFactors.js

@@ -0,0 +1,42 @@
+/**
+ * Finds prime factors of a number.
+ *
+ * @param {number} n - the number that is going to be split into prime factors.
+ * @returns {number[]} - array of prime factors.
+ */
+export function primeFactors(n) {
+  // Clone n to avoid function arguments override.
+  let nn = n;
+
+  // Array that stores the all the prime factors.
+  const factors = [];
+
+  // Running the loop till sqrt(n) instead of n to optimise time complexity from O(n) to O(sqrt(n)).
+  for (let factor = 2; factor <= Math.sqrt(nn); factor += 1) {
+    // Check that factor divides n without a reminder.
+    while (nn % factor === 0) {
+      // Overriding the value of n.
+      nn /= factor;
+      // Saving the factor.
+      factors.push(factor);
+    }
+  }
+
+  // The ultimate reminder should be a last prime factor,
+  // unless it is not 1 (since 1 is not a prime number).
+  if (nn !== 1) {
+    factors.push(nn);
+  }
+
+  return factors;
+}
+
+/**
+ * Hardy-Ramanujan approximation of prime factors count.
+ *
+ * @param {number} n
+ * @returns {number} - approximate number of prime factors.
+ */
+export function hardyRamanujan(n) {
+  return Math.log(Math.log(n));
+}

src/algorithms/uncategorized/rain-terraces/bfRainTerraces.js

@@ -25,7 +25,7 @@ export default function bfRainTerraces(terraces) {
     if (terraceBoundaryLevel > terraces[terraceIndex]) {
       // Terrace will be able to store the water if the lowest of two left and right highest
       // terraces are still higher than the current one.
-      waterAmount += Math.min(leftHighestLevel, rightHighestLevel) - terraces[terraceIndex];
+      waterAmount += terraceBoundaryLevel - terraces[terraceIndex];
     }
   }
 

src/data-structures/doubly-linked-list/README.ko-KR.md

@@ -0,0 +1,107 @@
+# Doubly Linked List
+
+_Read this in other languages:_
+[_Русский_](README.ru-RU.md),
+[_简体中文_](README.zh-CN.md),
+[_日本語_](README.ja-JP.md),
+[_Português_](README.pt-BR.md)
+
+컴퓨터공학에서 **이중 연결 리스트**는 순차적으로 링크된 노드라는 레코드 세트로 구성된 링크된 데이터 구조입니다.
+각 노드에는 링크라고 하는 두 개의 필드가 있으며, 노드 순서에서 이전 노드와 다음 노드에 대한 참조를 가집니다.
+시작 및 종료 노드의 이전 및 다음 링크는 각각 리스트의 순회를 용이하게 하기 위해서 일종의 종결자 (일반적으로 센티넬노드 또는 null)를 나타냅니다.
+센티넬 노드가 하나만 있으면, 목록이 센티넬 노드를 통해서 원형으로 연결됩니다.
+동일한 데이터 항목으로 구성되어 있지만, 반대 순서로 두 개의 단일 연결 리스트로 개념화 할 수 있습니다.
+
+![이중 연결 리스트](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg)
+
+두 개의 노드 링크를 사용하면 어느 방향으로든 리스트를 순회할 수 있습니다.
+이중 연결 리스트에서 노드를 추가하거나 제거하려면, 단일 연결 리스트에서 동일한 작업보다 더 많은 링크를 변경해야 하지만, 첫 번째 노드 이외의 노드인 경우 작업을 추적할 필요가 없으므로 작업이 더 단순해져 잠재적으로 더 효율적입니다.
+리스트 순회 중 이전 노드 또는 링크를 수정할 수 있도록 이전 노드를 찾기 위해 리스트를 순회할 필요가 없습니다.
+
+## 기본 동작을 위한 Pseudocode
+
+### 삽입
+
+```text
+Add(value)
+  Pre: value는 리스트에 추가하고자 하는 값
+  Post: value는 목록의 끝에 배치됨
+  n ← node(value)
+  if head = ø
+    head ← n
+    tail ← n
+  else
+    n.previous ← tail
+    tail.next ← n
+    tail ← n
+  end if
+end Add
+```
+    
+### 삭제
+
+```text
+Remove(head, value)
+  Pre: head는 리스트의 앞단에 위치
+       value는 리스트에서 제거하고자 하는 값
+  Post: value가 리스트에서 제거되면 true; 아니라면 false;
+  if head = ø
+    return false
+  end if
+  if value = head.value
+    if head = tail
+      head ← ø
+      tail ← ø
+    else
+      head ← head.next
+      head.previous ← ø
+    end if
+    return true
+  end if
+  n ← head.next
+  while n = ø and value !== n.value
+    n ← n.next
+  end while
+  if n = tail
+    tail ← tail.previous
+    tail.next ← ø
+    return true
+  else if n = ø
+    n.previous.next ← n.next
+    n.next.previous ← n.previous
+    return true
+  end if
+  return false
+end Remove
+```
+    
+### 역순회
+
+```text
+ReverseTraversal(tail)
+  Pre: tail은 리스트에서 순회하고자 하는 노드
+  Post: 리스트가 역순으로 순회됨
+  n ← tail
+  while n = ø
+    yield n.value
+    n ← n.previous
+  end while
+end Reverse Traversal
+```
+    
+## 복잡도
+
+## 시간 복잡도
+
+| Access    | Search    | Insertion | Deletion  |
+| :-------: | :-------: | :-------: | :-------: |
+| O(n)      | O(n)      | O(1)      | O(n)      |
+
+### 공간 복잡도
+
+O(n)
+
+## 참고
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Doubly_linked_list)
+- [YouTube](https://www.youtube.com/watch?v=JdQeNxWCguQ&t=7s&index=72&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/data-structures/doubly-linked-list/README.md

@@ -5,13 +5,14 @@ _Read this in other languages:_
 [_简体中文_](README.zh-CN.md),
 [_日本語_](README.ja-JP.md),
 [_Português_](README.pt-BR.md)
+[_한국어_](README.ko-KR.md)
 
 In computer science, a **doubly linked list** is a linked data structure that 
 consists of a set of sequentially linked records called nodes. Each node contains 
 two fields, called links, that are references to the previous and to the next 
 node in the sequence of nodes. The beginning and ending nodes' previous and next 
 links, respectively, point to some kind of terminator, typically a sentinel 
-node or null, to facilitate traversal of the list. If there is only one 
+node or null, to facilitate the traversal of the list. If there is only one 
 sentinel node, then the list is circularly linked via the sentinel node. It can 
 be conceptualized as two singly linked lists formed from the same data items, 
 but in opposite sequential orders.

src/data-structures/hash-table/HashTable.js

@@ -105,4 +105,17 @@ export default class HashTable {
   getKeys() {
     return Object.keys(this.keys);
   }
+
+  /**
+   * Gets the list of all the stored values in the hash table.
+   *
+   * @return {*[]}
+   */
+  getValues() {
+    return this.buckets.reduce((values, bucket) => {
+      const bucketValues = bucket.toArray()
+        .map((linkedListNode) => linkedListNode.value.value);
+      return values.concat(bucketValues);
+    }, []);
+  }
 }

src/data-structures/hash-table/__test__/HashTable.test.js

@@ -86,4 +86,32 @@ describe('HashTable', () => {
     expect(hashTable.has('b')).toBe(true);
     expect(hashTable.has('x')).toBe(false);
   });
+
+  it('should get all the values', () => {
+    const hashTable = new HashTable(3);
+
+    hashTable.set('a', 'alpha');
+    hashTable.set('b', 'beta');
+    hashTable.set('c', 'gamma');
+
+    expect(hashTable.getValues()).toEqual(['gamma', 'alpha', 'beta']);
+  });
+
+  it('should get all the values from empty hash table', () => {
+    const hashTable = new HashTable();
+    expect(hashTable.getValues()).toEqual([]);
+  });
+
+  it('should get all the values in case of hash collision', () => {
+    const hashTable = new HashTable(3);
+
+    // Keys `ab` and `ba` in current implementation should result in one hash (one bucket).
+    // We need to make sure that several items from one bucket will be serialized.
+    hashTable.set('ab', 'one');
+    hashTable.set('ba', 'two');
+
+    hashTable.set('ac', 'three');
+
+    expect(hashTable.getValues()).toEqual(['one', 'two', 'three']);
+  });
 });

src/data-structures/linked-list/README.ko-KR.md

@@ -0,0 +1,149 @@
+# 링크드 리스트
+
+_Read this in other languages:_
+[_简体中文_](README.zh-CN.md),
+[_Русский_](README.ru-RU.md),
+[_日本語_](README.ja-JP.md),
+[_Português_](README.pt-BR.md)
+
+컴퓨터과학에서, **링크드 리스트**는 데이터 요소의 선형 집합이며, 이 집합에서 논리적 저장 순서는 메모리의 물리적 저장 순서와 일치하지 않습니다. 그 대신, 각각의 원소들은 자기 자신 다음의 원소를 가리킵니다. **링크드 리스트**는 순서를 표현하는 노드들의 집합으로 이루어져 있습니다. 간단하게, 각각의 노드들은 데이터와 다음 순서의 노드를 가리키는 레퍼런스로 이루어져 있습니다. (링크라고 부릅니다.) 이 자료구조는 순회하는 동안 순서에 상관없이 효율적인 삽입이나 삭제가 가능합니다. 더 복잡한 변형은 추가적인 링크를 더해, 임의의 원소 참조로부터 효율적인 삽입과 삭제를 가능하게 합니다. 링크드 리스트의 단점은 접근 시간이 선형이라는 것이고, 병렬처리도 하지 못합니다. 임의 접근처럼 빠른 접근은 불가능합니다. 링크드 리스트에 비해 배열이 더 나은 캐시 지역성을 가지고 있습니다.
+
+![링크드 리스트](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+## 기본 연산에 대한 수도코드
+
+### 삽입
+
+```text
+Add(value)
+  Pre: 리스트에 추가할 값
+  Post: 리스트의 맨 마지막에 있는 값
+  n ← node(value)
+  if head = ø
+    head ← n
+    tail ← n
+  else
+    tail.next ← n
+    tail ← n
+  end if
+end Add
+```
+
+```text
+Prepend(value)
+ Pre: 리스트에 추가할 값
+ Post: 리스트의 맨 앞에 있는 값
+ n ← node(value)
+ n.next ← head
+ head ← n
+ if tail = ø
+   tail ← n
+ end
+end Prepend
+```
+
+### 탐색
+
+```text
+Contains(head, value)
+  Pre: head는 리스트에서 맨 앞 노드
+       value는 찾고자 하는 값
+  Post: 항목이 링크드 리스트에 있으면 true;
+        없으면 false
+  n ← head
+  while n != ø and n.value != value
+    n ← n.next
+  end while
+  if n = ø
+    return false
+  end if
+  return true
+end Contains
+```
+    
+### 삭제
+
+```text
+Remove(head, value)
+  Pre: head는 리스트에서 맨 앞 노드
+       value는 삭제하고자 하는 값
+  Post: 항목이 링크드 리스트에서 삭제되면 true;
+        없으면 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
+    end if
+    n.next ← n.next.next
+    return true
+  end if
+  return false
+end Remove
+```
+
+### 순회
+
+```text
+Traverse(head)
+  Pre: head는 리스트에서 맨 앞 노드
+  Post: 순회된 항목들
+  n ← head
+  while n != ø
+    yield n.value
+    n ← n.next
+  end while
+end Traverse
+```
+
+### 역순회
+
+```text
+ReverseTraversal(head, tail)
+  Pre: 같은 리스트에 들어 있는 맨 앞, 맨 뒤 노드
+  Post: 역순회된 항목들
+  if tail != ø
+    curr ← tail
+    while curr != head
+      prev ← head
+      while prev.next != curr
+        prev ← prev.next
+      end while
+      yield curr.value
+      curr ← prev
+    end while
+   yield curr.value
+  end if
+end ReverseTraversal
+```
+
+## 복잡도
+
+### 시간 복잡도
+
+|  접근   |  탐색   |  삽입   |  삭제   |
+| :---: | :---: | :---: | :---: |
+| O(n)  | O(n)  | O(1)  | O(1)  |
+
+### 공간 복잡도
+
+O(n)
+
+## 참조
+
+- [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)

src/data-structures/linked-list/README.md

@@ -4,7 +4,8 @@ _Read this in other languages:_
 [_简体中文_](README.zh-CN.md),
 [_Русский_](README.ru-RU.md),
 [_日本語_](README.ja-JP.md),
-[_Português_](README.pt-BR.md)
+[_Português_](README.pt-BR.md),
+[_한국어_](README.ko-KR.md)
 
 In computer science, a **linked list** is a linear collection 
 of data elements, in which linear order is not given by 

src/data-structures/trie/README.ru-RU.md

@@ -2,7 +2,7 @@
 
 **Префиксное дерево** (также бор, луч, нагруженное или суффиксное дерево) в информатике - упорядоченная древовидная
 структура данных, которая используется для хранения динамических множеств или ассоциативных массивов, где
-ключём обычно выступают строки. Дерево называется префиксным, потому что поиск осуществляется по префиксам.
+ключом обычно выступают строки. Дерево называется префиксным, потому что поиск осуществляется по префиксам.
 
 В отличие от бинарного дерева, узлы не содержат ключи, соответствующие узлу. Представляет собой корневое дерево, каждое
 ребро которого помечено каким-то символом так, что для любого узла все рёбра, соединяющие этот узел с его сыновьями,