Merge remote-tracking branch 'origin/master'

Author: 0xbrayo

ciphers/diffieHellmanKeyExchange.go

@@ -24,36 +24,40 @@ func main() {
 
 	AliceSecret := 1 + rand.Intn(1<<bit)
 	BobSecret := 1 + rand.Intn(1<<bit)
-
-	fmt.Printf("Alice's secret key is: %v", AliceSecret)
-	fmt.Printf("Bob's secret key is: %v", BobSecret)
-
-	//Both parties send ((g^secret_key)%p)
+	
+	fmt.Printf("Alice's secret key is: %v",AliceSecret)
+	fmt.Printf("Bob's secret key is: %v",BobSecret)
+	
+	//Both parties send ((g^secret_key)%p) 
 	//It's not possible to determine the secretkey from the value sent
 
 	AliceSends := modularExponentiation(g, AliceSecret, p)
 	BobSends := modularExponentiation(g, BobSecret, p)
 
-	fmt.Printf("Alice sends to Bob: %v", AliceSends)
-	fmt.Printf("Bob sends to Alice: %v", BobSends)
-
 	//Both parties calculate the shared secret key from the value send
+<<<<<<< HEAD
+
+=======
 	//(value_sent^secret_key)%p
 	//Both calculations end up with same value despite the different inputs
-	AliceComputes := modularExponentiation(BobSends, AliceSecret, p)
-	BobComputes := modularExponentiation(AliceSends, BobSecret, p)
-
-	fmt.Printf("Alice Computes the shared secret key as: %v", AliceComputes)
-	fmt.Printf("Bob Computes the shared secret key as: %v", BobComputes)
+	AliceComputes :=modularExponentiation(BobSends,AliceSecret,p)
+	BobComputes := modularExponentiation(AliceSends,BobSecret,p)
 
+	fmt.Printf("Alice Computes the shared secret key as: %v",AliceComputes)
+	fmt.Printf("Bob Computes the shared secret key as: %v",BobComputes)
+	
 	// simply confirms that the values are equal
-	if AliceComputes == BobComputes {
-		sharedKey := AliceComputes
-		fmt.Println(" Voila, shared key is", sharedKey)
+	if AliceComputes == BobComputes{
+		sharedKey:=AliceComputes
+		fmt.Println(" Voila, shared key is",sharedKey)
 	}
+}
+
+	
 
+	
 }
-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
 	//uses exponentiation by squaring to speed up the process
 	if mod == 1 {
@@ -65,8 +69,8 @@ func modularExponentiation(b int, e int, mod int) int {
 		if e%2 == 1 {
 			r = (r * b) % mod
 		}
-		e = e >> 1
-		b = (b * b) % mod
+		e =e>>1
+		b = (b*b)%mod
 	}
 	return r
 }

ciphers/xorCipher.go

@@ -34,11 +34,11 @@ func toASCII(slice []rune) []int {
 }
 func main() {
 	str := "hello world"
-	key := 97
-	temp := []rune(str)
-	message := toASCII(temp)
-	encrypted := encrypt(key, message)
-	decrypted := decrypt(key, encrypted)
-	plaintext := decodeToString(decrypted)
+	key :=97
+	temp:= []rune(str)
+	message:=toASCII(temp)
+	encrypted:=encrypt(key,message)
+	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 */
 	}
 }

math/fastExponent.go

@@ -0,0 +1,31 @@
+package main
+
+//based on square and multiply algorithm
+
+func fastExponentiation(b int, e int) float64 {
+	//runs in O(log(n)) where n = e
+	if e == 0 {
+		return 1.0
+	}
+	if e == 1 {
+		return float64(b)
+	}
+	if e < 0 {
+		e *= -1
+		println("executed")
+		return 1 / fastExponentiation(b, e)
+	}
+	r := 1
+	for e > 0 {
+		if e%2 == 1 {
+			r = r * b
+		}
+		e = e >> 1
+		b = b * b
+	}
+	return float64(r)
+}
+
+func main() {
+	print(fastExponentiation(2, 0))
+}

other/NestedBrackets.go

@@ -7,6 +7,7 @@
 // For example, the string "()()[()]" is properly nested but "[(()]" is not.
 // The function called isBalanced takes as input a string which is a sequence of brackets and
 // returns true if input is nested and false otherwise.
+//note that only an even number of brackets can be properly nested
 
 package main
 
@@ -18,7 +19,8 @@ import (
 )
 
 func isBalanced(input string) string {
-
+	if len(input)%2 != 0{
+		return input + "is not balanced."
 	if len(input) > 0 {
 		var stack []byte
 		for i := 0; i < len(input); i++ {

searches/binary_search.go

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 /*
 	Binary search implementation in Go
 */
@@ -33,3 +34,5 @@ func iterBinarySearch(array []int, target int, lowIndex int, highIndex int) int
 	}
 	return -1
 }
+=======
+>>>>>>> master

sorts/sorts_case_test.go

@@ -13,7 +13,7 @@ type sortTest struct {
 	name     string
 }
 
-var arr []int = makeRandArray(500_000)
+var arr []= makeRandArray(500_000)
 
 var sortTests = []sortTest{
 	//Sorted slice