如何改进我的置乱字符串函数，它可能包含不同的符号、数字和字符串Golang？

Question

这个想法是创建一个函数，它接受一些整数的字符串，文本也可以包括'，‘，这样的符号。-If字符串中有数字，首先返回字符串-The，单词中的最后一个字母应该保持不变。只乱写其他信。

• 如果我们有一个"'“符号，不要乱动它。

问题是，我希望打印出来的希望节，但得到另一个结果。例如:我使用的是seed = 100，而不是-> aa、metatr -> metater等

函数来标记：

import "regexp"

func tokenize(text string) []string {
    re := regexp.MustCompile(`[A-Za-z0-9']+|[':;?().,!\\ ]`)
    return re.FindAllString(text, -1)
}

置乱码

import (
    "math/rand"
    "strconv"
)

func scramble(text string, seed int64) string {
    rand.Seed(seed)
    slicy := tokenize(text)
    var str string = ""
    for a := 0; a < len(slicy); a++ {

        _, err := strconv.Atoi(slicy[a])
        if err != nil {

            var shufle []byte
            for i := 1; i < len(slicy[a])-1; i++ {
                shufle = append(shufle, slicy[a][i])
            }

            if slicy[a] != " " && slicy[a] != "." && slicy[a] != "," && slicy[a] != "(" && slicy[a] != ")" {
                new_length := 0
                for d := 0; d < len(shufle); d++ {
                    if string(shufle[d]) == "'" {
                        new_length = d - 1
                    }
                }
                if new_length != 0 {
                    for l := 0; l < new_length-1; l++ {
                        m := l + 1
                        shufle[l], shufle[m] = shufle[m], shufle[l]
                    }
                } else {
                    rand.Shuffle(len(shufle), func(k, j int) {

                        shufle[k], shufle[j] = shufle[j], shufle[k]
                    })
                }

                var scrambled_list []byte
                scrambled_list = append(scrambled_list, slicy[a][0])
                for d := 0; d < len(shufle); d++ {
                    scrambled_list = append(scrambled_list, shufle[d])
                }
                scrambled_list = append(scrambled_list, slicy[a][len(slicy[a])-1])

                str = str + string(scrambled_list)
            } else {
                switch slicy[a] {
                case " ":
                    str += " "
                case ".":
                    str += "."
                case "(":
                    str += "("
                case ")":
                    str += ")"
                case ",":
                    str += ","
                default:

                }
            }
        } else {
            return text
        }
    }

    return str
}

当我测试它时，我失败了：

输入：

"it doesn't matter in what order the letters in a word are, the only important thing is that the first and last letter be at the right place."

想要：

 "it deson't metatr in waht oredr the lettres in a wrod are, the only inmproatt thing is taht the frist and last letetr be at the right plcae."

我得到的是：

“这并不意味着我们要做的事情是，老生常谈的是在正确的地方。”

Answer 1

鉴于我对OP需求的理解，这是另一种解决方案。

Wthiin a seneetnc，如果它是nburem，scrmaebl eahc wosrd，btu levae itnact teohs cceahrsrta“.，()"，frtsi lrteet和ltsa ltreet。

它使用配置为使用bufio.Scanner将输入按单词拆分的bufio.ScanWords。

当找到一个单词时，如果它被检测为一个数字，它就会保持原样，否则，它会检查单词的长度，如果它大于2，则会对该单词进行洗牌。

为了对单词进行洗牌，它使用text until ".,()'\""的一部分使用strings.IndexAny扫描它，然后使用rand.Shuffle对每个部分进行洗牌。

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "strconv"
    "strings"
)

func main() {
    input := `Within a sentence, if it is not a number, scramble each words, but leave intact those characters "'\".,()", the first letter, and the last letter.`
    output := scramble(input, 100)
    fmt.Printf("%v\n", input)
    fmt.Printf("%v\n", output)
}

func scramble(text string, seed int64) (output string) {
    rand.Seed(seed)

    b := bufio.NewScanner(strings.NewReader(text))
    b.Split(bufio.ScanWords)

    for b.Scan() {
        w := b.Text()
        _, err := strconv.Atoi(w)
        if err == nil || len(w) < 2 {
            output += w
        } else {
            output += shuffleWord(w)
        }
        output += " "
    }
    return strings.TrimSuffix(output, " ")
}

func shuffleWord(input string) (output string) {
    if len(input) < 2 {
        output = input
        return
    }
    r := []rune(input)
    ln := len(r)
    for i := 1; i < ln-1; i++ {
        n := strings.IndexAny(input[i:], ".,()'\"")
        if n == -1 {
            n = ln - i
        }
        if n > 0 {
            rand.Shuffle(n, func(k, j int) {
                r[i+k], r[i+j] = r[i+j], r[i+k]
            })
            i += n - 1
        }
    }
    output = string(r)
    return
}

试试吧，这里