fixes:

- trim incoming data
- add strategy choice
- count invocations in quicksort

tasks/amashoshyna/week2/index.js

@@ -1,12 +1,28 @@
 const quickSort = require('./quicksort')
 const fs = require('fs')
-const data = fs.readFileSync('./QuickSort.txt', 'utf8').split('\r\n').map(num => +num)
-quickSort('alwaysFirst')(data)
-let result = data.every((val, index) => {
-    if(index > 0) {
-        return (val - data[index-1]) >0
-    }
-    return true
-})
-
-console.log('Result is correct: ', result)
+const data = fs.readFileSync('./QuickSort.txt', 'utf8')
+    .trim()
+    .split('\r\n')
+    .map(num => +num)
+
+let availableStrategies = [
+    'alwaysFirst',
+    'alwaysLast',
+    'random'
+]
+// TODO: choose strategy from array "availableStrategies"
+let strategy = availableStrategies[0]
+let numberOfComparisons = quickSort(strategy)(data)
+
+console.log(`Number of comparisons for strategy "${strategy}": ${numberOfComparisons}`)
+
+function checkResult(data) {
+    return data.every((val, index) => {
+        if(index > 0) {
+            return (val - data[index-1]) > 0
+        }
+        return true
+    })
+}
+
+console.log('Result is correct: ', checkResult(data))

tasks/amashoshyna/week2/quicksort.js

@@ -1,25 +1,21 @@
 let m = 0
-function choosePivot(arr, limits) {
-	if(limits) {
-		return Math.floor(
-			Math.random() * (limits[1] - limits[0])+ limits[0]
-		) 
-	} 
-	return Math.floor(Math.random()*arr.length)
-}
+let strategy = null
 
 const pivotChoiceStrategies = {
-    random: (arr, limits) => {
-        if(limits) {
-            return Math.floor(
-                Math.random() * (limits[1] - limits[0])+ limits[0]
-            )
-        }
-        return Math.floor(Math.random()*arr.length)
-    },
-    alwaysFirst: (arr, limits) => {
-        return limits[0]
-    }
+	random: (arr, limits) => {
+		if(limits) {
+			return Math.floor(
+				Math.random() * (limits[1] - limits[0])+ limits[0]
+			)
+		}
+		return Math.floor(Math.random()*arr.length)
+	},
+	alwaysFirst: (arr, limits) => {
+		return limits[0]
+	},
+	alwaysLast: (arr, limits) => {
+		return limits[1]
+	}
 }
 function swapByIndex(arr, a, b) {
 	let tempA = arr[a]
@@ -29,8 +25,8 @@ function swapByIndex(arr, a, b) {
 }
 
 function partition(arr, boundaries) {
-    let initialPivotIndex = pivotChoiceStrategies.alwaysFirst(arr, boundaries)
-    let [leftBoundary, rightBoundary] = boundaries
+	let initialPivotIndex = pivotChoiceStrategies[strategy](arr, boundaries)
+	let [leftBoundary, rightBoundary] = boundaries
 	if(initialPivotIndex !== leftBoundary) {
 		swapByIndex(arr, leftBoundary, initialPivotIndex)
 	}
@@ -42,37 +38,39 @@ function partition(arr, boundaries) {
 			swapByIndex(arr, j, i)
 			i++
 		} 
-    }
-    let finalPivotIndex = i - 1
+	}
+	let finalPivotIndex = i - 1
 	swapByIndex(arr, finalPivotIndex, leftBoundary)
 	return finalPivotIndex
 }
 
 function quickSort(arr, boundariesGiven) {
 	let boundaries = boundariesGiven || [0, arr.length - 1]
+	let addedComparisons = (boundaries[1] - boundaries[0])
+	m = m + addedComparisons
 	let positionedElementIndex = partition(arr, boundaries)
 	let n = boundaries[1] - boundaries[0]
 	if(n > 1) {
 		let leftPartLimits = [boundaries[0], positionedElementIndex - 1]
 		let rightPartLimits = [positionedElementIndex + 1, boundaries[1]]
 		if (positionedElementIndex - 1 >= 0
             && (leftPartLimits[1] - leftPartLimits[0]) > 0) {
-                quickSort(arr, leftPartLimits)
-                m = m + (leftPartLimits[1] - leftPartLimits[0] - 1)
-            }
-        if (positionedElementIndex + 1 <= boundaries[1]
+			quickSort(arr, leftPartLimits)
+		} 
+		if (positionedElementIndex + 1 <= boundaries[1]
             && (rightPartLimits[1] - rightPartLimits[0]) > 0) {
-                quickSort(arr, rightPartLimits)
-                m = m + (rightPartLimits[1] - rightPartLimits[0]-1)
-            }
-    }
-    console.log(m)
+			quickSort(arr, rightPartLimits)
+		} 
+	} 
+	return m
 }
 
-function quickSortByStrategy (strategy) {
-    // let strategy = strategy
-    let choosePivot = pivotChoiceStrategies[strategy]
-    return quickSort.bind(this)
+function quickSortByStrategy (strategyChosen) {
+	if(strategyChosen) {
+		strategy = strategyChosen
+		return quickSort
+	}
+	throw new Error('Strategy cannot be null')
 }
 
 module.exports = quickSortByStrategy