Efficient reverse indexing of number (type string) in Go

Here's an efficient way to solve the complete problem: sum("987-65") = 115. The complete problem is documented in your working solution link: https://go.dev/play/p/DJ1ZYYDFnfq.

package main

import "fmt"

func reverseSum(s string) int {
    sum := 0
    for i, j := len(s)-1, 0; i >= 0; i-- {
        d := int(s[i]) - '0'
        if 0 <= d && d <= 9 {
            j++
            sum += j * d
        }
    }
    return sum
}

func main() {
    s := "987-65"
    sum := reverseSum(s)
    fmt.Println(sum)
}

https://go.dev/play/p/bx7wfmtXaie

115

Since we are talkng about efficient Go code, we need some Go benchmarks.

$ go test reversesum_test.go -bench=. -benchmem

BenchmarkSumTBJ-8     4001182   295.8 ns/op     52 B/op   6 allocs/op
BenchmarkSumA2Q-8   225781720     5.284 ns/op    0 B/op   0 allocs/op

Your solution (TBJ) is slow.

reversesum_test.go:

package main

import (
    "strconv"
    "strings"
    "testing"
)

func reverseSumTBJ(s string) int {
    total := 0
    count := 1
    for i := len(s) - 1; i >= 0; i-- {
        char := string([]rune(s)[i])
        num, _ := strconv.Atoi(char)
        total += count * num
        count++
    }
    return total
}

func BenchmarkSumTBJ(b *testing.B) {
    for n := 0; n < b.N; n++ {
        rawString := "987-65"
        stringSlice := strings.Split(rawString, "-")
        numberString := stringSlice[0] + stringSlice[1]
        reverseSumTBJ(numberString)
    }
}

func reverseSumA2Q(s string) int {
    sum := 0
    for i, j := len(s)-1, 0; i >= 0; i-- {
        d := int(s[i]) - '0'
        if 0 <= d && d <= 9 {
            j++
            sum += j * d
        }
    }
    return sum
}

func BenchmarkSumA2Q(b *testing.B) {
    for n := 0; n < b.N; n++ {
        rawString := "987-65"
        reverseSumA2Q(rawString)
    }
}

The reverse sum is part of a larger problem, computing a CAS Registry Number check digit.

package main

import "fmt"

// CASRNCheckDigit returns the computed
// CAS Registry Number check digit.
func CASRNCheckDigit(s string) string {
    // CAS Registry Number
    // https://en.wikipedia.org/wiki/CAS_Registry_Number
    //
    // The check digit is found by taking the last digit times 1,
    // the preceding digit times 2, the preceding digit times 3 etc.,
    // adding all these up and computing the sum modulo 10.
    //
    // The CAS number of water is 7732-18-5:
    // the checksum 5 is calculated as
    // (8×1 + 1×2 + 2×3 + 3×4 + 7×5 + 7×6)
    // = 105; 105 mod 10 = 5.
    //
    // Check Digit Verification of CAS Registry Numbers
    // https://www.cas.org/support/documentation/chemical-substances/checkdig

    for i, sep := 0, 0; i < len(s); i++ {
        if s[i] == '-' {
            sep++
            if sep == 2 {
                s = s[:i]
                break
            }
        }
    }

    sum := 0
    for i, j := len(s)-1, 0; i >= 0; i-- {
        d := int(s[i]) - '0'
        if 0 <= d && d <= 9 {
            j++
            sum += j * d
        }
    }
    return string(rune(sum%10 + '0'))
}

func main() {
    var rn, cd string
    // 987-65-5: Adenosine 5'-triphosphate disodium salt
    // https://www.chemicalbook.com/CASEN_987-65-5.htm
    rn = "987-65"
    cd = CASRNCheckDigit(rn)
    fmt.Println("CD:", cd, "\tRN:", rn)
    // 732-18-5: Water
    // https://www.chemicalbook.com/CASEN_7732-18-5.htm
    rn = "7732-18-5"
    cd = CASRNCheckDigit(rn)
    fmt.Println("CD:", cd, "\tRN:", rn)
    // 7440-21-3: Silicon
    // https://www.chemicalbook.com/CASEN_7440-21-3.htm
    rn = "7440-21-3"
    cd = CASRNCheckDigit(rn)
    fmt.Println("CD:", cd, "\tRN:", rn)
}

https://go.dev/play/p/VYh-5LuGpCn

BenchmarkCD-4   37187641   30.29 ns/op   4 B/op   1 allocs/op

Maybe this is more efficient

func reverseStringSum(s string) int {
    total := 0
    count := 1
    for i := len(s) - 1; i >= 0; i-- {
        num, _ := strconv.Atoi(string(s[i]))
        total += count * num
        count++
    }
    return total
}