- implement Abstract GenericSort class

Author: Isaac Ramirez

src/abstracts/generic-sort/generic-sort.js

@@ -0,0 +1,75 @@
+const { StdOut } = require('../../libs')
+const { defaultComparator } = require('../../common')
+
+/**
+ * GenericSort
+ * @classdesc Abstract Class for Sorting Algorithms.
+ */
+class GenericSort {
+  /**
+   * Returns whether `a` is less than `b`
+   * based on a comparing function.
+   * @param {*} a Comparable object `a`
+   * @param {*} b Comparable object `b`
+   * @param {function} comparator A comparing function that
+   * returns -1 when `a` is less than `b`,
+   * returns 1 when `a` is greater than `b` or
+   * returns 0 when `a` is equal to `b`.
+   */
+  static less (a, b, comparator = defaultComparator) {
+    return comparator(a, b) < 0
+  }
+
+  /**
+   * Interchanges the values located in indexes `i` and `j`
+   * for the given `array`.
+   * @param {[*]} array Array of values.
+   * @param {number} i Index 1
+   * @param {number} j Index 2
+   */
+  static exchange (array, i, j) {
+    const temp = array[i]
+
+    array[i] = array[j]
+    array[j] = temp
+  }
+
+  /**
+   * Returns `true` if the provided array is sorted,
+   * `false` otherwise.
+   * @param {[*]} array Array of values
+   * @param {function} comparator A comparing function that
+   * returns -1 when `a` is less than `b`,
+   * returns 1 when `a` is greater than `b` or
+   * returns 0 when `a` is equal to `b`.
+   */
+  static isSorted (array, comparator = defaultComparator) {
+    for (let i = 1; i < array.length; i++) {
+      if (this.less(array[i], array[i - 1], comparator)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * A function that prints to the StdOut
+   * the contents of the `array` provided.
+   * @param {[*]} array Array of values.
+   */
+  static show (array) {
+    StdOut.println(array.join(' '))
+  }
+
+  /**
+   * Should sorts the `array` using the Sorting algorithm of your choice.
+   * @abstract
+   * @throws SyntaxError This function should be implemented by the client.
+   */
+  static sort () {
+    throw new SyntaxError('sort method not implemented')
+  }
+}
+
+module.exports = GenericSort

src/abstracts/generic-sort/generic-sort.spec.js

@@ -0,0 +1,102 @@
+const GenericSort = require('./generic-sort')
+const { newArrayOf } = require('../../utils')
+const { defaultComparator: comparator } = require('../../common')
+
+describe('Unit Tests: GenericSort Abstract Class', () => {
+  beforeEach(() => {
+    this.orderedArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    this.reversedArray = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+    this.unorderedArray = [0, 9, 5, 2, 1, 8, 7, 6, 4, 3]
+    this.allEqualArray = [9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
+  })
+
+  describe('static less method', () => {
+    it('should return true if a is less than b', () => {
+      const a = 1
+      const b = 2
+
+      expect(GenericSort.less(a, b, comparator)).toBe(true)
+    })
+
+    it('should return false if a is greater than b', () => {
+      const a = 2
+      const b = 1
+
+      expect(GenericSort.less(a, b, comparator)).toBe(false)
+    })
+
+    it('should return false if a is equal to b', () => {
+      const a = 1
+      const b = 1
+
+      expect(GenericSort.less(a, b, comparator)).toBe(false)
+    })
+
+    it('should have a defaultComparator function', () => {
+      expect(GenericSort.less(1, 10)).toBe(true)
+      expect(GenericSort.less(1, 1)).toBe(false)
+      expect(GenericSort.less(10, 1)).toBe(false)
+    })
+  })
+
+  describe('static exchange method', () => {
+    it('should interchange the values of the two given indexes in the array', () => {
+      const array = [5, 6, 7]
+      const expectedArray = [7, 6, 5]
+
+      GenericSort.exchange(array, 0, 2)
+
+      expect(array).toEqual(expectedArray)
+    })
+  })
+
+  describe('static isSorted method', () => {
+    it('should return true if an array is sorted', () => {
+      expect(GenericSort.isSorted(this.orderedArray)).toBe(true)
+      expect(GenericSort.isSorted(this.allEqualArray)).toBe(true)
+    })
+
+    it('should return false if the array is not sorted', () => {
+      expect(GenericSort.isSorted(this.unorderedArray)).toBe(false)
+      expect(GenericSort.isSorted(this.reversedArray)).toBe(false)
+    })
+
+    it('should accept a comparator function', () => {
+      const orderedArray = ['A', 'B', 'C']
+      const unorderedArray = ['Z', 'X', 'Y']
+
+      expect(GenericSort.isSorted(orderedArray, comparator)).toBe(true)
+      expect(GenericSort.isSorted(unorderedArray, comparator)).toBe(false)
+    })
+
+    it('should return true for a sorted big array', () => {
+      const n = 1000000 // a million!
+      const array = newArrayOf(n, i => i) // from 0 to 999999
+
+      expect(GenericSort.isSorted(array)).toBeTrue()
+    })
+
+    it('should return false for a random big array', () => {
+      const n = 1000000 // a million!
+      const array = newArrayOf(n, i => i) // from 0 to 999999
+      array[array.length - 1] = 0 // change last number to be 0
+
+      expect(GenericSort.isSorted(array)).toBeFalse()
+    })
+  })
+
+  describe('static show method', () => {
+    it('should be a function', () => {
+      // I could test the call to StdOut, but I don't want to.
+      expect(GenericSort.show).toBeInstanceOf(Function)
+    })
+  })
+
+  describe('static sort method', () => {
+    it('should throw because is not implemented', () => {
+      expect(() => {
+        GenericSort.sort()
+      }).toThrowError('sort method not implemented')
+    })
+  })
+})

src/abstracts/index.js

@@ -1,5 +1,6 @@
 module.exports = {
   ArrayIterator: require('./array-iterator/array-iterator'),
+  GenericSort: require('./generic-sort/generic-sort'),
   Iterator: require('./iterator/iterator'),
   ReversedArrayIterator: require('./reversed-array-iterator/reversed-array-iterator')
 }