validate as you go

// Package luhn is a small library for returning if a phrase is valid according to the Luhn algorithm.
package luhn

func Valid(num string) bool {
	total := 0
	pos := 0
	for i := len(num) - 1; i > -1; i-- {
		char := num[i]
		if char == ' ' {
			continue
		}
		if char < '0' || char > '9' {
			return false
		}
		digit := int(char - '0')
		if pos%2 == 0 {
			total += digit
		} else {
			switch digit {
			case 1, 2, 3, 4:
				total += digit << 1
			case 5, 6, 7, 8:
				total += (digit << 1) - 9
			case 9:
				total += digit
			}
		}
		pos++
	}
	return pos > 1 && total%10 == 0
}

This approach starts by initializing some variables for iterating backward (i.e. from right to left) through the input string.

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 iterating from left to right and 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 can iterate bytes, since all of the characters are ASCII.

Iterating backward is a way to keep us from having to reverse the input string.

In the loop, the character is checked to see if it is a space. If so, continue is used to go to the next iteration without incrementing the pos variable, thus ignoring the space and indicating the same position.

If it is not a space, then the character is tested to be a digit character. If not, the function returns false for having an illegal character.

The character is converted to an int after subtracting its ASCII value by the ASCII value of '0', for example '3' - '0' = 3.

The pos variable is then checked to see if the position is evenly divisible by 0. If so, it adds the digit value to the total.

If not, it adds double the digit value to the total if the digit value is less than 5. This can be done by shifting all of the digit bits one position to the left, or by multiplying by 2. For example, 3 in binary is 11, By shifting all of the bits once to the left it becomes 110, which is 6 in binary (100 is 4 plus 10 is 2 = 110 is 6.)

Otherwise, if the digit value is greater than 4 and less than 9, then 9 is subtracted from the doubled digit value and then added to the total.

If the digit value is 9, then it is added to the total.

The pos variable is incremented to keep track of the position, and the loop either exits or goes on to the next digit.

After the loop exits, the functon returns if the position is greater than 1 and the total is evenly divisible by 10.

There is an interesting optimization for the "lidate as you go" approach that can cut the time by more than half. It requires two modifications to be made in tandem. Either one by itself does not reduce the time so dramatically. It was benchmarked on version 1.19.4 windows/amd.

The whole modified code is here

// Package luhn is a small library for returning if a phrase is valid according to the Luhn algorithm.
package luhn

func Valid(num string) bool {
    var total, pos int
        for i := len(num) - 1; i > -1; i-- {
            char := num[i]
            if char == ' ' {
                continue
            }
            if char < 48 || char > 57 {
                return false
            }
            digit := int(char - 48)
            total += digit + pos%2*(digit+digit/5)
            pos++
        }
        return pos > 1 && total%10 == 0
}

The first modification is simple and changes

total := 0
pos := 0

for

var total, pos int

which defines the same variables with their default zero values.

The other change is more of a mathematical way to avoid the conditional logic for adding the value. The if statement and entire switch statement can be replaced with

total += digit + pos%2*(digit+digit/5)

The first mathematical choice is that when the position number is even, the number multiplies its "doubled" value by 0, so evenly-positioned numbers only add themselves. An oddly-positioned number will multiply its "doubled" value by 1.

The second mathematical choice is that, instead of possibly subtracting "down" by 9, the doubling expression always adds "up". For higher numbers which would have been subtracted by 9, the result is the number desired plus 10. Since the total value is checked by seeing if it is evenly divisible by 10, the extra 10 in the higher-number calculations is effectively factored out.

To understand how this works, you can see in the following table for digit + (digit + digit/5)

The benchmarks were as follows:

unoptimized
BenchmarkValid-12    	 4668248	       248.4 ns/op	       0 B/op	       0 allocs/op

optimized
BenchmarkValid-12    	10885153	       106.8 ns/op	       0 B/op	       0 allocs/op

The optimized solution is much faster, but it is not as clear as to how it is conforming to the Luhn algorithm, unless one readily understands the math.