Translate Go algorithm comments from Portuguese to English

Author: K11E3R

src/go/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "editor.formatOnSave": false,
+    "editor.formatOnSaveMode": "modificationsIfAvailable"
+}

src/go/bubble_sort.go

@@ -2,34 +2,34 @@ package main
 
 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] {
-				slice[indice2], slice[indice2+1] = slice[indice2+1], slice[indice2]
+// Iterative
+func BubbleSortIterative(slice []int) {
+	for index1 := len(slice) - 1; index1 > 0; index1-- {
+		for index2 := 0; index2 < index1; index2++ {
+			if slice[index2] > slice[index2+1] {
+				slice[index2], slice[index2+1] = slice[index2+1], slice[index2]
 			}
 		}
 	}
 }
 
-// Recursivo
-func BubbleSortRecursivo(slice []int, tamanho int) {
-	trocas := 0
-	for indice := 0; indice < tamanho-1; indice++ {
-		if slice[indice] > slice[indice+1] {
-			slice[indice], slice[indice+1] = slice[indice+1], slice[indice]
-			trocas++
+// Recursive
+func BubbleSortRecursive(slice []int, size int) {
+	swaps := 0
+	for index := 0; index < size-1; index++ {
+		if slice[index] > slice[index+1] {
+			slice[index], slice[index+1] = slice[index+1], slice[index]
+			swaps++
 		}
 	}
-	if trocas != 0 {
-		BubbleSortRecursivo(slice, tamanho-1)
+	if swaps != 0 {
+		BubbleSortRecursive(slice, size-1)
 	}
 }
 
 func main() {
 	slice := []int{5, 2, 1, 6, 9, 8, 7, 3, 4}
 	fmt.Println("Slice:", slice)
-	BubbleSortIterativo(slice)
+	BubbleSortIterative(slice)
 	fmt.Println("BubbleSort:", slice)
 }

src/go/cocktail_sort.go

@@ -5,12 +5,12 @@ import "fmt"
 func CocktailSort(slice []int) {
 
 	swapped := true
-	begining := 0
+	beginning := 0
 	ending := len(slice) - 1
 
-	for begining < ending && swapped {
+	for beginning < ending && swapped {
 
-		for index := begining; index < ending; index++ {
+		for index := beginning; index < ending; index++ {
 			if slice[index] > slice[index+1] {
 				slice[index], slice[index+1] = slice[index+1], slice[index]
 				swapped = true
@@ -21,15 +21,15 @@ func CocktailSort(slice []int) {
 
 		if swapped {
 			swapped = false
-			for index := ending; index > begining; index-- {
+			for index := ending; index > beginning; index-- {
 				if slice[index] < slice[index-1] {
 					slice[index], slice[index-1] = slice[index-1], slice[index]
 					swapped = true
 				}
 			}
 		}
 
-		begining++
+		beginning++
 	}
 }
 

src/go/dijkstra.go

@@ -1,12 +1,12 @@
 /*
-* Grafos - Algoritmo de Dijkstra em Go
-* Complexidade: Teta(n^2)
-* Implementação utilizando matriz de adjacências (matriz de distância)
+* Graphs - Dijkstra's Algorithm in Go
+* Complexity: Theta(n^2)
+* Implementation using adjacency matrix (distance matrix)
 *
-* 1 para todos - Arestas de pesos não negativo - Algoritmo guloso
-* Encontra o caminho mais curto de um vértice (inicio) a outro (destino)
+* One to all - Non-negative weighted edges - Greedy algorithm
+* Finds the shortest path from one vertex (start) to another (destination)
 *
-* Grafo com 5 vértices e 6 arestas
+* Graph with 5 vertices and 6 edges
 *
 *              6
 *   (0)-----------------(1)
@@ -19,18 +19,18 @@
 *      \              /
 *       -----(4)-----
 *
-* Matriz de Distância
+* Distance Matrix
 *    0   1   2   3   4
 * 0  0   6  10   -   -
 * 1  6   0   -   2   -
 * 2 10   -   0   1   3
 * 3  -   2   1   0   8
 * 4  -   -   3   8   0
 *
-* O objetivo é sair do ponto inicial (0) e chegar ao destino (4) pelo caminho mais curto
-* Resposta: (0)->(1)->(3)->(2)->(4) = 12
+* The goal is to start from the initial point (0) and reach the destination (4) by the shortest path
+* Answer: (0)->(1)->(3)->(2)->(4) = 12
 *
-* link Go PlayGround: https://play.golang.org/p/HyWAcYJ3qXY
+* Go PlayGround link: https://play.golang.org/p/HyWAcYJ3qXY
  */
 
 package main
@@ -39,56 +39,56 @@ import "fmt"
 
 var nroVertices = 5
 
-type Matriz [][]int
+type Matrix [][]int
 
 var maxInt = 4294967295
 
-// Algoritmo de Dijkstra recebe como parâmetro a matriz de distância e o número de vértices
-func Dijkstra(matriz Matriz, n int) {
-	visitados := make([]bool, n) // Variável que guarda true para os vértices visitados
-	// O valor 'i' do for abaixo não é utilizado, pois o for serve apenas para percorrer todo o número de colunas da matriz
-	for i := 1; i < n; i++ { // Começa em 1 pois não precisa comparar o vértice com ele mesmo
+// Dijkstra's Algorithm takes the distance matrix and the number of vertices as parameters
+func Dijkstra(matrix Matrix, n int) {
+	visited := make([]bool, n) // Variable that stores true for visited vertices
+	// The 'i' value in the for loop below is not used, as the loop is only used to iterate over the number of columns in the matrix
+	for i := 1; i < n; i++ { // Starts at 1 because there is no need to compare the vertex with itself
 
-		min := -1          // Variável que guarda a posição do menor valor, inicia em -1 pois é uma posição inválida
-		minValor := maxInt // Variável que guarda o menor valor encontrado, inicia com 'infinito', assim, sempre na primeira passada o valor será menor que esta variável
+		min := -1          // Variable that stores the position of the smallest value, starts at -1 because it is an invalid position
+		minValue := maxInt // Variable that stores the smallest value found, starts with 'infinity', so in the first pass the value will be smaller than this variable
 
-		// For que percorre todas as linhas na coluna [0]
+		// For loop that iterates over all rows in column [0]
 		for j := 1; j < n; j++ {
-			// Se o vertice ainda não foi visitado e o valor for menor que o 'MinValor'
-			if !visitados[j] && matriz[j][0] < minValor {
-				min = j                 // Guarda a posição do menor
-				minValor = matriz[j][0] // Guarda o menor valor
+			// If the vertex has not been visited yet and the value is smaller than 'minValue'
+			if !visited[j] && matrix[j][0] < minValue {
+				min = j                 // Stores the position of the smallest value
+				minValue = matrix[j][0] // Stores the smallest value
 			}
 		}
 
-		visitados[min] = true // Marca o valor a posição do minimo como visitado
+		visited[min] = true // Marks the position of the minimum as visited
 
-		// For de 1 até n
+		// For loop from 1 to n
 		for j := 1; j < n; j++ {
-			// Se o valor da coluna [0] + o valor da coluna que está passando for menor que o valor da linha que está passando e coluna [0]
-			// Atualiza a primeira coluna da matriz, que será utilizado para as próximas iterações
-			if (matriz[min][0] + matriz[min][j]) < matriz[j][0] {
-				matriz[j][0] = matriz[min][0] + matriz[min][j]
+			// If the value of column [0] + the value of the current column is smaller than the value of the current row and column [0]
+			// Updates the first column of the matrix, which will be used for the next iterations
+			if (matrix[min][0] + matrix[min][j]) < matrix[j][0] {
+				matrix[j][0] = matrix[min][0] + matrix[min][j]
 			}
 		}
 	}
 }
 
 func main() {
-	matriz := Matriz{
+	matrix := Matrix{
 		{0, 6, 10, maxInt, maxInt},
 		{6, 0, maxInt, 2, maxInt},
 		{10, maxInt, 0, 1, 3},
 		{maxInt, 2, 1, 0, 8},
 		{maxInt, maxInt, 3, 8, 0},
 	}
 
-	Dijkstra(matriz, nroVertices)
+	Dijkstra(matrix, nroVertices)
 
-	fmt.Printf("Total caminho mais curto do vertice 0 ao 4: %v\n\n", matriz[4][0]) // Caminho total mais curto
+	fmt.Printf("Total shortest path from vertex 0 to 4: %v\n\n", matrix[4][0]) // Total shortest path
 
-	// Da print na matriz com os valores atualizados
-	fmt.Println("Matriz:")
+	// Prints the matrix with the updated values
+	fmt.Println("Matrix:")
 
 	fmt.Printf("-  |	|v0	|v1	|v2	|v3	|v4\n")
 	fmt.Println("_____________________________________________")
@@ -100,10 +100,10 @@ func main() {
 				fmt.Printf("v%v |", i)
 			}
 
-			if matriz[i][j] == maxInt {
+			if matrix[i][j] == maxInt {
 				fmt.Printf("	|inf")
 			} else {
-				fmt.Printf("	|%v", matriz[i][j])
+				fmt.Printf("	|%v", matrix[i][j])
 			}
 		}
 		fmt.Println()

src/go/exponentiation.go

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

src/go/factorial.go

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

src/go/floyd_warshall.go

@@ -2,25 +2,25 @@ package main
 
 import "fmt"
 
-// Grafos - Algoritmo de Floyd-Warshall em GO
-// link Go PlayGround: https://go.dev/play/p/tIRTHkNf7Fz
+// Graphs - Floyd-Warshall Algorithm in GO
+// Go PlayGround link: https://go.dev/play/p/tIRTHkNf7Fz
 
-// Algoritmo de Floyd-Warshall
+// Floyd-Warshall Algorithm
 func FloydWarshall(graph [][]int) [][]int {
-	// Inicializa a matriz de distancias
+	// Initialize the distance matrix
 	dist := make([][]int, len(graph))
 	for i := range dist {
 		dist[i] = make([]int, len(graph))
 		copy(dist[i], graph[i])
 	}
 
-	// Percorre os vértices
+	// Traverse the vertices
 	for k := 0; k < len(graph); k++ {
-		// Percorre as linhas
+		// Traverse the rows
 		for i := 0; i < len(graph); i++ {
-			// Percorre as colunas
+			// Traverse the columns
 			for j := 0; j < len(graph); j++ {
-				// Verifica se o caminho passando pelo vértice k é menor
+				// Check if the path passing through vertex k is shorter
 				if dist[i][k]+dist[k][j] < dist[i][j] {
 					dist[i][j] = dist[i][k] + dist[k][j]
 				}

src/go/min_max_recursive.go

@@ -2,14 +2,14 @@ package main
 
 import "fmt"
 
-func MaximoDivisaoEConquista(vetor []int, inicio int, fim int) int {
-	if inicio == fim {
-		return vetor[inicio]
+func MaxDivideAndConquer(array []int, start int, end int) int {
+	if start == end {
+		return array[start]
 	}
 
-	meio := (inicio + fim) / 2
-	aux1 := MaximoDivisaoEConquista(vetor, inicio, meio)
-	aux2 := MaximoDivisaoEConquista(vetor, meio+1, fim)
+	middle := (start + end) / 2
+	aux1 := MaxDivideAndConquer(array, start, middle)
+	aux2 := MaxDivideAndConquer(array, middle+1, end)
 
 	if aux1 > aux2 {
 		return aux1
@@ -18,22 +18,22 @@ func MaximoDivisaoEConquista(vetor []int, inicio int, fim int) int {
 	return aux2
 }
 
-func MinimoMaximoRecursivo(vetor []int, minimo int, maximo int, indice int) {
-	if vetor[indice] < minimo {
-		minimo = vetor[indice]
+func RecursiveMinMax(array []int, min int, max int, index int) {
+	if array[index] < min {
+		min = array[index]
 	}
-	if vetor[indice] > maximo {
-		maximo = vetor[indice]
+	if array[index] > max {
+		max = array[index]
 	}
-	if indice < len(vetor)-1 {
-		MinimoMaximoRecursivo(vetor, minimo, maximo, indice+1)
+	if index < len(array)-1 {
+		RecursiveMinMax(array, min, max, index+1)
 	} else {
-		fmt.Println("Minimo:", minimo)
-		fmt.Println("Maximo:", maximo)
+		fmt.Println("Minimum:", min)
+		fmt.Println("Maximum:", max)
 	}
 }
 
 func main() {
 	slice := []int{2, 3, 9, 1, 6, 8, 5}
-	MinimoMaximoRecursivo(slice, 999, 0, 0)
+	RecursiveMinMax(slice, 999, 0, 0)
 }