Merge branch 'master' into master

src/algorithms/search/binary-search/binarySearch.js

@@ -22,7 +22,7 @@ export default function binarySearch(sortedArray, seekElement, comparatorCallbac
     }
 
     // Decide which half to choose for seeking next: left or right one.
-    if (comparator.lessThen(sortedArray[middleIndex], seekElement)) {
+    if (comparator.lessThan(sortedArray[middleIndex], seekElement)) {
       // Go to the right half of the array.
       startIndex = middleIndex + 1;
     } else {

src/algorithms/sorting/bubble-sort/BubbleSort.js

@@ -18,7 +18,7 @@ export default class BubbleSort extends Sort {
         this.callbacks.visitingCallback(array[j]);
 
         // Swap elements if they are in wrong order.
-        if (this.comparator.lessThen(array[j + 1], array[j])) {
+        if (this.comparator.lessThan(array[j + 1], array[j])) {
           const tmp = array[j + 1];
           array[j + 1] = array[j];
           array[j] = tmp;

src/algorithms/sorting/insertion-sort/InsertionSort.js

@@ -15,7 +15,7 @@ export default class InsertionSort extends Sort {
       // If this is the case then swap that elements.
       while (
         array[currentIndex - 1] &&
-        this.comparator.lessThen(array[currentIndex], array[currentIndex - 1])
+        this.comparator.lessThan(array[currentIndex], array[currentIndex - 1])
       ) {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[currentIndex - 1]);

src/algorithms/sorting/merge-sort/MergeSort.js

@@ -31,7 +31,7 @@ export default class MergeSort extends Sort {
       let minimumElement = null;
 
       // Find minimum element of two arrays.
-      if (this.comparator.lessThenOrEqual(leftArray[0], rightArray[0])) {
+      if (this.comparator.lessThanOrEqual(leftArray[0], rightArray[0])) {
         minimumElement = leftArray.shift();
       } else {
         minimumElement = rightArray.shift();

src/algorithms/sorting/quick-sort/QuickSort.js

@@ -27,7 +27,7 @@ export default class QuickSort extends Sort {
 
       if (this.comparator.equal(currentElement, pivotElement)) {
         centerArray.push(currentElement);
-      } else if (this.comparator.lessThen(currentElement, pivotElement)) {
+      } else if (this.comparator.lessThan(currentElement, pivotElement)) {
         leftArray.push(currentElement);
       } else {
         rightArray.push(currentElement);

src/algorithms/sorting/selection-sort/SelectionSort.js

@@ -16,7 +16,7 @@ export default class SelectionSort extends Sort {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[j]);
 
-        if (this.comparator.lessThen(array[j], array[minIndex])) {
+        if (this.comparator.lessThan(array[j], array[minIndex])) {
           minIndex = j;
         }
       }

src/algorithms/sorting/shell-sort/ShellSort.js

@@ -20,7 +20,7 @@ export default class ShellSort extends Sort {
           this.callbacks.visitingCallback(array[currentIndex]);
 
           // Compare and swap array elements if needed.
-          if (this.comparator.lessThen(array[gapShiftedIndex], array[currentIndex])) {
+          if (this.comparator.lessThan(array[gapShiftedIndex], array[currentIndex])) {
             const tmp = array[currentIndex];
             array[currentIndex] = array[gapShiftedIndex];
             array[gapShiftedIndex] = tmp;

src/algorithms/uncategorized/knight-tour/knightTour.js

@@ -4,7 +4,7 @@
  * @return {number[][]}
  */
 function getPossibleMoves(chessboard, position) {
-  // Generate all knight moves (event those that goes beyond the board).
+  // Generate all knight moves (even those that go beyond the board).
   const possibleMoves = [
     [position[0] - 1, position[1] - 2],
     [position[0] - 2, position[1] - 1],