Question

我想创建一个函数来计算两个字符串中公共段的长度（从头开始）。例如：

foo:="Makan"
bar:="Makon"

结果应为3。

foo:="Indah"
bar:="Ihkasyandehlo"

结果应为1。

Answer 1

由于您将测试用例限制为ASCII字符，因此不清楚您的要求我添加了一个Unicode测试用例，并且我已经包含了字节，符文或两者的答案。

play.golang.org ：

package main

import (
    "fmt"
    "unicode/utf8"
)

func commonBytes(s, t string) (bytes int) {
    if len(s) > len(t) {
        s, t = t, s
    }
    i := 0
    for ; i < len(s); i++ {
        if s[i] != t[i] {
            break
        }
    }
    return i
}

func commonRunes(s, t string) (runes int) {
    if len(s) > len(t) {
        s, t = t, s
    }
    i := 0
    for ; i < len(s); i++ {
        if s[i] != t[i] {
            break
        }
    }
    return utf8.RuneCountInString(s[:i])
}

func commonBytesRunes(s, t string) (bytes, runes int) {
    if len(s) > len(t) {
        s, t = t, s
    }
    i := 0
    for ; i < len(s); i++ {
        if s[i] != t[i] {
            break
        }
    }
    return i, utf8.RuneCountInString(s[:i])
}

func main() {
    Tests := []struct {
        word1, word2 string
    }{
        {"Makan", "Makon"},
        {"Indah", "Ihkasyandehlo"},
        {"日本語", "日本語"},
    }
    for _, test := range Tests {
        fmt.Println("Words:        ", test.word1, test.word2)
        fmt.Println("Bytes:        ", commonBytes(test.word1, test.word2))
        fmt.Println("Runes:        ", commonRunes(test.word1, test.word2))
        fmt.Print("Bytes & Runes: ")
        fmt.Println(commonBytesRunes(test.word1, test.word2))
    }
}

输出：

Words:         Makan Makon
Bytes:         3
Runes:         3
Bytes & Runes: 3 3
Words:         Indah Ihkasyandehlo
Bytes:         1
Runes:         1
Bytes & Runes: 1 1
Words:         日本語 日本語
Bytes:         9
Runes:         3
Bytes & Runes: 9 3

Answer 2

请注意，如果您使用的是Unicode字符，结果可能会大不相同例如，尝试使用utf8.DecodeRuneInString()。

请参阅this example：

package main

import "fmt"
import "unicode/utf8"

func index(s1, s2 string) int {
    res := 0
    for i, w := 0, 0; i < len(s2); i += w {
        if i >= len(s1) {
            return res
        }
        runeValue1, width := utf8.DecodeRuneInString(s1[i:])
        runeValue2, width := utf8.DecodeRuneInString(s2[i:])
        if runeValue1 != runeValue2 {
            return res
        }
        if runeValue1 == utf8.RuneError || runeValue2 == utf8.RuneError {
            return res
        }
        w = width
        res = i + w
    }
    return res
}

func main() {
    foo := "日本本a語"
    bar := "日本本b語"
    fmt.Println(index(foo, bar))
    foo = "日本語"
    bar = "日otest"
    fmt.Println(index(foo, bar))
    foo = "\xF0"
    bar = "\xFF"
    fmt.Println(index(foo, bar))
}

这里的结果是：

9（3个常见符文宽度'3'）
3（1格宽'3'）
0（无效符文，意为utf8.RuneError）

Answer 3

你的意思是这样的。请注意，这不会处理UTF 8，只能处理ascii。

package main

import (
    "fmt"
)

func equal(s1, s2 string) int {
    eq := 0
    if len(s1) > len(s2) {
        s1, s2 = s2, s1
    }
    for key, _ := range s1 {
        if s1[key] == s2[key] {
            eq++
        } else {
            break
        }
    }
    return eq
}

func main() {
    fmt.Println(equal("buzzfizz", "buzz"))
    fmt.Println(equal("Makan", "Makon"))
    fmt.Println(equal("Indah", "Ihkasyandehlo"))
}

如何比较golang中的字符串？

3 个答案: