6. Nested

Maps can contain maps, creating a nested structure. For example:

map[string]map[string]int
map[rune]map[string]int
map[int]map[string]map[string]int

Assignment

Because Textio is a glorified customer database, we have a lot of internal logic for sorting and dealing with customer names.

Complete the getNameCounts function. It takes a slice of strings names and returns a nested map. The parent map's keys are all the unique first characters (see https://go.dev/blog/strings) of the names, the nested maps keys are all the names themselves, and the value is the count of each name.

For example:

billy
billy
bob
joe

Creates the following nested map:

b: {
    billy: 2,
    bob: 1
},
j: {
    joe: 1
}

• The test suite is not printing the map you're returning directly, but instead checking a few specific keys.

• You can convert a string into a slice of runes as follows:

runes := []rune(word)

Solution

package main

func getNameCounts(names []string) map[rune]map[string]int {
	result := make(map[rune]map[string]int)

	for _, name := range names {
		firstChar := []rune(name)[0]

		if result[firstChar] == nil {
			result[firstChar] = make(map[string]int)
		}
		result[firstChar][name]++
	}

	return result
}

You need to:

1

Group names by their first letter

Use a map keyed by rune (the first character) whose values are maps from the full name to counts.

2

Count how many times each name appears

Increment the nested map's count for each name encountered.

3

Return a nested map structure

Return map[rune]map[string]int with counts grouped by first rune.

Breaking It Down

Step 1: Create the Outer Map

result := make(map[rune]map[string]int)

This creates the structure:

result = {
    'b': map[string]int{},
    'j': map[string]int{},
}

Step 2: Loop Through Names

for _, name := range names {
    // process each name
}

Step 3: Get the First Character

firstChar := []rune(name)[0]

This converts the string to a slice of runes and gets the first one.

Example:

• "billy" → []rune{'b', 'i', 'l', 'l', 'y'} → first is 'b'

Step 4: Check If Inner Map Exists

Before you can increment a count, you need to make sure the inner map exists:

if result[firstChar] == nil {
    result[firstChar] = make(map[string]int)
}

If the inner map doesn't exist yet, create it.

Step 5: Increment the Count

result[firstChar][name]++

This increments the count for that specific name.

Complete Solution (again for convenience)

package main

func getNameCounts(names []string) map[rune]map[string]int {
    result := make(map[rune]map[string]int)
    
    for _, name := range names {
        // Get the first character as a rune
        firstChar := []rune(name)[0]
        
        // Check if the inner map exists, create it if not
        if result[firstChar] == nil {
            result[firstChar] = make(map[string]int)
        }
        
        // Increment the count for this name
        result[firstChar][name]++
    }
    
    return result
}

Step-by-Step Trace

Let's trace through with:

names = []string{"billy", "billy", "bob", "joe"}

1

Start

result = {}

2

Iteration 1: name = "billy"

firstChar = 'b'
result['b'] == nil  // true, create inner map
result['b'] = make(map[string]int)  // result = {'b': {}}
result['b']["billy"]++  // result = {'b': {"billy": 1}}

3

Iteration 2: name = "billy"

firstChar = 'b'
result['b'] == nil  // false, inner map exists
result['b']["billy"]++  // result = {'b': {"billy": 2}}

4

Iteration 3: name = "bob"

firstChar = 'b'
result['b'] == nil  // false, inner map exists
result['b']["bob"]++  // result = {'b': {"billy": 2, "bob": 1}}

5

Iteration 4: name = "joe"

firstChar = 'j'
result['j'] == nil  // true, create inner map
result['j'] = make(map[string]int)
result['j']["joe"]++  // result = {'b': {"billy": 2, "bob": 1}, 'j': {"joe": 1}}

Final result:

{
    'b': {"billy": 2, "bob": 1},
    'j': {"joe": 1}
}

Why Check if result[firstChar] == nil?

When you access a map key that doesn't exist:

result['b']  // Returns nil if 'b' doesn't exist yet

You can't index a nil map:

result['b']["billy"]++  // ❌ PANIC! Can't index nil map

So you must create the inner map first:

if result['b'] == nil {
    result['b'] = make(map[string]int)  // Create the inner map
}
result['b']["billy"]++  // ✓ Now it works

Alternative: Check with Two-Value Lookup

You could also write it like this:

func getNameCounts(names []string) map[rune]map[string]int {
    result := make(map[rune]map[string]int)
    
    for _, name := range names {
        firstChar := []rune(name)[0]
        
        // Check if inner map exists using two-value lookup
        if _, exists := result[firstChar]; !exists {
            result[firstChar] = make(map[string]int)
        }
        
        result[firstChar][name]++
    }
    
    return result
}

Both approaches work. The == nil check is simpler for maps.

Key Takeaway

When working with nested maps, always check if the inner map exists before trying to use it:

if outerMap[key] == nil {
    outerMap[key] = make(map[...])
}
outerMap[key][innerKey]++