Refact all Go files

src/go/bubblesort/bubblesort.go → src/go/bubble_sort.go

@@ -1,7 +1,9 @@
-package bubblesort
+package main
 
-// Bubble Sort tradicional
-func BubbleSort(slice []int) {
+import "fmt"
+
+// Iterativo
+func BubbleSortIterativo(slice []int) {
 	for indice1 := len(slice) - 1; indice1 > 0; indice1-- {
 		for indice2 := 0; indice2 < indice1; indice2++ {
 			if slice[indice2] > slice[indice2+1] {
@@ -11,8 +13,8 @@ func BubbleSort(slice []int) {
 	}
 }
 
-// Bubble Sort recursivo
-func Recursivo(slice []int, tamanho int) {
+// Recursivo
+func BubbleSortRecursivo(slice []int, tamanho int) {
 	trocas := 0
 	for indice := 0; indice < tamanho-1; indice++ {
 		if slice[indice] > slice[indice+1] {
@@ -21,6 +23,13 @@ func Recursivo(slice []int, tamanho int) {
 		}
 	}
 	if trocas != 0 {
-		Recursivo(slice, tamanho-1)
+		BubbleSortRecursivo(slice, tamanho-1)
 	}
 }
+
+func main() {
+	slice := []int{5, 2, 1, 6, 9, 8, 7, 3, 4}
+	fmt.Println("Slice:", slice)
+	BubbleSortIterativo(slice)
+	fmt.Println("BubbleSort:", slice)
+}

src/go/busca_binaria.go

@@ -0,0 +1,29 @@
+package main
+
+import "fmt"
+
+func BinarySearch(seq []int, element, start, end int) int {
+	index := (start + end) / 2
+
+	if index < len(seq) && seq[index] == element {
+		return index
+	}
+
+	if start != end {
+		if seq[index] < element {
+			return BinarySearch(seq, element, index+1, end)
+		}
+
+		return BinarySearch(seq, element, start, index-1)
+	}
+
+	return -1
+}
+
+func main() {
+  value := 7
+	slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	fmt.Println("Slice:", slice)
+  index := BinarySearch(slice, value, 0, len(slice))
+	fmt.Println("Value", value, "found in index:", index)
+}

src/go/caixeiroviajante/caixeiroviajante.go → src/go/caixeiro_viajante.go

@@ -36,7 +36,7 @@
  * 0 - 3 - 5 - 1 - 2 - 4 - 0: 13
  */
 
-package caixeiroviajante
+package main
 
 import "fmt"
 
@@ -52,7 +52,7 @@ var visitados []bool    // Vertices visitados
 var valorMelhorSolucao int
 var valorSolucaoAtual int
 
-func caixeiroViajanteAux(x int) {
+func CaixeiroViajanteAux(x int) {
 
 	// Significa que ja nao eh mais a melhor solucao podemos parar por aqui
 	if valorSolucaoAtual > valorMelhorSolucao {
@@ -92,7 +92,7 @@ func caixeiroViajanteAux(x int) {
 			// Incrementa o total do caminho percorrido com base na posicao da matriz
 			valorSolucaoAtual += matrizDistancia[ultimo][i]
 			// Chama recursivamente para o proximo vertice
-			caixeiroViajanteAux(x + 1)
+			CaixeiroViajanteAux(x + 1)
 			// Se ainda nao terminou decrementa o valor da variabel que guarta o total do caminho
 			valorSolucaoAtual -= matrizDistancia[ultimo][i]
 			// Define como nao visitada para poder ser acessada por outro vertice
@@ -101,12 +101,12 @@ func caixeiroViajanteAux(x int) {
 	}
 }
 
-func caixeiroViajante(posicaoInicial int) {
+func CaixeiroViajante(posicaoInicial int) {
 	// Verifica se a posicao eh valida
 	if posicaoInicial < vertices {
 		visitados[posicaoInicial] = true // Marca o primeiro vertice como visitado
 		tempSolucao[0] = posicaoInicial  // Coloca a posicao inicial na primeira posicao da solucao temporaria
-		caixeiroViajanteAux(1)           // Chama o metodo auxiliar do caixeiro viajante
+		CaixeiroViajanteAux(1)           // Chama o metodo auxiliar do caixeiro viajante
 	} else {
 		fmt.Println("Vertice inicial invalid")
 	}
@@ -140,12 +140,11 @@ func inicia() {
 	matrizDistancia = append(matrizDistancia, linha5)
 }
 
-// Funcao que roda o exemplo do caixeiro viajante
-func Run() {
+func main() {
 	inicia()
-	caixeiroViajante(0)
+	CaixeiroViajante(0)
 
-	fmt.Println("\nCaixeiro Viajante")
+	fmt.Println("Caixeiro Viajante")
 	fmt.Println("Caminho minimo:", valorMelhorSolucao)
 	for i := 0; i < vertices; i++ {
 		fmt.Print(melhorSolucao[i], ", ")

src/go/calculatepi/calculatepi.go → src/go/calculate_pi.go

@@ -1,4 +1,6 @@
-package calculatepi
+package main
+
+import "fmt"
 
 func CalculatePi(terms []int) []float64 {
 	var denominator float64
@@ -16,3 +18,9 @@ func CalculatePi(terms []int) []float64 {
 	}
 	return pi
 }
+
+func main() {
+  slice := []int{10, 1000, 100000, 10000000}
+	fmt.Println("Slice:", slice)
+	fmt.Println("Pi:", CalculatePi(slice))
+}

src/go/cocktailsort/cocktailsort.go → src/go/cocktail_sort.go

@@ -1,4 +1,6 @@
-package cocktailsort
+package main
+
+import "fmt"
 
 func CocktailSort(slice []int) {
 
@@ -30,3 +32,10 @@ func CocktailSort(slice []int) {
 		begining++
 	}
 }
+
+func main() {
+  slice := []int{1, 5, 8, 3, 7, 4, 9, 6, 2}
+	fmt.Println("Slice:", slice)
+	CocktailSort(slice)
+	fmt.Println("CocktailSort:", slice)
+}

src/go/combsort/combsort.go → src/go/comb_sort.go

@@ -1,4 +1,6 @@
-package combsort
+package main
+
+import "fmt"
 
 func CombSort(slice []int) {
 	shrinkFactor := 1.247330950103979
@@ -23,3 +25,10 @@ func CombSort(slice []int) {
 		}
 	}
 }
+
+func main() {
+  slice := []int{6, 5, 8, 7, 3, 4, 2, 1, 9}
+	fmt.Println("Slice:", slice)
+	CombSort(slice)
+	fmt.Println("CombSort:", slice)
+}

src/go/countingsort/countingsort.go → src/go/counting_sort.go

@@ -1,4 +1,6 @@
-package countingsort
+package main
+
+import "fmt"
 
 func CountingSort(slice []int) {
 	if len(slice) < 1 {
@@ -34,3 +36,10 @@ func CountingSort(slice []int) {
 		slice[index] = temp2[index]
 	}
 }
+
+func main() {
+  slice := []int{9, 5, 8, 7, 3, 2, 1, 6, 4}
+	fmt.Println("Slice:", slice)
+	CountingSort(slice)
+	fmt.Println("CountingSort:", slice)
+}

src/go/dijkstra/dijkstra.go → src/go/dijkstra.go

@@ -36,9 +36,7 @@
 
 package main
 
-import (
-	"fmt"
-)
+import "fmt"
 
 var nroVertices = 5
 

src/go/exponenciacao/exponenciacao.go → src/go/exponenciacao.go

@@ -1,8 +1,14 @@
-package exponenciacao
+package main
+
+import "fmt"
 
 func Exponenciacao(base int, expoente int) int {
 	for index := 0; index < (expoente - 1); index++ {
 		base *= expoente
 	}
 	return base
 }
+
+func main() {
+	fmt.Println("Exponenciacao:", Exponenciacao(5, 5))
+}

src/go/fatorial/fatorial.go → src/go/fatorial.go

@@ -1,8 +1,14 @@
-package fatorial
+package main
+
+import "fmt"
 
 func Fatorial(value int) int {
 	if value == 1 {
 		return 1
 	}
 	return value * Fatorial(value-1)
 }
+
+func main() {
+	fmt.Println("Fatorial:", Fatorial(6))
+}

src/go/fibonacci/fibonacci.go → src/go/fibonacci.go

@@ -1,8 +1,14 @@
-package fibonacci
+package main
+
+import "fmt"
 
 func Fibonacci(value int) int {
 	if value <= 1 {
 		return 1
 	}
 	return Fibonacci(value-1) + Fibonacci(value-2)
 }
+
+func main() {
+	fmt.Println("Fibonacci:", Fibonacci(9))
+}

src/go/floyd_warshall/floyd_warshall.go → src/go/floyd_warshall.go

@@ -1,4 +1,6 @@
-package floydwarshall
+package main
+
+import "fmt"
 
 // Grafos - Algoritmo de Floyd-Warshall em GO
 // Douglas Oliveira - 2022
@@ -30,3 +32,14 @@ func FloydWarshall(graph [][]int) [][]int {
 
 	return dist
 }
+
+var graph = [][]int{
+	{0, 5, 999, 10},
+	{999, 0, 3, 999},
+	{999, 999, 0, 1},
+	{999, 999, 999, 0},
+}
+
+func main() {
+	fmt.Println(FloydWarshall(graph))
+}

src/go/gnomesort/gnomesort.go → src/go/gnome_sort.go

@@ -1,4 +1,6 @@
-package gnomesort
+package main
+
+import "fmt"
 
 func GnomeSort(slice []int) {
 	pivot := 0
@@ -14,3 +16,10 @@ func GnomeSort(slice []int) {
 		pivot++
 	}
 }
+
+func main() {
+  slice := []int{2, 5, 1, 7, 4, 9, 8, 6, 3}
+	fmt.Println("Slice:", slice)
+	GnomeSort(slice)
+	fmt.Println("GnomeSort:", slice)
+}

src/go/hanoi/hanoi.go → src/go/hanoi.go

@@ -1,4 +1,4 @@
-package hanoi
+package main
 
 import "fmt"
 
@@ -11,3 +11,8 @@ func Hanoi(pino0 int, pino2 int, pino1 int, numero int) {
 		Hanoi(pino1, pino2, pino0, numero-1)
 	}
 }
+
+func main() {
+	fmt.Println("Torre de Hanoi:")
+  Hanoi(0, 2, 1, 3)
+}

src/go/heapsort/heapsort.go → src/go/heap_sort.go

@@ -1,4 +1,6 @@
-package heapsort
+package main
+
+import "fmt"
 
 func HeapSort1(slice []int) {
 
@@ -78,3 +80,15 @@ func clearTree(slice []int, length int, position int) {
 		clearTree(slice, length, largest)
 	}
 }
+
+func main() {
+  slice := []int{6, 8, 7, 9, 1, 5, 4, 2, 3}
+	fmt.Println("Slice:", slice)
+	HeapSort1(slice)
+	fmt.Println("HeapSort1:", slice)
+
+	slice = []int{6, 8, 7, 9, 1, 5, 4, 2, 3}
+	fmt.Println("Slice:", slice)
+	HeapSort2(slice)
+	fmt.Println("HeapSort2:", slice)
+}

src/go/insertionsort/insertionsort.go → src/go/insertion_sort.go

@@ -1,4 +1,6 @@
-package insertionsort
+package main
+
+import "fmt"
 
 func InsertionSort(slice []int) {
 	for index1 := 1; index1 < len(slice); index1++ {
@@ -13,3 +15,10 @@ func InsertionSort(slice []int) {
 		slice[index2+1] = currentValue
 	}
 }
+
+func main() {
+  slice := []int{9, 8, 7, 5, 1, 2, 4, 3, 6}
+	fmt.Println("Slice:", slice)
+	InsertionSort(slice)
+	fmt.Println("InsertionSort:", slice)
+}