Fix: Major restructuring for fixing the linting workflow errors and module style code writing.

.github/workflows/golangci-lint.yml

@@ -18,22 +18,23 @@ jobs:
           # only-new-issues: true  # Let's focus on this PR first
       - run: echo "/home/runner/golangci-lint-1.31.0-linux-amd64" >> $GITHUB_PATH
       - run: go version ; golangci-lint --version  # Fix the following and remove || true
-      - run: golangci-lint run --no-config ciphers
-      - run: golangci-lint run --no-config datastructures/binary-tree        || true
-      - run: golangci-lint run --no-config datastructures/dynamic-array      || true
-      - run: golangci-lint run --no-config datastructures/hashmap
-      - run: golangci-lint run --no-config datastructures/linkedlist        || true
-      - run: golangci-lint run --no-config datastructures/trie               || true
-      - run: golangci-lint run --no-config dynamicprogramming                || true
-      - run: golangci-lint run --no-config other                              || true
-      - run: golangci-lint run --no-config searches                           || true
-      - run: golangci-lint run --no-config sorts
-      # - run: golangci-lint run --no-config strings/...
-      - run: golangci-lint run --no-config "strings/multiple-string-matching" || true
+      - run: golangci-lint run --no-config ciphers/...
+      # - run: golangci-lint run --no-config datastructures/binary-tree        || true
+      # - run: golangci-lint run --no-config datastructures/dynamic-array      || true
+      # - run: golangci-lint run --no-config datastructures/hashmap
+      # - run: golangci-lint run --no-config datastructures/linkedlist        || true
+      # - run: golangci-lint run --no-config datastructures/trie               || true
+      - run: golangci-lint run --no-config dynamicprogramming/...
+      - run: golangci-lint run --no-config other/...
+      - run: golangci-lint run --no-config searches/...
+      - run: golangci-lint run --no-config sorts/...
+      - run: golangci-lint run --no-config strings/...
+      # - run: golangci-lint run --no-config "strings/multiple-string-matching" || true
       # - run: golangci-lint run --no-config "strings/single string matching"   || true
-      - run: golangci-lint run --no-config strings/levenshteindistance
-      - run: golangci-lint run --no-config strings/naivesearch
-      - run: golangci-lint run --no-config math/gcd
-      - run: golangci-lint run --no-config math/power
-      - run: golangci-lint run --no-config math/primecheck
-      - run: golangci-lint run --no-config math/sieve                         || true
+      # - run: golangci-lint run --no-config strings/levenshteindistance
+      # - run: golangci-lint run --no-config strings/naivesearch
+      - run: golangci-lint run --no-config math/...
+      # - run: golangci-lint run --no-config math/gcd
+      # - run: golangci-lint run --no-config math/power
+      # - run: golangci-lint run --no-config math/primecheck
+      # - run: golangci-lint run --no-config math/sieve                         || true

DIRECTORY.md

@@ -29,17 +29,20 @@
   * Binary-Tree
     * [Binarysearchtree](https://github.com/TheAlgorithms/Go/blob/master/datastructures/binary-tree/binarysearchtree.go)
     * [Binarytree](https://github.com/TheAlgorithms/Go/blob/master/datastructures/binary-tree/binarytree.go)
+    * [Btree](https://github.com/TheAlgorithms/Go/blob/master/datastructures/binary-tree/btree.go)
+    * [Node](https://github.com/TheAlgorithms/Go/blob/master/datastructures/binary-tree/node.go)
   * Dynamic-Array
     * [Dynamicarray](https://github.com/TheAlgorithms/Go/blob/master/datastructures/dynamic-array/dynamicarray.go)
   * Hashmap
     * [Hashmap](https://github.com/TheAlgorithms/Go/blob/master/datastructures/hashmap/hashmap.go)
     * [Hashmap Test](https://github.com/TheAlgorithms/Go/blob/master/datastructures/hashmap/hashmap_test.go)
   * Linkedlist
-    * [Doublylinkedlist](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/doublylinkedlist.go)
-    * Singlelinkedlist
-      * [Single-Linkedlist](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlelinkedlist/single-linkedlist.go)
-      * [Single-Linkedlist Test](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlelinkedlist/single-linkedlist_test.go)
-    * [Singlylinkedlist](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlylinkedlist.go)
+    * Doublylinkedlist
+      * [Doublylinkedlist](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/doublylinkedlist/doublylinkedlist.go)
+    * Singlylinkedlist
+      * [Singlylinkedlist](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlylinkedlist/singlylinkedlist.go)
+      * [Singlylinkedlist2](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlylinkedlist/singlylinkedlist2.go)
+      * [Singlylinkedlist Test](https://github.com/TheAlgorithms/Go/blob/master/datastructures/linkedlist/singlylinkedlist/singlylinkedlist_test.go)
   * Trie
     * [Trie](https://github.com/TheAlgorithms/Go/blob/master/datastructures/trie/trie.go)
     * [Trie Test](https://github.com/TheAlgorithms/Go/blob/master/datastructures/trie/trie_test.go)
@@ -55,9 +58,12 @@
   * [Rod-Cutting](https://github.com/TheAlgorithms/Go/blob/master/dynamicprogramming/rod-cutting.go)
 
 ## Graphs
-  * [Breathfirstsearch](https://github.com/TheAlgorithms/Go/blob/master/graphs/breathfirstsearch.go)
-  * [Depthfirstsearch](https://github.com/TheAlgorithms/Go/blob/master/graphs/depthfirstsearch.go)
-  * [Floydwarshall](https://github.com/TheAlgorithms/Go/blob/master/graphs/floydwarshall.go)
+  * Breathfirstsearch
+    * [Breathfirstsearch](https://github.com/TheAlgorithms/Go/blob/master/graphs/breathfirstsearch/breathfirstsearch.go)
+  * Depthfirstsearch
+    * [Depthfirstsearch](https://github.com/TheAlgorithms/Go/blob/master/graphs/depthfirstsearch/depthfirstsearch.go)
+  * Floydwarshall
+    * [Floydwarshall](https://github.com/TheAlgorithms/Go/blob/master/graphs/floydwarshall/floydwarshall.go)
 
 ## Math
   * Gcd
@@ -74,17 +80,20 @@
     * [Pythagoras Test](https://github.com/TheAlgorithms/Go/blob/master/math/pythagoras/pythagoras_test.go)
   * Sieve
     * [Sieve](https://github.com/TheAlgorithms/Go/blob/master/math/sieve/Sieve.go)
+    * [Sieve Test](https://github.com/TheAlgorithms/Go/blob/master/math/sieve/sieve_test.go)
 
 ## Other
-  * [Maxsubarraysum](https://github.com/TheAlgorithms/Go/blob/master/other/maxsubarraysum.go)
+  * Maxsubarraysum
+    * [Maxsubarraysum](https://github.com/TheAlgorithms/Go/blob/master/other/maxsubarraysum/maxsubarraysum.go)
   * Monte Carlo Pi
     * [Monte Carlo Pi](https://github.com/TheAlgorithms/Go/blob/master/other/monte_carlo_pi/monte_carlo_pi.go)
     * [Monte Carlo Pi Test](https://github.com/TheAlgorithms/Go/blob/master/other/monte_carlo_pi/monte_carlo_pi_test.go)
-  * [Nestedbrackets](https://github.com/TheAlgorithms/Go/blob/master/other/nestedbrackets.go)
-  * [Passwordgenerator](https://github.com/TheAlgorithms/Go/blob/master/other/passwordgenerator.go)
-  * [Prime Numbers](https://github.com/TheAlgorithms/Go/blob/master/other/prime_numbers.go)
-  * [Primenumbers](https://github.com/TheAlgorithms/Go/blob/master/other/PrimeNumbers.go)
-  * [Stringcombinations](https://github.com/TheAlgorithms/Go/blob/master/other/stringcombinations.go)
+  * Nestedbrackets
+    * [Nestedbrackets](https://github.com/TheAlgorithms/Go/blob/master/other/nestedbrackets/nestedbrackets.go)
+  * Passwordgenerator
+    * [Passwordgenerator](https://github.com/TheAlgorithms/Go/blob/master/other/passwordgenerator/passwordgenerator.go)
+  * Stringcombinations
+    * [Stringcombinations](https://github.com/TheAlgorithms/Go/blob/master/other/stringcombinations/stringcombinations.go)
 
 ## Searches
   * [Binarysearch](https://github.com/TheAlgorithms/Go/blob/master/searches/binarysearch.go)
@@ -121,8 +130,10 @@
     * [Naivestringsearch](https://github.com/TheAlgorithms/Go/blob/master/strings/naivesearch/naiveStringSearch.go)
     * [Naivestringsearch Test](https://github.com/TheAlgorithms/Go/blob/master/strings/naivesearch/naiveStringSearch_test.go)
   * Single-String-Matching
-    * [Bom](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/bom.go)
-    * [Horspool](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/horspool.go)
+    * Bom
+      * [Bom](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/bom/bom.go)
+    * Horspool
+      * [Horspool](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/horspool/horspool.go)
     * Kmp
       * [Kmp](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/kmp/kmp.go)
       * [Kmp Test](https://github.com/TheAlgorithms/Go/blob/master/strings/single-string-matching/kmp/kmp_test.go)

ciphers/caesar/CaesarCipher.go

@@ -2,17 +2,8 @@
 // ref: https://en.wikipedia.org/wiki/Caesar_cipher
 package caesar
 
-// Caesar is struct for Caesar cipher
-type Caesar struct {
-}
-
-// NewCaesar returns a pointer to object of Caesar
-func NewCaesar() *Caesar {
-	return &Caesar{}
-}
-
 // Encrypt encrypts by right shift of "key" each character of "input"
-func (c Caesar) Encrypt(input string, key int) string {
+func Encrypt(input string, key int) string {
 	// if key is negative value,
 	// updates "key" the number which congruents to "key" modulo 26
 	key = (key%26 + 26) % 26
@@ -32,7 +23,7 @@ func (c Caesar) Encrypt(input string, key int) string {
 }
 
 // Decrypt decrypts by left shift of "key" each character of "input"
-func (c Caesar) Decrypt(input string, key int) string {
+func Decrypt(input string, key int) string {
 	// left shift of "key" is same as right shift of 26-"key"
-	return c.Encrypt(input, 26-key)
+	return Encrypt(input, 26-key)
 }

ciphers/caesar/caesar_test.go

@@ -1,13 +1,10 @@
-package caesar_test
+package caesar
 
 import (
-	"TheAlgorithms/Go/ciphers/caesar"
 	"fmt"
 	"testing"
 )
 
-var c *caesar.Caesar = caesar.NewCaesar()
-
 func TestEncrypt(t *testing.T) {
 	var caesarTestData = []struct {
 		description string
@@ -66,7 +63,7 @@ func TestEncrypt(t *testing.T) {
 	}
 	for _, test := range caesarTestData {
 		t.Run(test.description, func(t *testing.T) {
-			actual := c.Encrypt(test.input, test.key)
+			actual := Encrypt(test.input, test.key)
 			if actual != test.expected {
 				t.Logf("FAIL: %s", test.description)
 				t.Fatalf("With input string '%s' and key '%d' was expecting '%s' but actual was '%s'",
@@ -129,7 +126,7 @@ func TestDecrypt(t *testing.T) {
 
 	for _, test := range caesarTestData {
 		t.Run(test.description, func(t *testing.T) {
-			actual := c.Decrypt(test.input, test.key)
+			actual := Decrypt(test.input, test.key)
 			if actual != test.expected {
 				t.Logf("FAIL: %s", test.description)
 				t.Fatalf("With input string '%s' and key '%d' was expecting '%s' but actual was '%s'",
@@ -139,18 +136,16 @@ func TestDecrypt(t *testing.T) {
 	}
 }
 
-func ExampleNewCaesar() {
+func Example() {
 	const (
 		key   = 10
 		input = "The Quick Brown Fox Jumps over the Lazy Dog."
 	)
 
-	c := caesar.NewCaesar()
-
-	encryptedText := c.Encrypt(input, key)
+	encryptedText := Encrypt(input, key)
 	fmt.Printf("Encrypt=> key: %d, input: %s, encryptedText: %s\n", key, input, encryptedText)
 
-	decryptedText := c.Decrypt(encryptedText, key)
+	decryptedText := Decrypt(encryptedText, key)
 	fmt.Printf("Decrypt=> key: %d, input: %s, decryptedText: %s\n", key, encryptedText, decryptedText)
 
 	// Output:

ciphers/polybius/polybius.go

@@ -35,9 +35,8 @@ func NewPolybius(key string, size int, chars string) (*Polybius, error) {
 
 // Encrypt encrypts with polybius encryption
 func (p *Polybius) Encrypt(text string) (string, error) {
-	chars := []rune(strings.ToUpper(text))
 	encryptedText := ""
-	for _, char := range chars {
+	for _, char := range strings.ToUpper(text) {
 		encryptedChar, err := p.encipher(char)
 		if err != nil {
 			return "", fmt.Errorf("failed encipher: %w", err)

ciphers/polybius/polybius_test.go

@@ -1,7 +1,6 @@
-package polybius_test
+package polybius
 
 import (
-	"TheAlgorithms/Go/ciphers/polybius"
 	"fmt"
 	"log"
 	"testing"
@@ -15,7 +14,7 @@ func ExampleNewPolybius() {
 		characters = "HogeF"
 		key        = "abcdefghijklmnopqrstuvwxy"
 	)
-	p, err := polybius.NewPolybius(key, size, characters)
+	p, err := NewPolybius(key, size, characters)
 	if err != nil {
 		log.Fatalf("failed NewPolybius: %v", err)
 	}
@@ -61,7 +60,7 @@ func TestNewPolybius(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			_, err := polybius.NewPolybius(tc.key, tc.size, tc.characters)
+			_, err := NewPolybius(tc.key, tc.size, tc.characters)
 			if err != nil && err.Error() != tc.wantErr {
 				t.Errorf("failed NewPolybius: %v", err)
 			}
@@ -89,7 +88,7 @@ func TestPolybiusEncrypt(t *testing.T) {
 		characters = "HogeF"
 		key        = "abcdefghijklmnopqrstuvwxy"
 	)
-	p, err := polybius.NewPolybius(key, size, characters)
+	p, err := NewPolybius(key, size, characters)
 	if err != nil {
 		t.Fatalf("failed NewPolybius: %v", err)
 	}
@@ -133,7 +132,7 @@ func TestPolybiusDecrypt(t *testing.T) {
 		characters = "HogeF"
 		key        = "abcdefghijklmnopqrstuvwxy"
 	)
-	p, err := polybius.NewPolybius(key, size, characters)
+	p, err := NewPolybius(key, size, characters)
 	if err != nil {
 		t.Fatalf("failed NewPolybius: %v", err)
 	}

ciphers/rot13/rot13.go

@@ -3,10 +3,10 @@
 package rot13
 
 import (
-	"TheAlgorithms/Go/ciphers/caesar"
+	"github.com/tjgurwara99/Go/ciphers/caesar"
 )
 
 // rot13 is a special case, which is fixed the shift of 13, of the Caesar cipher
 func rot13(input string) string {
-	return caesar.NewCaesar().Encrypt(input, 13)
+	return caesar.Encrypt(input, 13)
 }

ciphers/rsa/RSAcipher.go

@@ -1,11 +1,10 @@
-package main
+package rsacipher
 
 import (
 	//"math/big"
-	"fmt"
+
 	"math"
 	"math/rand"
-	"time"
 )
 
 func generatePrimes(limit int) int {
@@ -39,7 +38,7 @@ func prime(limit int) (primes []int) {
 	primes = append(primes, 2, 3, 5)
 	lastIndex := 2
 	for primes[lastIndex] < sqrtLimit {
-		if exit == true {
+		if exit {
 			break
 		}
 		for i := primes[lastIndex] + 2; i < primes[lastIndex]*primes[lastIndex]; i += 2 {
@@ -105,15 +104,18 @@ func modularExponentiation(b, e, mod int) int {
 	return r
 }
 
-func encryptRSA(message []int, e, n int) []int {
+// EncryptRSA main encryption function for RSA
+func EncryptRSA(message []int, e, n int) []int {
 	//runs in O(k*log(n)) where k = len(message) and n = e
 	var ciphertext []int
 	for _, v := range message {
 		ciphertext = append(ciphertext, modularExponentiation(v, e, n))
 	}
 	return ciphertext
 }
-func decryptRSA(ciphertext []int, d, n int) []int {
+
+// DecryptRSA main decryption function for RSA
+func DecryptRSA(ciphertext []int, d, n int) []int {
 	//runs in O(k*log(n)) where k = len(ciphertext) and n = d
 	var message []int
 	for _, v := range ciphertext {
@@ -130,7 +132,8 @@ func toASCII(slice []rune) []int {
 	return converted
 }
 
-func toRune(slice []int) string {
+// ToRune convert a string to rune
+func ToRune(slice []int) string {
 	//runs in O(n) where n = len(slice)
 	var str string
 	for _, v := range slice {
@@ -139,35 +142,35 @@ func toRune(slice []int) string {
 	return str
 }
 
-func main() {
-	rand.Seed(time.Now().UTC().UnixNano())
-	bits := 17
+// func main() {
+// 	rand.Seed(time.Now().UTC().UnixNano())
+// 	bits := 17
 
-	p := generatePrimes(1 << bits)
-	q := generatePrimes(1 << bits)
-	for p == q {
-		q = generatePrimes(1 << bits)
-	}
+// 	p := generatePrimes(1 << bits)
+// 	q := generatePrimes(1 << bits)
+// 	for p == q {
+// 		q = generatePrimes(1 << bits)
+// 	}
 
-	n := p * q
+// 	n := p * q
 
-	delta := lcm(p-1, q-1)
+// 	delta := lcm(p-1, q-1)
 
-	e := generatePrimes(delta)
-	d := modularMultiplicativeInverse(e, delta)
+// 	e := generatePrimes(delta)
+// 	d := modularMultiplicativeInverse(e, delta)
 
-	fmt.Printf("%v \n%v \n%v \n%v\n", p, q, e, d)
+// 	fmt.Printf("%v \n%v \n%v \n%v\n", p, q, e, d)
 
-	str := "I think RSA is really great"
-	message := []rune(str)
-	asciiSlice := toASCII(message)
+// 	str := "I think RSA is really great"
+// 	message := []rune(str)
+// 	asciiSlice := toASCII(message)
 
-	fmt.Printf("asciiSlice : %v \n", asciiSlice)
-	encrypted := encryptRSA(asciiSlice, e, n)
-	fmt.Printf("encrypted : %v \n", encrypted)
-	decrypted := decryptRSA(encrypted, d, n)
-	fmt.Printf("decrypted : %v \n", decrypted)
-	fmt.Printf("cleartext : %v \n", toRune(decrypted))
-	//switched to atom
+// 	fmt.Printf("asciiSlice : %v \n", asciiSlice)
+// 	encrypted := encryptRSA(asciiSlice, e, n)
+// 	fmt.Printf("encrypted : %v \n", encrypted)
+// 	decrypted := decryptRSA(encrypted, d, n)
+// 	fmt.Printf("decrypted : %v \n", decrypted)
+// 	fmt.Printf("cleartext : %v \n", toRune(decrypted))
+// 	//switched to atom
 
-}
+// }