Comment inverser une chaîne de caractères dans le jeu de Go?

Russ Cox, sur la golang-noix de liste de diffusion, suggère

package main 
import "fmt"
func main() { 
        input := "The quick brown 狐 jumped over the lazy 犬" 
        //Get Unicode code points. 
        n := 0
        rune := make([]rune, len(input))
        for _, r := range input { 
                rune[n] = r
                n++
        } 
        rune = rune[0:n]
        //Reverse 
        for i := 0; i < n/2; i++ { 
                rune[i], rune[n-1-i] = rune[n-1-i], rune[i] 
        } 
        //Convert back to UTF-8. 
        output := string(rune)
        fmt.Println(output)
}

Cela fonctionne sur des chaînes unicode en considérant 2 choses:

• gamme travaille sur la chaîne par l'énumération des caractères unicode
• chaîne peut être construit à partir de int tranches où chaque élément est un caractère unicode.

Donc, ici, il va:

func reverse(s string) string {
    o := make([]int, utf8.RuneCountInString(s));
    i := len(o);
    for _, c := range s {
        i--;
        o[i] = c;
    }
    return string(o);
}

J'ai remarqué cette question lors de la Simon posté sa solution qui, depuis les chaînes sont immuables, est très inefficace. Les autres solutions proposées sont également défectueux; ils ne fonctionnent pas ou ils sont inefficaces.

Voici une solution efficace qui fonctionne, sauf lorsque la chaîne n'est pas valide UTF-8 ou la chaîne contient des caractères composés.

package main

import "fmt"

func Reverse(s string) string {
    n := len(s)
    runes := make([]rune, n)
    for _, rune := range s {
        n--
        runes[n] = rune
    }
    return string(runes[n:])
}

func main() {
    fmt.Println(Reverse(Reverse("Hello, 世界")))
    fmt.Println(Reverse(Reverse("The quick brown 狐 jumped over the lazy 犬")))
}

J'ai écrit la suite de Reverse fonction qui respecte l'encodage UTF8 et les caractères combinés:

//Reverse reverses the input while respecting UTF8 encoding and combined characters
func Reverse(text string) string {
    textRunes := []rune(text)
    textRunesLength := len(textRunes)
    if textRunesLength <= 1 {
        return text
    }

    i, j := 0, 0
    for i < textRunesLength && j < textRunesLength {
        j = i + 1
        for j < textRunesLength && isMark(textRunes[j]) {
            j++
        }

        if isMark(textRunes[j-1]) {
            //Reverses Combined Characters
            reverse(textRunes[i:j], j-i)
        } 

        i = j
    }

    //Reverses the entire array
    reverse(textRunes, textRunesLength)

    return string(textRunes)
}

func reverse(runes []rune, length int) {
    for i, j := 0, length-1; i < length/2; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
}

//isMark determines whether the rune is a marker
func isMark(r rune) bool {
    return unicode.Is(unicode.Mn, r) || unicode.Is(unicode.Me, r) || unicode.Is(unicode.Mc, r)
}

J'ai fait de mon mieux pour la rendre aussi efficace et lisible que possible. L'idée est simple, parcourir à travers les runes à la recherche pour les combinaisons de caractères, puis inverser les caractères combinés " runes en place. Une fois que nous avons couvert tous les, inverser les runes de l'ensemble de la chaîne également en place.

Dire que nous tenons à inverser cette chaîne bròwn. Le ò est représenté par deux runes, l'un pour le o et un pour ce unicode \u0301a que représente la "tombe".

Pour des raisons de simplicité, nous allons représenter la chaîne comme ceci bro'wn. La première chose à faire est de regarder pour les caractères combinés et les inverser. Alors maintenant, nous avons la chaîne de br'own. Enfin, nous avons inversé l'ensemble de la chaîne et à la fin avec nwo'rb. C'est à nous retourner que nwòrb

Vous pouvez le trouver ici https://github.com/shomali11/util si vous souhaitez l'utiliser.

Ici sont quelques-uns des cas de test pour montrer un couple de différents scénarios:

func TestReverse(t *testing.T) {
    assert.Equal(t, Reverse(""), "")
    assert.Equal(t, Reverse("X"), "X")
    assert.Equal(t, Reverse("b\u0301"), "b\u0301")
    assert.Equal(t, Reverse("⚽"), "⚽")
    assert.Equal(t, Reverse("Les Mise\u0301rables"), "selbare\u0301siM seL")
    assert.Equal(t, Reverse("ab\u0301cde"), "edcb\u0301a")
    assert.Equal(t, Reverse("This `\xc5` is an invalid UTF8 character"), "retcarahc 8FTU dilavni na si `�` sihT")
    assert.Equal(t, Reverse("The quick bròwn 狐 jumped over the lazy 犬"), "犬 yzal eht revo depmuj 狐 nwòrb kciuq ehT")
}

C'est le plus rapide de la mise en œuvre

func Reverse(s string) string {
    size := len(s)
    buf := make([]byte, size)
    for start := 0; start < size; {
        r, n := utf8.DecodeRuneInString(s[start:])
        start += n
        utf8.EncodeRune(buf[size-start:], r)
    }
    return string(buf)
}

const (
    s       = "The quick brown 狐 jumped over the lazy 犬"
    reverse = "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"
)

func TestReverse(t *testing.T) {
    if Reverse(s) != reverse {
        t.Error(s)
    }
}

func BenchmarkReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Reverse(s)
    }
}

Si vous avez besoin pour gérer graphème clusters, l'utilisation de l'unicode ou regexp module.

package main
import (
"unicode"
"regexp"
)
func main() {
str := "\u0308" + "a\u0308" + "o\u0308" + "u\u0308"
println("u\u0308" + "o\u0308" + "a\u0308" + "\u0308" == ReverseGrapheme(str))
println("u\u0308" + "o\u0308" + "a\u0308" + "\u0308" == ReverseGrapheme2(str))
}
func ReverseGrapheme(str string) string {
buf := []rune("")
checked := false
index := 0
ret := "" 
for _, c := range str {
if !unicode.Is(unicode.M, c) {
if len(buf) > 0 {
ret = string(buf) + ret
}
buf = buf[:0]
buf = append(buf, c)
if checked == false {
checked = true
}
} else if checked == false {
ret = string(append([]rune(""), c)) + ret
} else {
buf = append(buf, c)
}
index += 1
}
return string(buf) + ret
}
func ReverseGrapheme2(str string) string {
re := regexp.MustCompile("\\PM\\pM*|.")
slice := re.FindAllString(str, -1)
length := len(slice)
ret := ""
for i := 0; i < length; i += 1 {
ret += slice[length-1-i]
}
return ret
}

Vous pouvez également importer une implémentation existante:

import "4d63.com/strrev"

Alors:

strrev.Reverse("abåd") //returns "dåba"

Ou à inverser une chaîne de caractères, y compris les combinaisons de caractères unicode:

strrev.ReverseCombining("abc\u0301\u031dd") //returns "d\u0301\u031dcba"

Ces implémentations prend en charge correcte de la commande de l'unicode codés sur plusieurs octets et le peignage des caractères lorsqu'il est inversé.

Remarque: string inverser les fonctions dans de nombreux langages de programmation ne permettent pas de préserver la combinaison, et d'identifier les combinaisons de caractères nécessite beaucoup plus de temps d'exécution.

Les deux méthodes suivantes permettent de courir plus vite que le plus rapide solution de préserver les combinaisons de caractères, si ce n'est pas à dire que je suis absent quelque chose dans ma référence en matière d'installation.

//input string s
bs := []byte(s)
var rs string
for len(bs) > 0 {
r, size := utf8.DecodeLastRune(bs)
rs += fmt.Sprintf("%c", r)
bs = bs[:len(bs)-size]
} //rs has reversed string

Deuxième méthode inspirée par cette

//input string s
bs := []byte(s)
cs := make([]byte, len(bs))
b1 := 0
for len(bs) > 0 {
r, size := utf8.DecodeLastRune(bs)
d := make([]byte, size)
_ = utf8.EncodeRune(d, r)
b1 += copy(cs[b1:], d)
bs = bs[:len(bs) - size]
} //cs has reversed bytes

Une version qui, je pense, travaille sur l'unicode. Il est construit sur l'utf8.Rune fonctions:

func Reverse(s string) string {
b := make([]byte, len(s));
for i, j := len(s)-1, 0; i >= 0; i-- {
if utf8.RuneStart(s[i]) {
rune, size := utf8.DecodeRuneInString(s[i:len(s)]);
utf8.EncodeRune(rune, b[j:j+size]);
j += size;
}
}
return string(b);
}

essayer de code ci-dessous:

package main
import "fmt"
func reverse(s string) string {
chars := []rune(s)
for i, j := 0, len(chars)-1; i < j; i, j = i+1, j-1 {
chars[i], chars[j] = chars[j], chars[i]
}
return string(chars)
}
func main() {
fmt.Printf("%v\n", reverse("abcdefg"))
}

pour plus d'informations, consultez http://golangcookbook.com/chapters/strings/reverse/

et http://www.dotnetperls.com/reverse-string-go

Voici encore une autre solution:

func ReverseStr(s string) string {
chars := []rune(s)
rev := make([]rune, 0, len(chars))
for i := len(chars) - 1; i >= 0; i-- {
rev = append(rev, chars[i])
}
return string(rev)
}

Cependant, yazu la solution ci-dessus est plus élégant car il inverse le []rune tranche en place.

package reverseString
import "strings"
//ReverseString - output the reverse string of a given string s
func ReverseString(s string) string {
strLen := len(s)
//The reverse of a empty string is a empty string
if strLen == 0 {
return s
}
//Same above
if strLen == 1 {
return s
}
//Convert s into unicode points
r := []rune(s)
//Last index
rLen := len(r) - 1
//String new home
rev := []string{}
for i := rLen; i >= 0; i-- {
rev = append(rev, string(r[i]))
}
return strings.Join(rev, "")
}

Test

package reverseString
import (
"fmt"
"strings"
"testing"
)
func TestReverseString(t *testing.T) {
s := "GO je úžasné!"
r := ReverseString(s)
fmt.Printf("Input: %s\nOutput: %s", s, r)
revR := ReverseString(r)
if strings.Compare(s, revR) != 0 {
t.Errorf("Expecting: %s\n. Got: %s\n", s, revR)
}
}

Sortie

Input: GO je úžasné!
Output: !énsažú ej OG
PASS
ok      github.com/alesr/reverse-string 0.098s

//Reverse reverses string using strings.Builder. It's about 3 times faster
//than the one with using a string concatenation
func Reverse(in string) string {
var sb strings.Builder
runes := []rune(in)
for i := len(runes) - 1; 0 <= i; i-- {
sb.WriteRune(runes[i])
}
return sb.String()
}
//Reverse reverses string using string
func Reverse(in string) (out string) {
for _, r := range in {
out = string(r) + out
}
return
}
BenchmarkReverseStringConcatenation-8   1000000 1571 ns/op  176 B/op    29 allocs/op
BenchmarkReverseStringsBuilder-8        3000000 499 ns/op   56 B/op 6 allocs/op

À l'aide de cordes.Builder est environ 3 fois plus rapide que l'utilisation de concaténation de chaîne