Intermediate Exercism • go

Scrabble Score

Challenge Overview

Given a word, compute the Scrabble score for that word.

Introduction

Scrabble is a word game where players place letter tiles on a board to form words. Each letter has a value. A word’s score is the sum of its letters’ values.

Instructions

Your task is to compute a word’s Scrabble score by summing the values of its letters.

The letters are valued as follows:

Letter	Value
A, E, I, O, U, L, N, R, S, T	1
D, G	2
B, C, M, P	3
F, H, V, W, Y	4
K	5
J, X	8
Q, Z	10

For example, the word “cabbage” is worth 14 points:

3 points for C
1 point for A
3 points for B
3 points for B
1 point for A
2 points for G
1 point for E

Dig Deeper

map

`map`

// Package scrabble scores a scrabble word.
package scrabblescore

import "unicode"

var lookup = map[rune]int{
	'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1, 'l': 1, 'n': 1, 'r': 1, 's': 1, 't': 1,
	'd': 2, 'g': 2,
	'b': 3, 'c': 3, 'm': 3, 'p': 3,
	'f': 4, 'h': 4, 'v': 4, 'w': 4, 'y': 4,
	'k': 5,
	'j': 8, 'x': 8,
	'q': 10, 'z': 10,
}

// Score takes a word and returns its scrabble score.
func Score(word string) (score int) {
	for _, ltr := range word {
		score += lookup[unicode.ToLower(ltr)]
	}
	return score
}

This approach starts be defining a map that relates each letter to its score. Note that the map is defined outside of the Score() function, so that it is no recreated on each call to the function. Lowercase letters are used instead of uppercase because most of the input will be lowercase. It makes a slight performance difference, because of how unicode.ToLower() is implemented, as seen in the letter.go file:

// ToLower maps the rune to lower case.
func ToLower(r rune) rune {
	if r <= MaxASCII {
		if 'A' <= r && r <= 'Z' {
			r += 'a' - 'A'
		}
		return r
	}
	return To(LowerCase, r)
}

We see that when the rune is an ASCII character it is only lowercased if it is not already lowercase. So, when most of the input is already lowercase, we can save a bit of time by only looking up the lowercase letters. We could use both lowercase and uppercase letters in the map, but that’s a lot of typing! Another consideration is that if the score of a letter were ever to change, if we look up both lowercase and uppercase letters then we would have to change the score in two places. It’s preferable to have only one place to change something if something gets modified. Some people may find uppercased letters to be more readable in this context, and they may take the slight performance hit to use those instead.

The Score() function is defined with a named return value which is initialized with its zero value.

The ways to iterate characters are by Unicode runes, or by each letter being a string, or by each letter being a byte. The runes are from range on a string, the strings from Split(), and the bytes from indexing into the string. Another way to iterate runes is to convert the string to a rune slice and range on it. The difference between ranging on a rune slice vs ranging on a string is that the index returned from a string is the position of the next rune in bytes, not which rune it is. For example, if the first unicode character is two bytes, then the second unicode character index will be 2 when ranging on a string and 1 when ranging on a rune slice. As of the time of this writing we are only iterating ASCII characters, so we don’t care about the index, and ranging on the input string is fine.

When the iteration is finished, the output variable of the totaled score is returned from the function.

switch on runes

`switch` on runes

// Package scrabble uses switch to score a scrabble word.
package scrabblescore

import "unicode"

// Score takes a word and returns its scrabble score.
func Score(word string) (score int) {
	for _, letter := range word {

		switch unicode.ToLower(letter) {
		case 'a', 'e', 'i', 'o', 'u', 'l', 'n', 'r', 's', 't':
			score += 1
		case 'd', 'g':
			score += 2
		case 'b', 'c', 'm', 'p':
			score += 3
		case 'f', 'h', 'v', 'w', 'y':
			score += 4
		case 'k':
			score += 5
		case 'j', 'x':
			score += 8
		case 'q', 'z':
			score += 10
		}
	}
	return score
}

The Score() function is defined with a named return value which is initialized with its zero value.

For this exercise we are not concerned with validating the letter and handling an error for an illegal character. The unicode.ToLower() function is used to ensure the letter is lowercase, and the letter is used in a switch statement. Lowercase letters are used instead of uppercase because most of the input will be lowercase. It makes a slight performance difference, because of how unicode.ToLower() is implemented, as seen in the letter.go file:

// ToLower maps the rune to lower case.
func ToLower(r rune) rune {
	if r <= MaxASCII {
		if 'A' <= r && r <= 'Z' {
			r += 'a' - 'A'
		}
		return r
	}
	return To(LowerCase, r)
}

We see that when the rune is an ASCII character it is only lowercased if it is not already lowercase. So, when most of the input is already lowercase, we can save a bit of time by only looking up the lowercase letters. We could use both lowercase and uppercase letters in the switch, but that’s a lot of typing! Another consideration is that if the score of a letter were ever to change, if we look up both lowercase and uppercase letters then we would have to change the score in two places. It’s preferable to have only one place to change something if something gets modified. Some people may find uppercased letters to be more readable in this context, and they may take the slight performance hit to use those instead.

The letter is used as the value to look up the score in the switch statement, which is added to the output variable.

When the iteration is finished, the output variable of the totaled score is returned from the function.

switch on strings

`switch` on strings

// Package scrabble uses switch to score a scrabble word.
package scrabblescore

import "strings"

// Score takes a word and returns its scrabble score.
func Score(word string) (score int) {
	for _, letter := range strings.Split(strings.ToLower(word), "") {

		switch letter {
		case "a", "e", "i", "o", "u", "l", "n", "r", "s", "t":
			score += 1
		case "d", "g":
			score += 2
		case "b", "c", "m", "p":
			score += 3
		case "f", "h", "v", "w", "y":
			score += 4
		case "k":
			score += 5
		case "j", "x":
			score += 8
		case "q", "z":
			score += 10
		}
	}
	return score
}

The Score() function is defined with a named return value which is initialized with its zero value.

For this exercise we are not concerned with validating the letter and handling an error for an illegal character. The strings.ToLower() function is used to ensure all of the letters are lowercase. Lowercase letters are used instead of uppercase because most of the input will be lowercase. It makes a slight performance difference, because of how strings.ToLower() is implemented, as seen in the strings.go file:

// ToLower returns s with all Unicode letters mapped to their lower case.
func ToLower(s string) string {
	isASCII, hasUpper := true, false
	for i := range len(s) {
		c := s[i]
		if c >= utf8.RuneSelf {
			isASCII = false
			break
		}
		hasUpper = hasUpper || ('A' <= c && c <= 'Z')
	}

	if isASCII { // optimize for ASCII-only strings.
		if !hasUpper {
			return s
		}
		var b Builder
		b.Grow(len(s))
		for i := range len(s) {
			c := s[i]
			if 'A' <= c && c <= 'Z' {
				c += 'a' - 'A'
			}
			b.WriteByte(c)
		}
		return b.String()
	}
	return Map(unicode.ToLower, s)
}

We see that when the rune is an ASCII character it is only lowercased if it is not already lowercase. So, when most of the input is already lowercase, we can save a bit of time by only looking up the lowercase letters. We could use both lowercase and uppercase letters in the switch, but that’s a lot of typing! Another consideration is that if the score of a letter were ever to change, if we look up both lowercase and uppercase letters then we would have to change the score in two places. It’s preferable to have only one place to change something if something gets modified. Some people may find uppercased letters to be more readable in this context, and they may take the slight performance hit to use those instead.

Each letter is used as the value to look up the score in the switch statement, which is added to the output variable.

When the iteration is finished, the output variable of the totaled score is returned from the function.

Source: Exercism go/scrabble-score