Algorithms on I'm Gilmar Soares

How to Build a Hashmap

Thu, 06 Mar 2025 17:54:50 -0300

This week, we’re diving into one of the most powerful and fundamental data structures in programming: the Hash Map, often called a Hash Table or Dictionary. Hash maps are vital in nearly every language for quickly storing and retrieving data as key-value pairs.

What’s a Hash Map, Really?

A Hash Map is an array-based structure that gives you near-instant access to a stored value. It achieves this speed by using a special hash function to convert the key (e.g., a person’s name) into an index (a number) in the underlying array.

Think of it like a coat check:

The key is the unique ticket number you receive.

The hash function is the attendant who instantly knows which hook (the index) your coat is on.

The value is your coat itself.

For this simple example, we’ll use a fixed-size array of 10 slots. Important: To keep the code simple, this implementation does not handle collisions—a scenario where two different keys hash to the same index.

Python’s Built-in Hash Map: The dict

Before we build our own, let’s look at Python’s highly optimized, native implementation: the dict. Python

Create an empty dictionary

user_profile = {}

Store key-value pairs

user_profile["username"] = "coder_x"
user_profile["status"] = "online"

Retrieve a value instantly using its key

print(user_profile["username"]) # Output: coder_x

The final structure

print(user_profile) # Output: {'username': 'coder_x', 'status': 'online'}

Building a Custom HashMap Class

Now, let’s implement the core logic ourselves. Our HashMap will clearly show how keys are converted to array indices for storage and retrieval:

class HashMap:
    def __init__(self, size):
        self.size = size
        # Initialize the map: a list of 'None' values
        self.map = [None] * self.size

    def _hash(self, key):
        return hash(key) % self.size

    def set(self, key, value):
        index = self._hash(key)
        self.map[index] = value

    def get(self, key):
        index = self._hash(key)
        return self.map[index]

    def __str__(self):
        return str(self.map)

Practical Example and Indexing

Let’s see our custom HashMap in action and observe the indices it generates: Python

1. Initialize the hash map with 10 slots

contact_list = HashMap(10)

2. Store entries (Note: the hash index is calculated internally)

Key: “Alice” -> hash index: 3

contact_list.set("Alice", "555-0101")

Key: “Bob” -> hash index: 6

contact_list.set("Bob", "555-0202")

Key: “Charlie” -> hash index: 7

contact_list.set("Charlie", "555-0303")

3. Retrieve values using the original keys

print(f"Alice's Number: {contact_list.get('Alice')}")    # Output: 555-0101
print(f"Bob's Number: {contact_list.get('Bob')}")      # Output: 555-0202

4. View the underlying array after insertions

print("\n--- Map Array State ---")
print(str(contact_list))

Output (Indices 0-9):

[None, None, None, '555-0101', None, None, '555-0202', '555-0303', None, None]

This simplified model demonstrates the core principle: using a hash function to achieve fast O(1) (constant time) lookups by jumping directly to the correct array slot. Real-world hash maps add complexity to handle growth and collisions, but the foundational concept remains this efficient indexing strategy!

I hope this walkthrough has given you a solid understanding of how a Hash Map works at its core! While our example was simple, it demonstrates the efficient hashing and indexing that makes this data structure so powerful. Got a question or need clarification on collisions or resizing? Don’t hesitate to reach out in the comments below! Happy coding!

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! 🚀