fortune not found

Quick commit

9 files changed, 46 insertions, 46 deletions

diff --git a/sort/bottomupmerge.go b/sort/bottomupmerge.go
index 4891c04..c0ae4fd 100644
--- a/sort/bottomupmerge.go
+++ b/sort/bottomupmerge.go
@@ -5,12 +5,12 @@ import (
 )
 
 func BottomUpMerge(a ds.ArrayList) ds.ArrayList {
-	length := len(a)
-	aux := make(ds.ArrayList, length)
+	l := len(a)
+	aux := make(ds.ArrayList, l)
 
-	for sz := 1; sz < length; sz = sz + sz {
-		for lo := 0; lo < length-sz; lo += sz + sz {
-			merge(a, aux, lo, lo+sz, min(lo+sz+sz-1, length-1))
+	for sz := 1; sz < l; sz = sz + sz {
+		for lo := 0; lo < l-sz; lo += sz + sz {
+			merge(a, aux, lo, lo+sz, min(lo+sz+sz-1, l-1))
 		}
 	}
 
diff --git a/sort/merge.go b/sort/merge.go
index 1f48c3a..601c378 100644
--- a/sort/merge.go
+++ b/sort/merge.go
@@ -12,15 +12,15 @@ func Merge(a ds.ArrayList) ds.ArrayList {
 }
 
 func mergeSort(a, aux ds.ArrayList) {
-	length := len(a)
-	if length <= 1 {
+	l := len(a)
+	if l <= 1 {
 		return
 	}
 
-	mi := length / 2
+	mi := l / 2
 	mergeSort(a[0:mi], aux[0:mi])
 	mergeSort(a[mi:], aux[mi:])
-	merge(a, aux, 0, mi, length-1)
+	merge(a, aux, 0, mi, l-1)
 }
 
 func merge(a, aux ds.ArrayList, lo, mi, hi int) {
diff --git a/sort/parallelmerge.go b/sort/parallelmerge.go
index f9a59a3..87543f6 100644
--- a/sort/parallelmerge.go
+++ b/sort/parallelmerge.go
@@ -11,16 +11,16 @@ func ParallelMerge(a ds.ArrayList) ds.ArrayList {
 }
 
 func parallelMerge(a, aux ds.ArrayList) {
-	length := len(a)
-	if length <= 1 {
+	l := len(a)
+	if l <= 1 {
 		return
 	}
 
-	mi := length / 2
-	if length < 1000 {
+	mi := l / 2
+	if l < 1000 {
 		mergeSort(a[0:mi], aux[0:mi])
 		mergeSort(a[mi:], aux[mi:])
-		merge(a, aux, 0, mi, length-1)
+		merge(a, aux, 0, mi, l-1)
 		return
 	}
 
@@ -38,6 +38,6 @@ func parallelMerge(a, aux ds.ArrayList) {
 	}()
 
 	wg.Wait()
-	merge(a, aux, 0, mi, length-1)
+	merge(a, aux, 0, mi, l-1)
 	return
 }
diff --git a/sort/parallelquick.go b/sort/parallelquick.go
index 2ac9f0e..cde4b5e 100644
--- a/sort/parallelquick.go
+++ b/sort/parallelquick.go
@@ -12,15 +12,15 @@ func ParallelQuick(a ds.ArrayList) ds.ArrayList {
 }
 
 func parallelQuick(a ds.ArrayList) {
-	length := len(a)
-	if length <= 10 {
+	l := len(a)
+	if l <= 10 {
 		Insertion(a)
 		return
 	}
 
 	j := quickPartition(a)
 
-	if length >= 1000 {
+	if l >= 1000 {
 		var wg sync.WaitGroup
 		wg.Add(2)
 		defer wg.Wait()
diff --git a/sort/quick3way.go b/sort/quick3way.go
index 6e7dc18..5263432 100644
--- a/sort/quick3way.go
+++ b/sort/quick3way.go
@@ -12,15 +12,15 @@ func Quick3Way(a ds.ArrayList) ds.ArrayList {
 }
 
 func quick3Way(a ds.ArrayList) {
-	length := len(a)
-	if length <= 10 {
+	l := len(a)
+	if l <= 10 {
 		Insertion(a)
 		return
 	}
 
 	lt := 0          // Lower than
 	i := 1           // lt..i contain duplicates
-	gt := length - 1 // Greater than
+	gt := l - 1 // Greater than
 
 	Insertion(a[0:3])
 	a.Swap(0, 1)
diff --git a/sort/selection.go b/sort/selection.go
index 781292a..a28437c 100644
--- a/sort/selection.go
+++ b/sort/selection.go
@@ -5,11 +5,11 @@ import (
 )
 
 func Selection(a ds.ArrayList) ds.ArrayList {
-	length := len(a)
+	l := len(a)
 
-	for i := 0; i < length; i++ {
+	for i := 0; i < l; i++ {
 		min := i
-		for j := i + 1; j < length; j++ {
+		for j := i + 1; j < l; j++ {
 			if a[min] > a[j] {
 				min = j
 			}
diff --git a/sort/shell.go b/sort/shell.go
index 4a8fded..5fab584 100644
--- a/sort/shell.go
+++ b/sort/shell.go
@@ -5,17 +5,17 @@ import (
 )
 
 func Shell(a ds.ArrayList) ds.ArrayList {
-	length := len(a)
+	l := len(a)
 	// h-sort the array
 	h := 1
 
-	for h < length/3 {
+	for h < l/3 {
 		// 1, 4, 13, 40, 121, 364, 1093...
 		h = 3*h + 1
 	}
 
 	for h >= 1 {
-		for i := h; i < length; i++ {
+		for i := h; i < l; i++ {
 			for j := i; j >= h; j -= h {
 				if a[j-h] < a[j] {
 					break
diff --git a/sort/shuffle.go b/sort/shuffle.go
index 0c20a80..3611f7b 100644
--- a/sort/shuffle.go
+++ b/sort/shuffle.go
@@ -6,10 +6,10 @@ import (
 )
 
 func Shuffle(a ds.ArrayList) ds.ArrayList {
-	length := len(a)
+	l := len(a)
 
-	for i := 0; i < length; i++ {
-		r := length - rand.Intn(length-i) - 1
+	for i := 0; i < l; i++ {
+		r := l - rand.Intn(l-i) - 1
 		a.Swap(i, r)
 	}
 
diff --git a/sort/sort_test.go b/sort/sort_test.go
index e3bda34..475c179 100644
--- a/sort/sort_test.go
+++ b/sort/sort_test.go
@@ -144,48 +144,48 @@ func BenchmarkShuffleSort(b *testing.B) {
 }
 */
 
-func test(sort sortAlgorithm, length int, t *testing.T) {
+func test(sort sortAlgorithm, l int, t *testing.T) {
 	cb := func(t *testing.T) {
 		t.Parallel()
-		a := makeRandomIntegers(length, -1)
+		a := makeRandomIntegers(l, -1)
 		a = sort(a)
 		if !a.Sorted() {
 			t.Errorf("Array not sorted: %v", a)
 		}
 	}
-	t.Run(fmt.Sprintf("%d", length), cb)
+	t.Run(fmt.Sprintf("%d", l), cb)
 }
 
-func testShuffle(sort sortAlgorithm, length int, t *testing.T) {
+func testShuffle(sort sortAlgorithm, l int, t *testing.T) {
 	cb := func(t *testing.T) {
 		t.Parallel()
-		a := sort(ds.NewAscendingArrayList(length))
+		a := sort(ds.NewAscendingArrayList(l))
 		if a.Sorted() {
 			t.Errorf("Array sorted: %v", a.FirstN(10))
 		}
 	}
-	t.Run(fmt.Sprintf("%d", length), cb)
+	t.Run(fmt.Sprintf("%d", l), cb)
 }
 
-func benchmark(sort sortAlgorithm, length int, b *testing.B) {
-	a := makeRandomIntegers(length, -1)
-	b.Run(fmt.Sprintf("random(%d)", length), func(b *testing.B) {
+func benchmark(sort sortAlgorithm, l int, b *testing.B) {
+	a := makeRandomIntegers(l, -1)
+	b.Run(fmt.Sprintf("random(%d)", l), func(b *testing.B) {
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			benchResult = sort(a)
 		}
 	})
 
-	a = ds.NewAscendingArrayList(length)
-	b.Run(fmt.Sprintf("ascending(%d)", length), func(b *testing.B) {
+	a = ds.NewAscendingArrayList(l)
+	b.Run(fmt.Sprintf("ascending(%d)", l), func(b *testing.B) {
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			benchResult = sort(a)
 		}
 	})
 
-	a = ds.NewDescendingArrayList(length)
-	b.Run(fmt.Sprintf("descending(%d)", length), func(b *testing.B) {
+	a = ds.NewDescendingArrayList(l)
+	b.Run(fmt.Sprintf("descending(%d)", l), func(b *testing.B) {
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			benchResult = sort(a)
@@ -193,18 +193,18 @@ func benchmark(sort sortAlgorithm, length int, b *testing.B) {
 	})
 }
 
-func makeRandomIntegers(length, max int) ds.ArrayList {
+func makeRandomIntegers(l, max int) ds.ArrayList {
 	// Use a cache to make sure that all all sorting algos use the same
 	// random sequences.
 	if arrayListCache == nil {
 		arrayListCache = make(map[string]ds.ArrayList)
 	}
 
-	key := fmt.Sprintf("random(%d, %d)", length, max)
+	key := fmt.Sprintf("random(%d, %d)", l, max)
 	if a, ok := arrayListCache[key]; ok {
 		return a
 	}
-	a := ds.NewRandomArrayList(length, max)
+	a := ds.NewRandomArrayList(l, max)
 	arrayListCache[key] = a
 	return a
 }