Added nth root of number

README.md

@@ -58,6 +58,7 @@ a set of rules that precisely define a sequence of operations.
 * **Math**
   * `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` [nth Root](src/algorithms/math/nth-root)
   * `B` [Fibonacci Number](src/algorithms/math/fibonacci)
   * `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)

src/algorithms/math/nth-root/README.MD

@@ -0,0 +1,8 @@
+# Nth Power using Binary Search
+
+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 range or sorted array. Binary search compares the target value to the middle element of the range or array. If they are not equal, the half in which the target cannot lie is eliminated and the search continues on the remaining half, again taking the middle element to compare to the target value, and repeating this until the target value is found. If the search ends with the remaining half being empty, the target is not in the array. Even though the idea is simple, implementing binary search correctly requires attention to some subtleties about its exit conditions and midpoint calculation.
+
+![Nth Root](https://upload.wikimedia.org/wikipedia/commons/8/83/Binary_Search_Depiction.svg)
+
+## References
+[Wikipedia](https://en.wikipedia.org/wiki/Binary_search_algorithm)

src/algorithms/math/nth-root/__test__/nthRoot.test.js

@@ -0,0 +1,12 @@
+import nthRoot from '../nthRoot';
+
+describe('nth Root', () => {
+  it('should nth root of number', () => {
+    expect(nthRoot(2, 2)).toBeCloseTo(1.414213562373095);
+    expect(nthRoot(2, 3)).toBeCloseTo(1.259921049894873);
+    expect(nthRoot(2, 4)).toBeCloseTo(1.259921049894873);
+    expect(nthRoot(2, 5)).toBeCloseTo(1.148698354997035);
+    expect(nthRoot(2, 6)).toBeCloseTo(1.122462048309373);
+    expect(nthRoot(2, 7)).toBeCloseTo(1.104089513673812);
+  });
+});

src/algorithms/math/nth-root/nthRoot.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number} number
+ * @param {number} power
+ * @return {number}
+ */
+
+function difference(num, mid, p) {
+  return Math.abs(num - (mid ** p));
+}
+
+export default function nthRoot(number, p) {
+  let start = 0.0;
+  let end = number;
+  const e = 0.000000001;
+  while (true) {
+    const mid = (start + end) / 2;
+    const error = difference(number, mid, p);
+    if (error <= e) return mid;
+    if (mid ** p > number) end = mid;
+    else start = mid;
+  }
+}