Как инвертировать строку в Движении?

ПРИМЕЧАНИЕ: Этот ответ относится к 2009 году, так что, вероятно, на данный момент существуют лучшие решения.

Выглядит немного «окольным» и, вероятно, не очень эффективным, но иллюстрирует как можно использовать интерфейс Reader для чтения строк. IntVectors также кажутся очень подходящими в качестве буферов при работе со строками utf8.

Это было бы еще короче, если бы не учитывать часть 'size' и вставлять в вектор с помощью Insert, но я думаю, что это было бы менее эффективно, в целом вектор нужно сдвигать на единицу каждый раз при добавлении новой руны.

Это решение определенно работает с символами 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());
}

Основано на первоначальном предложении 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, "" );
}

Альтернативный вариант, без использования пакета строк, но не «безопасный для 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 );
}

Это работает со строками Unicode, учитывая 2 вещи:

• range работает со строкой путем перечисления символов 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);
}

Расс Кокс из списка рассылки golang-nut предлагает

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

Версия, которая, как мне кажется, работает с юникодом. Он построен на функциях 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);
}