Merge branch 'master' of https://github.com/brayo-pip/Go

Author: 0xbrayo

sorts/bubble_sort.go

@@ -1,24 +1,21 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-func bubbleSort(arrayzor []int) []int {
-
-
-	swapped := true
-	for swapped {
-		swapped = false
-		for i := 0; i < len(arrayzor)-1; i++ {
-			if arrayzor[i+1] < arrayzor[i] {
-				swap(arrayzor, i, i+1)
-				swapped = true
-			}
+func bubbleSort(array []int)[]int{
+	for a:=0; a<len(array)-1;a++{
+		for i:=a;i<len(array)-1;i++{
+			j:=i+1
+			array =swap(array, i,j)
 		}
 	}
-	return arrayzor
-}
+	return array
 
-func swap(arrayzor []int, i, j int) {
-	tmp := arrayzor[j]
-	arrayzor[j] = arrayzor[i]
-	arrayzor[i] = tmp
 }
+
+func swap(array []int, i int, j int)[]int{
+	if array[i]>array[j]{
+		array[i],array[j] =array[j],array[i]
+	}
+	return array
+
+}

sorts/heap_sort.go

@@ -1,20 +1,20 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-type MaxHeap struct {
+type maxHeap struct {
 	slice    []int
 	heapSize int
 }
 
-func BuildMaxHeap(slice []int) MaxHeap {
-	h := MaxHeap{slice: slice, heapSize: len(slice)}
+func buildMaxHeap(slice []int) maxHeap {
+	h := maxHeap{slice: slice, heapSize: len(slice)}
 	for i := len(slice) / 2; i >= 0; i-- {
 		h.MaxHeapify(i)
 	}
 	return h
 }
 
-func (h MaxHeap) MaxHeapify(i int) {
+func (h maxHeap) MaxHeapify(i int) {
 	l, r := 2*i+1, 2*i+2
 	max := i
 
@@ -31,10 +31,10 @@ func (h MaxHeap) MaxHeapify(i int) {
 	}
 }
 
-func (h MaxHeap) size() int { return h.heapSize } // ???
+func (h maxHeap) size() int { return h.heapSize } // ???
 
 func heapSort(slice []int) []int {
-	h := BuildMaxHeap(slice)
+	h := buildMaxHeap(slice)
 	//log.Println(slice)
 	for i := len(h.slice) - 1; i >= 1; i-- {
 		h.slice[0], h.slice[i] = h.slice[i], h.slice[0]

sorts/quick_sort.go

@@ -13,26 +13,26 @@ func quickSort(arr []int) []int {
 
 	median := arr[rand.Intn(len(arr))]
 
-	low_part := make([]int, 0, len(arr))
-	high_part := make([]int, 0, len(arr))
-	middle_part := make([]int, 0, len(arr))
+	lowPart := make([]int, 0, len(arr))
+	highPart := make([]int, 0, len(arr))
+	middlePart := make([]int, 0, len(arr))
 
 	for _, item := range arr {
 		switch {
 		case item < median:
-			low_part = append(low_part, item)
+			lowPart = append(lowPart, item)
 		case item == median:
-			middle_part = append(middle_part, item)
+			middlePart = append(middlePart, item)
 		case item > median:
-			high_part = append(high_part, item)
+			highPart = append(highPart, item)
 		}
 	}
 
-	low_part = quickSort(low_part)
-	high_part = quickSort(high_part)
+	lowPart = quickSort(lowPart)
+	highPart = quickSort(highPart)
 
-	low_part = append(low_part, middle_part...)
-	low_part = append(low_part, high_part...)
+	lowPart = append(lowPart, middlePart...)
+	lowPart = append(lowPart, highPart...)
 
-	return low_part
+	return lowPart
 }

strings/naiveStringSearch.go

@@ -16,14 +16,14 @@ import (
 
 func naivePatternSearch(text string, pattern string) []int { 
     var positions []int 
-    for i := 0; i < len(text); i++ {
+    for i := 0; i < len(text)-len(pattern); i++ {
         var match bool = true
-        for j := 0; j < len(pattern); j++ {
-            if text[i+j] != pattern[j] {
+        j := i +(len(pattern))
+        if text[i+j] != pattern[j] {
                 match = false
                 break
             }
-        }
+        
         if match {
             positions = append(positions, i)
         }