fix: spellcheck (TheAlgorithms#527)

Author: tjgurwara99

README.md

@@ -91,8 +91,8 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 1. [`Abs`](./math/binary/abs.go#L10):  Abs returns absolute value using binary operation Principle of operation: 1) Get the mask by right shift by the base 2) Base is the size of an integer variable in bits, for example, for int32 it will be 32, for int64 it will be 64 3) For negative numbers, above step sets mask as 1 1 1 1 1 1 1 1 and 0 0 0 0 0 0 0 0 for positive numbers. 4) Add the mask to the given number. 5) XOR of mask + n and mask gives the absolute value.
 2. [`BitCounter`](./math/binary/bitcounter.go#L11):  BitCounter - The function returns the number of set bits for an unsigned integer number
-3. [`IsPowerOfTwo`](./math/binary/checkisnumberpoweroftwo.go#L19):  IsPowerOfTwo This function uses the fact that powers of 2 are represented like 10...0 in binary, and numbers one less than the power of 2 are represented like 11...1. Therefore, using the and function:    10...0  & 01...1    00...0 -> 0 This is also true for 0, which is not a power of 2, for which we have to add and extra condition.
-4. [`IsPowerOfTwoLeftShift`](./math/binary/checkisnumberpoweroftwo.go#L26):  IsPowerOfTwoLeftShift This function takes advantage of the fact that left shifting a number by 1 is equivalent to multiplying by 2. For example, binary 00000001 when shifted by 3 becomes 00001000, which in decimal system is 8 or = 2 * 2 * 2
+3. [`IsPowerOfTwo`](./math/binary/checkisnumberpoweroftwo.go#L21):  IsPowerOfTwo This function uses the fact that powers of 2 are represented like 10...0 in binary, and numbers one less than the power of 2 are represented like 11...1. Therefore, using the and function:	  10...0	& 01...1	  00...0 -> 0 This is also true for 0, which is not a power of 2, for which we have to add and extra condition.
+4. [`IsPowerOfTwoLeftShift`](./math/binary/checkisnumberpoweroftwo.go#L28):  IsPowerOfTwoLeftShift This function takes advantage of the fact that left shifting a number by 1 is equivalent to multiplying by 2. For example, binary 00000001 when shifted by 3 becomes 00001000, which in decimal system is 8 or = 2 * 2 * 2
 5. [`LogBase2`](./math/binary/logarithm.go#L7):  LogBase2 Finding the exponent of n = 2**x using bitwise operations (logarithm in base 2 of n) [See more](https://en.wikipedia.org/wiki/Logarithm)
 6. [`MeanUsingAndXor`](./math/binary/arithmeticmean.go#L12):  MeanUsingAndXor This function finds arithmetic mean using "AND" and "XOR" operations
 7. [`MeanUsingRightShift`](./math/binary/arithmeticmean.go#L17):  MeanUsingRightShift This function finds arithmetic mean using right shift
@@ -238,7 +238,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 ---
 
-#####  Package diffiehellman implements Deffie Hellman Key Exchange Algorithm for more information watch : https://www.youtube.com/watch?v=NmM9HA2MQGI
+#####  Package diffiehellman implements Diffie-Hellman Key Exchange Algorithm for more information watch : https://www.youtube.com/watch?v=NmM9HA2MQGI
 
 ---
 ##### Functions:
@@ -501,7 +501,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 ---
 
-#####  Package linkedlist demonstates different implementations on linkedlists.
+#####  Package linkedlist demonstrates different implementations on linkedlists.
 
 ---
 ##### Functions:
@@ -552,8 +552,11 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 3. [`FindKthMax`](./math/kthnumber.go#L11):  FindKthMax returns the kth large element given an integer slice with nil `error` if found and returns -1 with `error` `search.ErrNotFound` if not found. NOTE: The `nums` slice gets mutated in the process.
 4. [`FindKthMin`](./math/kthnumber.go#L19):  FindKthMin returns kth small element given an integer slice with nil `error` if found and returns -1 with `error` `search.ErrNotFound` if not found. NOTE: The `nums` slice gets mutated in the process.
 5. [`IsPowOfTwoUseLog`](./math/checkisnumberpoweroftwo.go#L10):  IsPowOfTwoUseLog This function checks if a number is a power of two using the logarithm. The limiting degree can be from 0 to 63. See alternatives in the binary package.
-6. [`Phi`](./math/eulertotient.go#L5):  Phi is the Euler totient function. This function computes the number of numbers less then n that are coprime with n.
-7. [`Sin`](./math/sin.go#L9):  Sin returns the sine of the radian argument x. [See more](https://en.wikipedia.org/wiki/Sine_and_cosine)
+6. [`Mean`](./math/mean.go#L7): No description provided.
+7. [`Median`](./math/median.go#L12): No description provided.
+8. [`Mode`](./math/mode.go#L19): No description provided.
+9. [`Phi`](./math/eulertotient.go#L5):  Phi is the Euler totient function. This function computes the number of numbers less then n that are coprime with n.
+10. [`Sin`](./math/sin.go#L9):  Sin returns the sine of the radian argument x. [See more](https://en.wikipedia.org/wiki/Sine_and_cosine)
 
 ---
 </details><details>
@@ -623,7 +626,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 ---
 ##### Functions:
 
-1. [`IsBalanced`](./other/nested/nestedbrackets.go#L20):  IsBalanced returns true if provided input string is properly nested. Input is a sequence of brackets: '(', ')', '[', ']', '{', '}'. A sequence of brackets `s` is considered properly nested if any of the following conditions are true: 	- `s` is empty; 	- `s` has the form (U) or [U] or {U} where U is a properly nested string; 	- `s` has the form VW where V and W are properly nested strings. For example, the string "()()[()]" is properly nested but "[(()]" is not. **Note** Providing characters other then brackets would return false, despite brackets sequence in the string. Make sure to filter input before usage.
+1. [`IsBalanced`](./other/nested/nestedbrackets.go#L20):  IsBalanced returns true if provided input string is properly nested. Input is a sequence of brackets: '(', ')', '[', ']', '{', '}'. A sequence of brackets `s` is considered properly nested if any of the following conditions are true:   - `s` is empty;   - `s` has the form (U) or [U] or {U} where U is a properly nested string;   - `s` has the form VW where V and W are properly nested strings. For example, the string "()()[()]" is properly nested but "[(()]" is not. **Note** Providing characters other then brackets would return false, despite brackets sequence in the string. Make sure to filter input before usage.
 
 ---
 </details><details>
@@ -765,7 +768,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 ##### Functions:
 
-1. [`Distance`](./math/pythagoras/pythagoras.go#L15): Distance calculates the distance between to vectors with the   Pythagoras theorem
+1. [`Distance`](./math/pythagoras/pythagoras.go#L15):  Distance calculates the distance between to vectors with the   Pythagoras theorem
 
 ---
 ##### Types
@@ -868,7 +871,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 ---
 
-#####  Package sort a package for demonstrating sorting algorithms in Go
+#####  Package sort a package for demonstrating sorting algorithms in Go Package sort Patience sorting is a sorting algorithm inspired by the card game patience.  For more details check out those links below here: GeeksForGeeks article : https://www.geeksforgeeks.org/patience-sorting/ Wikipedia article: https://en.wikipedia.org/wiki/Patience_sorting authors [guuzaa](https://github.com/guuzaa) see patiencesort.go
 
 ---
 ##### Functions:
@@ -883,13 +886,14 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 8. [`Merge`](./sort/mergesort.go#L40):  Merge Perform merge sort on a slice
 9. [`MergeIter`](./sort/mergesort.go#L54): No description provided.
 10. [`Partition`](./sort/quicksort.go#L12): No description provided.
-11. [`Pigeonhole`](./sort/pigeonholesort.go#L12):  Pigeonhole sorts a slice using pigeonhole sorting algorithm.
-12. [`Quicksort`](./sort/quicksort.go#L39):  Quicksort Sorts the entire array
-13. [`QuicksortRange`](./sort/quicksort.go#L26):  QuicksortRange Sorts the specified range within the array
-14. [`RadixSort`](./sort/radixsort.go#L35): No description provided.
-15. [`Selection`](./sort/selectionsort.go#L5): No description provided.
-16. [`Shell`](./sort/shellsort.go#L5): No description provided.
-17. [`Simple`](./sort/simplesort.go#L13): No description provided.
+11. [`Patience`](./sort/patiencesort.go#L13): No description provided.
+12. [`Pigeonhole`](./sort/pigeonholesort.go#L12):  Pigeonhole sorts a slice using pigeonhole sorting algorithm.
+13. [`Quicksort`](./sort/quicksort.go#L39):  Quicksort Sorts the entire array
+14. [`QuicksortRange`](./sort/quicksort.go#L26):  QuicksortRange Sorts the specified range within the array
+15. [`RadixSort`](./sort/radixsort.go#L35): No description provided.
+16. [`Selection`](./sort/selectionsort.go#L5): No description provided.
+17. [`Shell`](./sort/shellsort.go#L5): No description provided.
+18. [`Simple`](./sort/simplesort.go#L13): No description provided.
 
 ---
 ##### Types

other/password/generator.go

@@ -25,7 +25,7 @@ func Generate(minLength int, maxLength int) string {
 
 	newPassword := make([]byte, intLength)
 	randomData := make([]byte, intLength+intLength/4)
-	clen := byte(len(chars))
+	charLen := byte(len(chars))
 	maxrb := byte(256 - (256 % len(chars)))
 	i := 0
 	for {
@@ -36,7 +36,7 @@ func Generate(minLength int, maxLength int) string {
 			if c >= maxrb {
 				continue
 			}
-			newPassword[i] = chars[c%clen]
+			newPassword[i] = chars[c%charLen]
 			i++
 			if i == intLength {
 				return string(newPassword)

structure/linkedlist/doc.go

@@ -1,2 +1,2 @@
-// Package linkedlist demonstates different implementations on linkedlists.
+// Package linkedlist demonstrates different implementations on linkedlists.
 package linkedlist

structure/trie/trie_bench_test.go

@@ -6,42 +6,15 @@ import (
 	"testing"
 )
 
-// CAUTION : make sure to limit the benchamrks to 3000 iterations,
+// CAUTION : make sure to limit the benchmarks to 3000 iterations,
 // or removal will mostly process an empty Trie, giving absurd results.
 
-// go test -v -bench=. -benchmem -benchtime=3000x
-
-// === RUN   TestTrieInsert
-// --- PASS: TestTrieInsert (0.00s)
-// === RUN   TestTrieRemove
-// --- PASS: TestTrieRemove (0.00s)
-// === RUN   ExampleNode
-// --- PASS: ExampleNode (0.00s)
-// goos: linux
-// goarch: amd64
-// pkg: github.com/TheAlgorithms/Go/structure/trie
-// BenchmarkTrie_Insert
-// BenchmarkTrie_Insert-8                      3000           1559881 ns/op         1370334 B/op      25794 allocs/op
-// BenchmarkTrie_Find_non_existant
-// BenchmarkTrie_Find_non_existant-8           3000                59.1 ns/op             0 B/op          0 allocs/op
-// BenchmarkTrie_Find_existant
-// BenchmarkTrie_Find_existant-8               3000               238 ns/op               0 B/op          0 allocs/op
-// BenchmarkTrie_Remove_lazy
-// BenchmarkTrie_Remove_lazy-8                 3000               126 ns/op               0 B/op          0 allocs/op
-// BenchmarkTrie_Remove_and_Compact
-// BenchmarkTrie_Remove_and_Compact-8          3000            213945 ns/op               0 B/op          0 allocs/op
-// PASS
-// ok      github.com/TheAlgorithms/Go/structure/trie      5.355s
-
 func BenchmarkTrie_Insert(b *testing.B) {
-
-	// prepare random words for insertion
 	insert := make([]string, 3000)
 	for i := 0; i < len(insert); i++ {
 		insert[i] = fmt.Sprintf("%f", rand.Float64())
 	}
 
-	// Reset timer and run benchmark for insertion
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		n := NewNode()
@@ -51,63 +24,55 @@ func BenchmarkTrie_Insert(b *testing.B) {
 
 func BenchmarkTrie_Find_non_existant(b *testing.B) {
 
-	// prepare random words for insertion
 	insert := make([]string, 3000)
 	for i := 0; i < len(insert); i++ {
 		insert[i] = fmt.Sprintf("%f", rand.Float64())
 	}
 	n := NewNode()
 	n.Insert(insert...)
 
-	// Reset timer and run benchmark for finding non existing
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		n.Find("0.3213213244346546546546565465465") // does not exists
 	}
 }
 
 func BenchmarkTrie_Find_existant(b *testing.B) {
-	// prepare and insert random words
 	insert := make([]string, 3000)
 	for i := 0; i < len(insert); i++ {
 		insert[i] = fmt.Sprintf("%f", rand.Float64())
 	}
 	n := NewNode()
 	n.Insert(insert...)
 
-	// Reset timer and run benchmark for finding existing words
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		n.Find(insert[i%3000]) // always exists !
 	}
 }
 
 func BenchmarkTrie_Remove_lazy(b *testing.B) {
-	// prepare and insert random words
 	insert := make([]string, 3000)
 	for i := 0; i < len(insert); i++ {
 		insert[i] = fmt.Sprintf("%f", rand.Float64())
 	}
 	n := NewNode()
 	n.Insert(insert...)
 
-	// Reset timer and run benchmark for lazily removing words
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		n.Remove(insert[i%3000]) //  exists, at least until removed ...
 	}
 }
 
 func BenchmarkTrie_Remove_and_Compact(b *testing.B) {
-	// prepare and insert random words
 	insert := make([]string, 3000)
 	for i := 0; i < len(insert); i++ {
 		insert[i] = fmt.Sprintf("%f", rand.Float64())
 	}
 	n := NewNode()
 	n.Insert(insert...)
 
-	// Reset timer and run benchmark for removing words and immediately compacting
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		n.Remove(insert[i%3000])