Golang on I'm Gilmar Soares

Recursion and Quick Sort

Mon, 16 Dec 2024 16:18:30 -0300

In this post, I can explain two important concepts in computer science: recursion and quick sort. I need to explain recursion before I can explain quick sort because quick sort use recursion to sort the array.

Recursion

Recursion is a technique in computer science where a function calls itself. This technique is used to solve problems that can be broken down into smaller problems of the same type.

Here is an example of a recursive function that calculates the factorial of a number:


func factorial(n int) int {
	if n == 0 {
		return 1
	}
	return n * factorial(n-1)
}

In this example, the factorial function calls itself with a smaller number until the base case is reached. The base case is when n is equal to 0, in which case the function returns 1.

It is important to reinforce the base case, without it we would have an infinite loop, and you can test it with the code below


func factorial(n int) int {
	return n * factorial(n-1)
}

You can use ctrl+c to cancel.

Quick Sort

Anyway, now let’s talk about quick sort.

Quick sort is a sorting algorithm that uses recursion to sort an array. Quick sort use the Divide and Conquer strategy to sort the array. But what would be Divide and Conquer strategy?

Divide and Conquer is a technique in computer science where a problem is divided into smaller problems of the same type.

For example, let’s say we have an array:

arr := []int{100, 5, 3, 6, 2, 10}

First, we get the pivot element, which is the first element in the array:


pivot := arr[0]

With the pivot element, we divide the array into two arrays: one with elements smaller than the pivot and another with elements greater than the pivot:


var left []int
var right []int

for i := 1; i < len(arr); i++ {
	if arr[i] < pivot {
		left = append(left, arr[i])
	} else {
		right = append(right, arr[i])
	}
}

And here, we use recursion to sort the left and right arrays:


left = quickSort(left)
right = quickSort(right)

Finally, we concatenate the left array, the pivot element, and the right array:


return append(append(left, pivot), right...)

I purposely left it for last to say that we cannot forget the base case.

The base case is when the array has only one element, in which case we return the array:


if len(arr) < 2 {
	return arr
}

When the array has only one element, we return the array because it is already sorted.

Now we can create the quickSort function:


func quickSort(arr []int) []int {
	if len(arr) < 2 {
		return arr
	}

	pivot := arr[0]

	var left []int
	var right []int

	for i := 1; i < len(arr); i++ {
		if arr[i] < pivot {
			left = append(left, arr[i])
		} else {
			right = append(right, arr[i])
		}
	}

	left = quickSort(left)
	right = quickSort(right)

	return append(append(left, pivot), right...)
}

Now we can test the function:


func main() {
	arr := []int{100, 5, 3, 6, 2, 10}
	fmt.Println(quickSort(arr))
}

When you run the code above, you will see the sorted array:


[2 3 5 6 10 100]

That’s it! I hope you enjoyed this post. If you have any questions, please let me know in the comments below.

Conclusion

In this post, I explained two important concepts in computer science: recursion and quick sort. I hope I managed to explain it in a simple way, so that most people can understand, especially those who have difficulty or even fear of algorithms!

Hugs.

Selection Sort

Thu, 05 Dec 2024 18:46:28 -0300

Continuing my study of algorithms, I can now explain the selection sort algorithm to you.

Selection sort is a simple algorithm. It works by finding the smallest element in an array, adding it to a new array, and removing it from the original array. This process is repeated until the original array is empty. Once the original array is empty, the new array will contain the elements in sorted order.

In this example, I am not focusing on performance but rather on the simplicity of the algorithm.

Here is the array we will use for our example:

arr := []int{100, 5, 3, 6, 2, 10}

For the next step I create the function that receive this arr and return the sorted array:

func orderIntArray(arr []int) []int {
	var result []int
	var min int

	for len(arr) > 0 {
		min = getSmallerItem(arr)
		result = append(result, arr[min])
		arr = remove(arr, min)
	}

	return result
}

The getSmallerItem function is responsible to get the index of the smallest element in the array:

func getSmallerItem(arr []int) int {
	var min int = arr[0]
	var pos int

	for i := 1; i < len(arr); i++ {
		if arr[i] < min {
			min = arr[i]
			pos = i
		}
	}
	return pos
}

The getSmallerItem function compare the element in the array with the min variable, if the element is smaller than the min variable, the min variable will be updated with the element value and the pos variable will be updated with the index of the element. When the loop finish, the pos variable will be returned.

The remove function is responsible to remove the element from the array:

func remove(s []int, i int) []int {
	s[i] = s[len(s)-1]
	return s[:len(s)-1]
}

The remove function receive the array and the index of the element that will be removed.

Now we can test the function:

func main() {
	arr := []int{100, 5, 3, 6, 2, 10}
	result := orderIntArray(arr)
	fmt.Println(result) // return is [2 3 5 6 10 100]
}

This algorithm is not efficient, but is a good example to understand the selection sort algorithm.

I hope you enjoy this post, see you in the next one!

Explaining Binary Search in a Simple Way

Thu, 21 Nov 2024 16:15:51 -0300

Today I try to explain binary search in a simple way. Binary search is a search algorithm that finds the position of a target value within a sorted array. Sorted array is an important point here.

To explain binary search, we need a array to exemplify.

arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

In this array, we have 10 elements, from 1 to 10. Binary search works by comparing the target value to the middle element of the array.

For example, if we want to find the number 5 in the array, we start by comparing 5 to the middle element of the array, which is 6.

Next step is to compare 5 to 6. If 5 is less than 6, we can discard the right half of the array. The new array is now:

arr := []int{1, 2, 3, 4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 3.

Next step is to compare 5 to 3. If 5 is greater than 3, we can discard the left half of the array. The new array is now:

arr := []int{4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 5. And we found the number 5 in the array.

In this simple example we found the number 5 in 3 steps. This is my simple explanation of binary search.

Now I can implement the binary search algorithm in Go.

package main

func search(arr []int, searchItem int) int {
	minus := 0
	max := len(arr) - 1

	for minus <= max {
		middle := (minus + max) / 2
		tryFind := arr[middle]
		if tryFind == searchItem {
			return middle
		}
		if tryFind > searchItem {
			max = middle - 1
		} else {
			minus = middle + 1
		}
	}

	return -1
}

Now I can use the search function to find the number 5 in the array.

func main() {
	arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	searchItem := 80
	pos := search(arr, searchItem)
	var message string
	message = fmt.Sprintf("Find item %d in %d position", searchItem, searchItem)
	if pos == -1 {
		message = fmt.Sprintf("Item %d not found", searchItem)
	}
	fmt.Println(message)
}

This is the output of the program:

Item 80 not found

This algorithm reminds me of a phrase I often hear: ‘divide and conquer! I hope this post, along with the others, helps you in your studies and, more importantly, helps you understand that the best path is always through deep knowledge!

See you next time! Thanks for reading my blog. Hugs!

My Strategy for Studying LeetCode

Thu, 07 Nov 2024 10:58:22 -0300

First of all, don’t put pressure on yourself. Focus on the long term by doing a little every day or fitting it into your schedule and sticking to the plan, okay?

With that in mind, here is my strategy for studying Leetcode.

1. Start with the basics

At the moment, I’m studying the basics of algorithms, focusing on string manipulation on Leetcode by filtering for easy problems. In this post, I’ll walk you through the 125. Valid Palindrome exercise on Leetcode.

2. Study the problem

At this point, you should read and understand the problem. You can view the problem here.

3. Write the code

Now, I’ll start by explaining how I study on Leetcode. First, I focus on simply solving the problem without worrying about finding the most optimized solution. The goal is just to get a working solution, okay?

In this example, I start by solving the problem with the following code:

func isPalindrome(s string) bool {
    var reversed string
	var newS string

	for _, v := range s {
		if unicode.IsLetter(v) || unicode.IsDigit(v) {
			reversed += strings.ToLower(string(v))
			newS = strings.ToLower(string(v)) + newS
		}
	}
	return reversed == newS
}

I noticed that this solution takes 1067 ms and uses 80.2 MB of memory. At this point, I start looking for ways to improve it.

4. Optimize the code

Here, I work on improving the solution to make it faster and more memory-efficient:

func isPalindrome(s string) bool {
    var stringReversed string
	var sNew string
	lenString := len(s)
	count := 0

	for count != lenString {
		if unicode.IsLetter(rune(s[count])) || unicode.IsDigit(rune(s[count])) {
			sNew += strings.ToLower(string(s[count]))
			stringReversed = strings.ToLower(string(s[count])) + stringReversed
		}
		count++
	}

	return sNew == stringReversed
}

I observed that the updated solution now takes 976 ms and uses 48.5 MB of memory. At this point, I’ll continue refining it to see if further improvements are possible.

5. Last improve solution

Then I realized that to validate a palindrome, I don’t need to store anything in memory; I only need to compare the characters at specific positions. With this approach, my solution improved significantly.

func isPalindrome(s string) bool {
    for i, j := 0, len(s)-1; i < j; {
		if !isAlphaNumeric(s[i]) {
			i++
		} else if !isAlphaNumeric(s[j]) {
			j--
		} else if strings.ToLower(string(s[i])) != strings.ToLower(string(s[j])) {
			return false
		} else {
			i++
			j--
		}
	}
	return true
}


func isAlphaNumeric(s byte) bool {
	return (s >= 'a' && s <= 'z') || (s >= 'A' && s <= 'Z') || (s >= '0' && s <= '9')
}

I saw that this optimized solution now takes 0 ms and uses only 4.5 MB of memory. At this point, I’ll see if there’s any further room for improvement, though the solution is already very efficient.

Here a printscreen of the solutions on Leetcode:

6. Conclusion

In these steps, I’ve shown you my approach to studying on Leetcode:

First, I solve the problem without worrying about finding the optimal solution—just focusing on getting it to work. Next, I try to refine the solution to use less memory and run faster. Finally, I think about further simplifications. For example, to validate a palindrome, I realized I don’t need to store anything in memory; I only need to compare specific character positions. This approach greatly improved my solution. This method has helped me write better code in my daily work, and I hope it’s helpful for you too!

Happy coding! 🚀

How to Publish Your Go Library on Pkg Go

Thu, 31 Oct 2024 14:38:09 -0300

Continue my way to learn Go in a deep way, today I’ll show to you how to publish you library in Pkg.Go

First of all, you need to have a Go library in you Github account or any other Git repository. In this example, I’ll use a simple library that I created to show how to publish it.

The library is valid-brazilian-cnpj. In Brazil we have a document called CNPJ, the next year the rules to validate it will change, so I created this library to help me to validate CNPJ.

How I create this library is not the focus of this post, but if you want to see the code, you can access the repository.

To publish your library in Pkg.Go, you need to create a release in your repository.

First Step - run go mod tidy

The first step is to run go mod tidy to make sure that all dependencies are in the go.mod file.

go mod tidy

Second Step - Run tests

The second step is to run the tests to make sure that everything is working as expected.

go test -v

This command will run all tests in the library and show the results.

Third Step - Create a tag

The third step is to create a tag in your repository.

git tag v0.1.0
git push origin v0.1.0

This command will create a tag called v0.1.0 and push it to the repository.

Fourth Step - Push this to Pkg.Go

GOPROXY=proxy.golang.org go list -m github.com/linuxsoares/valid-brazilian-cnpj@v0.1.1

Explaining the command:

GOPROXY=proxy.golang.org: This is the URL of the Pkg.Go
go list -m github.com/linuxsoares/valid-brazilian-cnpj@v0.1.1: This command will push the library to Pkg.Go

After running this command, you can access the library in Pkg.Go.

Conclusion

In this post, I showed you how to publish your library in Pkg.Go. This is a simple process, but it’s important to follow the steps to make sure that everything is working as expected.

I hope you enjoyed this post and see you in the next one.

Happy coding!

How to Document Your Go API

Thu, 24 Oct 2024 16:22:02 -0300

Today, I’m writing a technical post about API documentation in Go. I hope you find it useful!

First, we’ll create a simple CRUD API using Go and the Gin framework. Let’s get started!

package main

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

var users = []User{
	{ID: 1, Name: "John"},
	{ID: 2, Name: "Doe"},
}

func main() {
	r := gin.Default()

	// Change to default is /api/v1
	api := r.RouterGroup.Group("/api/v1")
	{
		api.GET("/users", getUsers)

		api.GET("/users/:id", getUser)

		api.POST("/users", createUser)

		api.PUT("/users", editUser)

		api.DELETE("/users/:id", removeUser)
	}

	r.Run(":8080")
}

func getUsers(c *gin.Context) {
	c.JSON(http.StatusOK, users)
}

func getUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	userFound, _ := findUserByID(users, id)
	c.JSON(http.StatusOK, userFound)
}

func createUser(c *gin.Context) {
	var user User
	c.BindJSON(&user)
	users = append(users, user)
	c.JSON(http.StatusCreated, user)
}

func editUser(c *gin.Context) {
	var user User
	c.BindJSON(&user)
	putUser(users, user)
	c.JSON(http.StatusOK, user)
}

func removeUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	deleteUserByID(users, id)
	c.JSON(http.StatusOK, nil)
}

func findUserByID(users []User, id int) (*User, bool) {
	for _, user := range users {
		if user.ID == id {
			return &user, true
		}
	}
	return nil, false
}

func deleteUserByID(users []User, id int) []User {
	newUsers := []User{}
	for _, user := range users {
		if user.ID != id {
			newUsers = append(newUsers, user)
		}
	}
	return newUsers
}

func putUser(users []User, newUser User) []User {
	for i := range users {
		if users[i].ID == newUser.ID {
			// Update the existing user
			users[i] = newUser
			return users
		}
	}
	// Add new user if not found
	return append(users, newUser)
}

Now that we have a simple CRUD API in Go, let’s document it.

Note: In this example, I didn’t use the best approach for a CRUD. Instead, I defined a User struct to represent a user and used a slice to store the users. In a real-world project, you should use a database to store the data. Additionally, while I used basic functions to manipulate the data, it’s recommended to follow the repository pattern in production code.

With that out of the way, let’s move on to creating our documentation.

First, we’ll create a Makefile to simplify managing the app.

run:
    go run main.go

build-swagger:
	@go run github.com/swaggo/swag/cmd/swag@latest init -g main.go -o docs

Now, we need to install some dependencies to use Swag.

    go get -u github.com/swaggo/gin-swagger
    go get -u github.com/swaggo/files

Now, I need to add some descriptions using code comments in the main function.

// @BasePath /api/v1

// PingExample godoc
// @Summary ping example
// @Schemes
// @Description do ping
func main...

We need to add a route to serve the Swagger documentation.

r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))

Now, we need to run a command to generate the documentation.

make build-swagger

With all the Swag configurations complete, we can run the app and access the documentation in the browser.

make run

Now, access the URL http://localhost:8080/swagger/index.html to view the documentation.

Below is an example of how to document a CRUD:

GET USERS:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Show a Users list
// @Description  get users
// @Tags         getUsers
// @Accept       json
// @Produce      json
// @Router       /users  [get]

GET USER:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Show a Users list
// @Description  get users
// @Tags         getUsers
// @Accept       json
// @Produce      json
// @Param        id         path      string  true  "ID"
// @Router       /users/{id}  [get]

POST:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Create a User
// @Description  create users
// @Tags         createUser
// @Accept       json
// @Produce      json
// @Param user body User true "User to create"
// @Router 		/users [post]

PUT:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Edit a User
// @Description  edit users
// @Tags         editUser
// @Accept       json
// @Produce      json
// @Param user body User true "User to edit"
// @Router 		/users [put]

DELETE:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Remove a Users list
// @Description  delete user
// @Tags         removeUser
// @Accept       json
// @Produce      json
// @Param        id         path      string  true  "ID"
// @Router       /users/{id}  [delete]

With these comments in each function, we can generate the documentation using Swag.

The result is:

You can view the project in the repository.

Conclusion

In this article, we learned how to document a Go API using Swag. We started by creating a simple CRUD API in Go and then documented it using Swag. We also learned how to generate the documentation and view it in the browser.

Swag is a powerful tool that can help you document your Go APIs easily.

I hope you found this article helpful. If you have any questions or suggestions, feel free to send me a message in my social media accounts.

Thank you for reading!

Duck Typing in Go

Thu, 10 Oct 2024 13:46:16 -0300

Hello everyone!

As I mentioned in a previous post, I’m currently learning Go to use in some of my work projects. In this short post, I’ll explain how to use duck typing in Go, which was quite challenging for me when I first started learning the language.

To begin, let’s look at a simple example in Python:

class Duck:
    def quack(self):
        print("Quack, quack!")


class Person(Duck):
    pass


def quack(obj):
    obj.quack()

def main():
    donald = Duck()
    john = Person()

    quack(donald) -- Quack, quack!
    quack(john) -- Quack, quack!

In this somewhat quirky example, the Person class can “quack” like a Duck because it inherits from the Duck class. In Python, we don’t need to explicitly declare the type of the object in the function; we simply call the method we want to use.

Now, let’s see how to achieve something similar in Go:

package main

import "fmt"

type Dog interface {
	Bark()
}

type Cat interface {
	Meow()
}

type Shihtzu struct {
	Name string
}

type Chartreux struct {
	Name string
}

func (s Shihtzu) Bark() {
	message := fmt.Sprintf("Type: %T - My name is %s! Bark! Bark! Bark!", s, s.Name)
	fmt.Println(message)
}

func (c Chartreux) Meow() {
	message := fmt.Sprintf("Type: %T - My name is %s! Meow! Meow! Meow! ", c, c.Name)
	fmt.Println(message)
}

func main() {
	var dog Dog
	dog = Shihtzu{Name: "Puppy"}
	dog.Bark()

	var cat Cat
	cat = Chartreux{Name: "Kitty"}
	cat.Meow()
}

The example code above is in this repository on github.

In this Go example, we have two interfaces, Dog and Cat, and two structs, Shihtzu and Chartreux. The Dog interface defines a method Bark, while the Cat interface defines a method Meow. The structs Shihtzu and Chartreux implement the Bark and Meow methods, respectively. It’s important to note that although it’s not explicitly stated in the code, these structs are implementing the interfaces.

In Go, we implement an interface by simply defining the required methods, without needing to declare that the struct is explicitly implementing the interface.

In other words, we don’t need to state that Shihtzu is a Dog—we just need to implement the Bark method for the Shihtzu struct, and Go automatically understands that Shihtzu satisfies the Dog interface.

This is quite different from languages like Python or Java, but once you get the hang of it, it’s straightforward and easy to use.

I hope this post helps you better understand Go and how duck typing works in the language!

How Am I Learning Golang

Mon, 23 Sep 2024 17:34:27 -0300

In my work, I’ve started using Golang. I’m aware of AI tools like ChatGPT, which can help me complete tasks more efficiently. However, I really enjoy learning new technologies and am always open to new challenges.

In the past, I learned Scala, Python, and Java by reading books and practicing them daily. This time, I’m learning Golang using different approaches. I use Exercism to practice Golang, and now I’ll show you how to use it.

Step 1: Install Golang

First, you need to install Golang on your computer. You can download it from the official website. I won’t go into detail on how to install it because it’s straightforward. You can find the installation instructions here.

Once Golang is installed, you can check if it’s installed correctly by running this command:

go version

Step 2: Install Exercism

Now that Golang is installed, let’s install Exercism. You can find the installation instructions for your operating system on this page.

After installing Exercism, you can verify the installation by running:

exercism version

Step 3: Start Practicing

Now that everything is set up, you can start practicing Golang using Exercism. You can download exercises using the following command:

exercism download --exercise=<exercise-name> --track=go

For example:

exercism download --track=go --exercise=lasagna-master

This command will download the lasagna-master exercise for the Golang track.

After solving the exercise, you can submit it using:

exercism submit

This will upload your solution to Exercism, and you can see other people’s solutions as well.

Conclusion

This is how I’m learning Golang using Exercism. It’s a great platform to practice coding in different languages. Let’s try to solve some exercises in Golang or another language you prefer. I hope you enjoy the process!