Standard formatting

I ran go fmt for every single go file in the repo. Maybe this can be automated via Github Actions

Author: 0xbrayo

ciphers/RSAcipher.go

@@ -2,57 +2,58 @@ package main
 
 import (
 	//"math/big"
-	"math/rand"
+	"fmt"
 	"math"
+	"math/rand"
 	"time"
-	"fmt"
 )
-func generatePrimes(limit int)int{
+
+func generatePrimes(limit int) int {
 	/*
-	generate primes by factoring
-	relies on the 30k+i, though better formulae exist
-	where k >=0 and i = (1,7,11,13,17,13,19,23,29)
+		generate primes by factoring
+		relies on the 30k+i, though better formulae exist
+		where k >=0 and i = (1,7,11,13,17,13,19,23,29)
 	*/
-	primes:= prime(limit)
+	primes := prime(limit)
 	var choice []int
-	choice = append(choice, 1,7,11,13,17,19,23,29)
-	for{
-		k:=rand.Intn(int(limit/30))
-		i:=choice[rand.Intn(len(choice))]
-		c:=30*k+i
+	choice = append(choice, 1, 7, 11, 13, 17, 19, 23, 29)
+	for {
+		k := rand.Intn(int(limit / 30))
+		i := choice[rand.Intn(len(choice))]
+		c := 30*k + i
 		found := true
-		for _,v:= range primes{
-			if c%v==0{
+		for _, v := range primes {
+			if c%v == 0 {
 				found = false
 				break
 			}
 		}
-		if found{
+		if found {
 			return c
 		}
 	}
 }
-func prime(limit int)(primes []int){
-	sqrtLimit:=int(math.Ceil(math.Sqrt(float64(limit))))
-	exit:= false
-	primes = append(primes,2,3,5)
-	lastIndex :=2
-	for ;primes[lastIndex]<sqrtLimit;{
-		if exit == true{
+func prime(limit int) (primes []int) {
+	sqrtLimit := int(math.Ceil(math.Sqrt(float64(limit))))
+	exit := false
+	primes = append(primes, 2, 3, 5)
+	lastIndex := 2
+	for primes[lastIndex] < sqrtLimit {
+		if exit == true {
 			break
 		}
-		for i:=primes[lastIndex]+2;i<primes[lastIndex]*primes[lastIndex];i+=2{
-			found:= true
-			for _,v:= range primes {
-				if i%v==0{
-					found= false
+		for i := primes[lastIndex] + 2; i < primes[lastIndex]*primes[lastIndex]; i += 2 {
+			found := true
+			for _, v := range primes {
+				if i%v == 0 {
+					found = false
 					break
 				}
 			}
-			if found{
-				primes = append(primes,i)
+			if found {
+				primes = append(primes, i)
 				lastIndex++
-				if i >=sqrtLimit{
+				if i >= sqrtLimit {
 					exit = true
 					break
 				}
@@ -62,113 +63,111 @@ func prime(limit int)(primes []int){
 	}
 	return
 }
-func lcm (a int, b int)int{
+func lcm(a int, b int) int {
 	//complexity depends on gcd
-	return int((a*b)/gcd(a,b))
+	return int((a * b) / gcd(a, b))
 
 }
-func gcd (a int, b int) int{
+func gcd(a int, b int) int {
 	//complexity not clear
-	for b != 0{
-		t:=b
+	for b != 0 {
+		t := b
 		b = a % b
 		a = t
 	}
 	return a
 }
-func modularMultiplicativeInverse(e int, delta int)int{
+func modularMultiplicativeInverse(e int, delta int) int {
 	//runs in O(n) where n = delta
-	e= e % delta
-	for i:=1;i<delta;i++{
-		if (i*e)%delta==1{
+	e = e % delta
+	for i := 1; i < delta; i++ {
+		if (i*e)%delta == 1 {
 			return i
 		}
 	}
 	return 0
 }
 
-func modularExponentiation(b int, e int, mod int)int{
+func modularExponentiation(b int, e int, mod int) int {
 	//runs in O(log(n)) where n = e
-	if mod == 1{
+	if mod == 1 {
 		return 0
 	}
-	r:=1
+	r := 1
 	b = b % mod
-	for ;e>0;{
-		if e%2==1{
-			r=(r*b)%mod
+	for e > 0 {
+		if e%2 == 1 {
+			r = (r * b) % mod
 		}
-		e =e>>1
-		b = (b*b)%mod
+		e = e >> 1
+		b = (b * b) % mod
 	}
 	return r
 }
 
-func encryptRSA(message []int,e int,n int)[]int{
+func encryptRSA(message []int, e int, 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))
+	for _, v := range message {
+		ciphertext = append(ciphertext, modularExponentiation(v, e, n))
 	}
 	return ciphertext
 }
-func decryptRSA(ciphertext []int, d int, n int )[]int{
+func decryptRSA(ciphertext []int, d int, n int) []int {
 	//runs in O(k*log(n)) where k = len(ciphertext) and n = d
 	var message []int
-	for _,v := range ciphertext {
-		message = append(message, modularExponentiation(v,d,n))
+	for _, v := range ciphertext {
+		message = append(message, modularExponentiation(v, d, n))
 	}
 	return message
 }
-func toASCII(slice []rune)[]int{
+func toASCII(slice []rune) []int {
 	//runs in O(n) where n = len(slice)
 	var converted []int
-	for _,v:= range slice{
+	for _, v := range slice {
 		converted = append(converted, int(v))
 	}
 	return converted
 }
 
-func toRune(slice []int)string{
+func toRune(slice []int) string {
 	//runs in O(n) where n = len(slice)
 	var str string
-	for _,v:= range slice{
+	for _, v := range slice {
 		str += string(v)
 	}
 	return str
 }
 
-
-func main(){
+func main() {
 	rand.Seed(time.Now().UTC().UnixNano())
-	bits:=17
+	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
-
-	delta:=lcm(p-1,q-1)
+	n := p * q
 
-	e:=generatePrimes(delta)
-	d:=modularMultiplicativeInverse(e,delta)
+	delta := lcm(p-1, q-1)
 
-	fmt.Printf("%v \n%v \n%v \n%v\n",p,q,e,d)
+	e := generatePrimes(delta)
+	d := modularMultiplicativeInverse(e, delta)
 
+	fmt.Printf("%v \n%v \n%v \n%v\n", p, q, e, d)
 
-	str:="I think RSA is really great"
+	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))
+	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
 
 }

ciphers/xorCipher.go

@@ -1,45 +1,45 @@
 package main
 
 import "fmt"
-func encrypt(key int, plaintext []int)(ciphertext []int){
-	for _,char:= range plaintext {
-		ciphertext = append(ciphertext,xor(char,key))
+
+func encrypt(key int, plaintext []int) (ciphertext []int) {
+	for _, char := range plaintext {
+		ciphertext = append(ciphertext, xor(char, key))
 	}
 	return
 }
-func xor(char int,key int)int{
-	return (char^key)
+func xor(char int, key int) int {
+	return (char ^ key)
 }
 
-func decrypt(key int, ciphertext []int)(plaintext []int){
-	for _,char:= range ciphertext {
-		plaintext = append(plaintext , xor(char,key))
+func decrypt(key int, ciphertext []int) (plaintext []int) {
+	for _, char := range ciphertext {
+		plaintext = append(plaintext, xor(char, key))
 	}
 	return
 }
 
-func decodeToString(slice []int)(str string){
-	for _,v:= range slice{
-		str+=string(v)
+func decodeToString(slice []int) (str string) {
+	for _, v := range slice {
+		str += string(v)
 	}
 	return
 }
-func toASCII(slice []rune)[]int{
+func toASCII(slice []rune) []int {
 	var converted []int
-	for _,v:= range slice{
+	for _, v := range slice {
 		converted = append(converted, int(v))
 	}
 	return converted
 }
-func main(){
+func main() {
 	str := "hello world"
-	key :=97
-	temp:= []rune(str)
-	message:=toASCII(temp)
-	encrypted:=encrypt(key,message)
+	key := 97
+	temp := []rune(str)
+	message := toASCII(temp)
+	encrypted := encrypt(key, message)
 	//ciphertext:=decodeToString(key,message)
-	decrypted:=decrypt(key,encrypted)
-	plaintext:=decodeToString(decrypted)
+	decrypted := decrypt(key, encrypted)
+	plaintext := decodeToString(decrypted)
 	fmt.Println(plaintext)
 }
-

data-structures/linked-list/Linkedlist.go

@@ -4,7 +4,7 @@ import "fmt"
 
 /* v is the value of node; next is the pointer to next node */
 type node struct {
-	v int
+	v    int
 	next *node
 }
 
@@ -24,9 +24,9 @@ func (l *node) pushFront(val int) *node {
 		nnode = head
 		/* create a second node with new value and `next -> nnode`
 		*  is this way, nnode2 is before nnode
-		*/
-		nnode2 := &node {
-			v: val,
+		 */
+		nnode2 := &node{
+			v:    val,
 			next: nnode,
 		}
 		/* now head is equals nnode2 */
@@ -62,7 +62,7 @@ func (l *node) popFront() *node {
 	/* create a new node equals to first node pointed by head */
 	cpnode := new(node)
 	cpnode = head.next
-	
+
 	/* now head is equals cpnode (second node) */
 	head = cpnode
 
@@ -76,7 +76,7 @@ func (l *node) popBack() *node {
 	/* create a new node equals to head */
 	cpnode := new(node)
 	cpnode = head
-	
+
 	/* read list to the penultimate node */
 	for cpnode.next.next != nil {
 		cpnode = cpnode.next
@@ -89,14 +89,14 @@ func (l *node) popBack() *node {
 func main() {
 	lista := new(node)
 	lista.pushBack(25).pushBack(24).pushBack(32) /* lista: 25 24 32 */
-	lista.pushBack(56) /* lista: 25 24 32 56 */
-	lista.pushFront(36) /* lista: 36 25 24 32 56 */
-	lista.popFront() /* lista: 25 24 32 56 */
-	lista.popBack() /* lista: 25 24 32 */
-	
+	lista.pushBack(56)                           /* lista: 25 24 32 56 */
+	lista.pushFront(36)                          /* lista: 36 25 24 32 56 */
+	lista.popFront()                             /* lista: 25 24 32 56 */
+	lista.popBack()                              /* lista: 25 24 32 */
+
 	/* read the list until head is not nil */
 	for head != nil {
-		fmt.Printf("%d ",head.v)
+		fmt.Printf("%d ", head.v)
 		head = head.next /*head points to next node */
 	}
 }