String 如何在Go中反转字符串？_String_Go_Reverse

String 如何在Go中反转字符串？

string go

String 如何在Go中反转字符串？,string,go,reverse,String,Go,Reverse,如何在Go中反转简单字符串？基于Stephan202的原始建议，似乎适用于unicode字符串： import "strings"; func Reverse( orig string ) string { var c []string = strings.Split( orig, "", 0 ); for i, j := 0, len(c)-1; i < j; i, j = i+1, j-1 { c[i], c[j] = c[j], c[i]

如何在Go中反转简单字符串？

基于Stephan202的原始建议，似乎适用于unicode字符串：

import "strings";

func Reverse( orig string ) string {
    var c []string = strings.Split( orig, "", 0 );

    for i, j := 0, len(c)-1; i < j; i, j = i+1, j-1 {
        c[i], c[j] = c[j], c[i]
    }

    return strings.Join( c, "" );
}

导入“字符串”；
func反向（原始字符串）字符串{
var c[]string=strings.Split（orig，“，0）；
对于i，j:=0，len（c）-1；i


备用，不使用字符串包，但不使用“unicode安全”：
func Reverse( s string ) string {
    b := make([]byte, len(s));
    var j int = len(s) - 1;
    for i := 0; i <= j; i++ {
        b[j-i] = s[i]
    }

    return string ( b );
}

func反向（s字符串）字符串{
b:=make（[]字节，len）；
var j int=len（s）-1；
对于i:=0；i一个我认为可以在unicode上工作的版本。它是基于utf8.Rune函数构建的：
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);
}

func Reverse(s string) (result string) {
  for _,v := range s {
    result = string(v) + result
  }
  return 
}

，建议
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)
}

主程序包
输入“fmt”
func main（）{
输入：=“快速棕色”狐 跳过懒惰的人犬" 
//获取Unicode代码点。
n:=0
符文：=make（[]符文，len（输入））
对于Ur:=范围输入{
符文[n]=r
n++
} 
符文=符文[0:n]
//逆转
对于i:=0；i
注意：这个答案来自2009年，所以现在可能有更好的解决方案

看起来有点“迂回”，可能效率不高，但说明了如何使用读卡器接口读取字符串。在使用utf8字符串时，IntVector似乎也非常适合用作缓冲区
如果省略“大小”部分，并通过插入将其插入到向量中，则长度会更短，但我认为这会降低效率，因为每次添加新符文时，整个向量都需要向后推一次
此解决方案绝对适用于utf8字符
package main

import "container/vector";
import "fmt";
import "utf8";
import "bytes";
import "bufio";


func
main() {
    toReverse := "Smørrebrød";
    fmt.Println(toReverse);
    fmt.Println(reverse(toReverse));
}

func
reverse(str string) string {
    size := utf8.RuneCountInString(str);
    output := vector.NewIntVector(size);
    input := bufio.NewReader(bytes.NewBufferString(str));
    for i := 1; i <= size; i++ {
        rune, _, _ := input.ReadRune();
        output.Set(size - i, rune);
    }
    return string(output.Data());
}

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 犬")))
}

主程序包
导入“容器/向量”；
进口“fmt”；
导入“utf8”；
导入“字节”；
进口“bufio”；
func
main（）{
toReverse:=“Smørrebrød”；
fmt.Println（toReverse）；
格式印刷（反向（反向））；
}
func
反向（str字符串）字符串{
大小：=utf8.运行计数器安装（str）；
输出：=vector.NewIntVector（大小）；
输入：=bufio.NewReader（bytes.NewBufferString（str））；
对于i:=1；i这通过考虑两件事在unicode字符串上工作：

范围通过枚举unicode字符来处理字符串
字符串可以从int片段构造，其中每个元素都是unicode字符

下面是：
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);
}

这是可行的，没有任何功能上的混乱：
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);
}

func Reverse(s string) (result string) {
  for _,v := range s {
    result = string(v) + result
  }
  return 
}

我在发布时注意到这个问题，因为字符串是不可变的，所以效率很低。其他建议的解决方案也有缺陷；它们不起作用或者效率很低
这是一个有效的解决方案，除非字符串不是有效的UTF-8或字符串包含组合字符
package main

import "container/vector";
import "fmt";
import "utf8";
import "bytes";
import "bufio";


func
main() {
    toReverse := "Smørrebrød";
    fmt.Println(toReverse);
    fmt.Println(reverse(toReverse));
}

func
reverse(str string) string {
    size := utf8.RuneCountInString(str);
    output := vector.NewIntVector(size);
    input := bufio.NewReader(bytes.NewBufferString(str));
    for i := 1; i <= size; i++ {
        rune, _, _ := input.ReadRune();
        output.Set(size - i, rune);
    }
    return string(output.Data());
}

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 犬")))
}

在Go1中，符文是一种内置类型
func Reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

func反向（s字符串）字符串{
符文：=[]符文
对于i，j:=0，len（符文）-1；i
符文是一种类型，所以请使用它。此外，Go不使用分号
func reverse(s string) string {
    l := len(s)
    m := make([]rune, l)

    for _, c := range s {
        l--
        m[l] = c
    }
    return string(m)
}

func main() {
    str := "the quick brown 狐 jumped over the lazy 犬"
    fmt.Printf("reverse(%s): [%s]\n", str, reverse(str))
}

这是最快的实现
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)
    }
}

func反向（s字符串）字符串{
尺寸：=透镜
buf:=生成（[]字节，大小）
起始值：=0；起始值<大小{
r、 n:=utf8.decodeRuneInstalling（s[start:]）
开始+=n
utf8.EncodeRune（buf[size start:]，r）
}
返回字符串（buf）
}
常数(
s=“快速棕色狐 跳过懒惰的人犬"
反向=”犬 yzal eht revo depmuj狐 nworb kciuq ehT“
)
func TestReverse（t*testing.t）{
如果倒车！=倒车{
t、 错误
}
}
func BenchmarkReverse（b*testing.b）{
对于i:=0；i
这里是另一个解决方案：
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)
}

然而，yazu的上述解决方案更加优雅，因为他将[]符文
片段反转到位。
另一个解决方案（tm）：
主程序包
输入“fmt”
键入符文[]符文
func（s符文）Reverse（）（cp符文）{
l:=len（s）；cp=make（符文，l）
//i如果需要处理grapheme集群，请使用unicode或regexp模块
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
}

主程序包
进口(
“unicode”
“regexp”
)
func main（）{
str:=“\u0308”+“a\u0308”+“o\u0308”+“u\u0308”
println（“u\u0308”+“o\u0308”+“a\u0308”+“\u0308”==反向语法（str））
println（“u\u0308”+“o\u0308”+“a\u0308”+“\u0308”==ReverseGrapheme2（str））
}
func ReverseGrapheme（str字符串）字符串{
buf:=[]符文（“”）
选中：=假
索引：=0
ret:=“”
对于u，c:=范围str{
if！unicode.Is（unicode.M，c）{
如果len（buf）>0{
ret=字符串（buf）+ret
}
buf=buf[：0]
buf=附加（buf，c）
如果选中==false{
选中=真
}
}否则，如果选中==false{
ret=string（附加（[]符文（“”，c））+ret
}否则{
buf=附加（buf，c）
}
指数+=1
}
返回字符串（buf）+ret
}
func ReverseGrapheme2（str字符串）字符串{
re:=regexp.MustCompile（“\\PM\\PM*|.”）
切片：=re.FindAllString（str，-1）
长度：=长度（切片）
ret:=“”
对于i:=0；i此代码保留完整的组合字符序列，并且
也应适用于无效的UTF-8输入
package stringutil
import "code.google.com/p/go.text/unicode/norm"

func Reverse(s string) string {
    bound := make([]int, 0, len(s) + 1)

    var iter norm.Iter
    iter.InitString(norm.NFD, s)
    bound = append(bound, 0)
    for !iter.Done() {
        iter.Next()
        bound = append(bound, iter.Pos())
    }
    bound = append(bound, len(s))
    out := make([]byte, 0, len(s))
    for i := len(bound) - 2; i >= 0; i-- {
        out = append(out, s[bound[i]:bound[i+1]]...)
    }
    return string(out)
}

如果使用unicode/norm原语
允许通过字符串的边界进行迭代，而无需
分配。另请参见安德鲁·格兰德的《来自》
/*
Copyright 2014 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
     http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Reverse returns its argument string reversed rune-wise left to right.
func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

/*
版权所有2014谷歌公司。
根据Apache许可证2.0版（以下简称“许可证”）获得许可；
除非遵守许可证，否则不得使用此文件。
您可以通过以下方式获得许可证副本：
Benchmark_rmuller-4   100000         19246 ns/op
Benchmark_peterSO-4    50000         28068 ns/op
Benchmark_russ-4       50000         30007 ns/op
Benchmark_ivan-4       50000         33694 ns/op
Benchmark_yazu-4       50000         33372 ns/op
Benchmark_yuku-4       50000         37556 ns/op
Benchmark_simon-4       3000        426201 ns/op

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)
}

func reverseStr(str string) (out string) {
    for _, s := range str {
        out = string(s) + out
    }

    return
}

func reverse(s string) (ret string) {
    for _, v := range s {
        defer func(r rune) { ret += string(r) }(v)
    }
    return
}

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"))
}

//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

//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

// 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)
}

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("You could also import an existing implementation:

import "4d63.com/strrev"

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

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

func Reverse(str string) string {
    if str != "" {
        return Reverse(str[1:]) + str[:1]
    }
    return ""   
}

    func reverseString(someString string) string {
        runeString := []rune(someString)
        var reverseString string
        for i := len(runeString)-1; i >= 0; i -- {
            reverseString += string(runeString[i])
        }
        return reverseString
    }

//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

: doG ehT 语汉 gfedcbA

func Reverse(s string) string {
    r := []rune(s)
    var output strings.Builder
    for i := len(r) - 1; i >= 0; i-- {
        output.WriteString(string(r[i]))
    }

    return output.String()
}

func reverseStr(b string) {
for _, v := range []rune(b) {
    defer fmt.Printf("%c", v)

}
 }