7. Distinct Words

Complete the countDistinctWords function using a map. It should take a slice of strings and return the total count of distinct words across all the strings. Assume words are separated by spaces. Casing should not matter. (e.g., "Hello" and "hello" should be considered the same word).

For example:

messages := []string{"Hello world", "hello there", "General Kenobi"}
count := countDistinctWords(messages)

count should be 5 as the distinct words are "hello", "world", "there", "general" and "kenobi" irrespective of casing.

Tips

• Go's strings package can be very helpful here. Specifically the Fields method and the ToLower method.

• Since all that matters is counting distinct words, we don't care about the value of each key in the map. You can use struct{}{} as the value of your map key. This empty struct uses no memory.

Solution

My Solution

solution.go

package main
import "strings"

func countDistinctWords(messages []string) int {
	holder := make(map[string]struct{})
	count:=0

	for _,words:= range messages{
		sepWords:= strings.Fields(words)
		for _, word:= range sepWords{
			lowered:= strings.ToLower(word)
			if _, ok:=holder[lowered]; !ok{
				holder[lowered] = struct{}{}
				count++
			}
		}
	}
	return count
}

Optimized Solution

optimized.go

package main

import (
	"strings"
)

func countDistinctWords(messages []string) int {
	distinctWords := make(map[string]struct{})
	for _, message := range messages {
		for _, word := range strings.Fields(strings.ToLower(message)) {
			// struct{}{} is a zero-byte value in Go.
			distinctWords[word] = struct{}{}
		}
	}
	return len(distinctWords)
}

Why this works

• strings.Fields splits on whitespace → words, not characters.

• strings.ToLower normalizes casing.

• map[string]struct{} tracks uniqueness efficiently.

• No manual counter needed → len(map) gives the distinct count.