如何在 Golang 的字符串中每 X 个字符插入一个字符？

Question

目标：在Golang的字符串中每x个字符插入一个字符

输入： helloworldhelloworldhelloworld

预期输出： hello-world-hello-world-hello-world

尝试

尝试一

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "helloworldhelloworldhelloworld"

    s = strings.Replace(s, "world", ",", -1)
    fmt.Println(s)
}

结果： hello,hello,hello,

---

尝试二

1. 计算字符数
2. 循环
3. 如果 X=5 则插入-

---

尝试三

1. 扫描结合加入

问题

尝试二和三目前不包含代码片段的原因是我仍在思考应该使用什么方法在 Golang 中的字符串中每 X 个字符插入一个字符。

Answer 1

https://play.golang.org/p/HEGbe7radf

此函数仅在每个第 N 个元素中插入“-”

func insertNth(s string,n int) string {
    var buffer bytes.Buffer
    var n_1 = n - 1
    var l_1 = len(s) - 1
    for i,rune := range s {
       buffer.WriteRune(rune)
       if i % n == n_1 && i != l_1  {
          buffer.WriteRune('-')
       }
    }
    return buffer.String()
}

Answer 2

我觉得下面的解决方案值得一提：

package main

import "fmt"

var s = "helloworldhelloworldhelloworld"

func main() {
    for i := 5; i < len(s); i += 6 {
        s = s[:i] + "-" + s[i:]
    }
    fmt.Println(s)
}

https://play.golang.org/p/aMXOTgiNHf

Answer 3

根据 Go 文档，字符串是只读的字节切片。 . 考虑到这一点，就会出现一个问题。 你用的是什么字符集？ 你可以在这里和这里看到一些事情变得奇怪的例子。

尽管很复杂，但仍然有一个简单的答案

s = strings.Replace(s, "hello", "hello-", -1)
s = strings.Replace(s, "world", "world-", -1)

Answer 4

我的看法：

import (
    "fmt"
    "regexp"
)

const s = "helloworldhelloworldhelloworld"

func Attempt1(s string) string {
    var re = regexp.MustCompile(`(\Bhello|\Bworld)`)
    return re.ReplaceAllString(s, "-$1")
}

func Attempt2(s string) string {
    const chunkLen = len("hello")
    out := make([]rune, len(s)+len(s)/chunkLen)
    i, j := 1, 0
    for _, c := range s {
        out[j] = c
        if i == len(s) {
            break
        }
        j++
        if i%chunkLen == 0 {
            out[j] = '-'
            j++
        }
        i++
    }
    return string(out)
}

func main() {
    fmt.Println(Attempt1(s))
    fmt.Println(Attempt2(s))
}

游乐场链接

我应该补充一点，虽然可以实现“方法 3”——即“将源字符串分成五个字符的块，然后使用 '-' 字符连接块”——它仍然需要扫描源字符串 rune -按符文，就像我的Attempt2()一样； 所以如果你眯着眼睛看它，你会发现存储一个块列表然后加入它们会做更多的操作而没有真正的收益（以及更大的内存占用等）。

Answer 5

如果您知道您的字符串可以被 5 整除，那么这也可能是一个解决方案。 虽然肯定比发布的其他一些解决方案效率低。

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    fmt.Println(InsertEvery5("HelloWorld", "-"))
}

// Only works if len(str) mod 5 is 0
func InsertEvery5(str string, insert string) string {
    re := regexp.MustCompile(`.{5}`) // Every 5 chars
    parts := re.FindAllString(str, -1) // Split the string into 5 chars blocks.
    return strings.Join(parts, insert) // Put the string back together
}

Answer 6

我的看法。 我需要在长字符串中添加新行（不止一个字符）来包装它们。

func InsertNewLines(s string, n int) string {
    var r = regexp.MustCompile("(.{" + strconv.Itoa(n) + "})")
    return r.ReplaceAllString(s, "$1<wbr />")
}

Answer 7

预分配内存和使用copy比对每个字符进行迭代要快。

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

func insertNthCopy(in, sep string, n int) string {
    count := len(in) / n // amount of lines to split
    split := make([]byte, len(in)+len(sep)*count)
    i, s := 0, 0

    for ; i < count*n; i, s = i+n, s+n+len(sep) {
        copy(split[s:], in[i:i+n])
        copy(split[s+n:], sep)
    }

    copy(split[s:], in[i:]) // copy remainder if any

    return string(split)
}

提供的示例字符串比接受的答案快大约六倍：

cpu: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz
Benchmark_insertNthCopy
Benchmark_insertNthCopy-8       12404311            85.11 ns/op
Benchmark_insertNth
Benchmark_insertNth-8            2269458           524.5 ns/op