কিভাবে একটি স্ট্রিং বিপরীত?

Question 1

আমরা কীভাবে সরল স্ট্রিংগুলিকে বিপরীত করতে পারি?

Question 2

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

Question 3

গোলং-বাদাম মেলিং তালিকায় রাশ কক্স পরামর্শ দেয়

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

Question 4

এটি কার্যকারিতা সম্পর্কে সমস্ত মাতামাতি ছাড়াই কাজ করে:

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

Question 5

এটি 2 টি বিষয় বিবেচনা করে ইউনিকোড স্ট্রিংয়ে কাজ করে:

পরিসর ইউনিকোড অক্ষর গণনা করে স্ট্রিংয়ে কাজ করে
স্ট্রিংটি ইন স্লাইস থেকে তৈরি করা যেতে পারে যেখানে প্রতিটি উপাদান একটি ইউনিকোড অক্ষর।

সুতরাং এখানে এটি যায়:

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

Question 6

থেকে golang / উদাহরণস্বরূপ / stringutil / reverse.go: যান উদাহরণস্বরূপ প্রকল্প , অ্যান্ড্রু Gerrand দ্বারা

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

স্ট্রিংটিকে বিপরীত করার জন্য খেলার মাঠে যান

স্ট্রিং "ব্রাউন" বিপরীত করার পরে, সঠিক ফলাফলটি "নরব" হওয়া উচিত, "নরব" নয়।
ও বর্ণের উপরে কবরটি নোট করুন।

ইউনিকোডের বিপরীত ফলাফল "f⃝ds⃝a" এর সাথে যেমন "as⃝df̅" সংযুক্ত অক্ষর সংরক্ষণের জন্য,
দয়া করে নীচে তালিকাভুক্ত অন্য কোডটি দেখুন:

http://rosettacode.org/wiki/Revers_a_string#Go

Question 7

আমি এই প্রশ্নটি লক্ষ্য করেছি যখন সাইমন তার সমাধান পোস্ট করেছিলেন , যেহেতু স্ট্রিংগুলি অপরিবর্তনীয়, খুব অদক্ষ। অন্যান্য প্রস্তাবিত সমাধানগুলিও ত্রুটিযুক্ত; তারা কাজ করে না বা তারা অদক্ষ।

স্ট্রিংটি বৈধ UTF-8 নয় বা স্ট্রিংটিতে সম্মিলিত অক্ষর রয়েছে তা ব্যতীত এখানে একটি কার্যকর সমাধান রয়েছে।

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

Question 8

এখানে অনেক উত্তর আছে। এর মধ্যে কয়েকটি পরিষ্কার নকল ates তবে বাম দিক থেকেও, সেরা সমাধানটি নির্বাচন করা শক্ত।

সুতরাং আমি উত্তরগুলি দিয়ে গিয়েছিলাম, ইউনিকোডের জন্য কাজ করে না এমন একটিটি ফেলে দিয়েছি এবং নকলগুলিও সরিয়েছি। আমি বেঁচে থাকাদের দ্রুততম খুঁজে পেতে বেঞ্চমার্ক করেছি। সুতরাং এট্রিবিউশন সহ ফলাফলগুলি (যদি আপনি যে উত্তরগুলি মিস করেছেন তবে তা যদি লক্ষ্য করেন তবে যোগ করার মতো মূল্য নির্ধারণ করুন, মাপদণ্ডটি সংশোধন করতে নির্দ্বিধায়):

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

সুতরাং এখানে rmuller দ্বারা দ্রুততম পদ্ধতি :

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

কিছু কারণে আমি একটি বেঞ্চমার্ক যোগ করতে পারছি না, সুতরাং আপনি এটি থেকে অনুলিপি PlayGroundকরতে পারেন (আপনি সেখানে পরীক্ষা চালাতে পারবেন না)। এটির নাম পরিবর্তন করে চালানgo test -bench=.

Question 9

আমি নিম্নলিখিত Reverseফাংশনটি লিখেছি যা ইউটিএফ 8 এনকোডিং এবং সম্মিলিত অক্ষরকে সম্মান করে:

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

এটিকে যথাসম্ভব দক্ষ ও পঠনযোগ্য করার জন্য আমি যথাসাধ্য চেষ্টা করেছি। ধারণাটি সহজ, সম্মিলিত অক্ষরগুলির সন্ধানকারী রুনগুলির মধ্য দিয়ে অতিক্রম করে তারপরে জায়গায় সম্মিলিত অক্ষরের রানগুলি বিপরীত করুন। একবার আমরা সেগুলি সবগুলি coveredেকে ফেললে, পুরো স্ট্রিংয়ের রানগুলিও ঠিক জায়গায় করুন।

বলুন আমরা এই স্ট্রিংটি বিপরীত করতে চাই bròwn। òদুই runes, এক দ্বারা প্রতিনিধিত্ব করা হয় oএবং এই ইউনিকোড জন্য এক \u0301aযে "কবর" প্রতিনিধিত্ব করে।

সরলতার জন্য, এর মতো স্ট্রিংটি উপস্থাপন করি bro'wn। আমরা প্রথমে যা করি তা হ'ল সম্মিলিত অক্ষরগুলি অনুসন্ধান করা এবং সেগুলি বিপরীত করুন। সুতরাং এখন আমরা স্ট্রিং আছে br'own। শেষ পর্যন্ত, আমরা পুরো স্ট্রিংটি বিপরীত করি এবং শেষ করি nwo'rb। এটি আমাদের কাছে ফেরত দেওয়া হয়েছেnwòrb

আপনি এটি ব্যবহার করতে চাইলে https://github.com/shomali11/util আপনি এখানে এটি পেতে পারেন।

কয়েকটি ভিন্ন ভিন্ন দৃষ্টিকোণ প্রদর্শন করার জন্য এখানে কয়েকটি পরীক্ষার কেস দেওয়া হয়েছে:

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

Question 10

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

স্ট্রিংস.বিল্ডার ব্যবহার স্ট্রিং কনট্যাকটেশন ব্যবহারের চেয়ে প্রায় 3 গুণ বেশি গতিযুক্ত

Question 11

এখানে বেশ আলাদা, আমি আরও কার্যকরী পদ্ধতির কথা বলতে চাই, অন্য উত্তরের মধ্যে তালিকাভুক্ত নয়:

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

Question 12

স্টিফান202 এর মূল পরামর্শ অনুযায়ী বিল্ডিং, এবং ইউনিকোড স্ট্রিংয়ের জন্য কাজ করে বলে মনে হচ্ছে:

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

Question 13

এটি দ্রুততম বাস্তবায়ন

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

Question 14

এই কোড অক্ষর একত্রিত করার ক্রম অক্ষর সংরক্ষণ করে এবং অবৈধ ইউটিএফ -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)
}

ইউনিকোড / আদর্শের আদিমরা যদি কোনও স্ট্রিংয়ের সীমানা ছাড়িয়ে বরাদ্দ না করে পুনরায় পুনরায় প্রবেশের অনুমতি দেয় তবে এটি কিছুটা দক্ষ হতে পারে। Https://code.google.com/p/go/issues/detail?id=9055 দেখুন ।

Question 15

আপনার যদি গ্রাফিম ক্লাস্টারগুলি পরিচালনা করতে হয় তবে ইউনিকোড বা রিজেক্সপ মডিউলটি ব্যবহার করুন।

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
}

Question 16

আপনি একটি বিদ্যমান বাস্তবায়ন আমদানি করতে পারেন:

import "4d63.com/strrev"

তারপরে:

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

অথবা ইউনিকোডের সমন্বয়যুক্ত অক্ষরগুলি সহ একটি স্ট্রিং উল্টাতে:

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

এই বাস্তবায়নগুলি ইউনিকোড মাল্টিবাইট এবং বিপরীত হলে অক্ষর অক্ষরগুলির সঠিক ক্রম সমর্থন করে।

দ্রষ্টব্য: অনেকগুলি প্রোগ্রামিং ভাষায় অন্তর্নির্মিত স্ট্রিং বিপরীত ফাংশনগুলি সংমিশ্রণ সংরক্ষণ করে না এবং সংযুক্ত অক্ষরগুলি সনাক্তকরণের জন্য কার্যকরভাবে আরও কার্যকর সময় প্রয়োজন।

Question 17

এটি অবশ্যই সর্বাধিক মেমরি দক্ষ সমাধান নয়, তবে একটি "সাধারণ" ইউটিএফ -8 নিরাপদ সমাধানের জন্য নিম্নলিখিতটি কাজটি করবে এবং রানগুলি না ভেঙে দেবে।

এটি আমার মতে পৃষ্ঠায় সর্বাধিক পঠনযোগ্য এবং বোধগম্য।

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

    return
}

Question 18

নিম্নোক্ত দুটি পদ্ধতি দ্রুত সমাধানের চেয়ে দ্রুত সঞ্চালিত যা অক্ষরগুলির সংমিশ্রণ সংরক্ষণ করে , যদিও এটি বলে না যে আমি আমার বেঞ্চমার্ক সেটআপে কিছু মিস করছি।

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

Question 19

দ্রষ্টব্য: এই উত্তরটি ২০০৯ সালের, সুতরাং এখনই সম্ভবত আরও ভাল সমাধান রয়েছে।

কিছুটা 'রাউন্ডআউট' দেখায়, এবং সম্ভবত খুব দক্ষ নয়, তবে স্ট্রিংগুলি থেকে কীভাবে রিডার ইন্টারফেসটি ব্যবহার করতে পারা যায় তা চিত্রিত করে। ইউটিএফ 8 স্ট্রিংয়ের সাথে কাজ করার সময় ইন্টারভিেক্টরগুলি বাফার হিসাবেও খুব উপযুক্ত বলে মনে হয়।

এটি 'আকার' অংশটি ছেড়ে দেওয়ার সময় এবং এমনকি সন্নিবেশ দ্বারা ভেক্টরে সন্নিবেশ করানোর সময় আরও ছোট হবে, তবে আমি অনুমান করি যে এটি কম দক্ষ হবে, কারণ পুরো ভেক্টরটি প্রতিবার নতুন রুন যুক্ত হওয়ার পরে একে একে পিছনে ঠেলাঠেলি করা দরকার ।

এই সমাধানটি অবশ্যই 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());
}

Question 20

একটি সংস্করণ যা আমি মনে করি ইউনিকোডে কাজ করে। এটি utf8 এ নির্মিত হয়েছে une রুন ফাংশন:

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

Question 21

রুনে এক প্রকার, তাই এটি ব্যবহার করুন। তদতিরিক্ত, গো সেমিকোলন ব্যবহার করে না।

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

Question 22

কোড নীচে চেষ্টা করুন:

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

আরও তথ্যের জন্য http://golangcookbook.com/chapters/strings/reverse/
এবং http://www.dotnetperls.com/reverse-string-go দেখুন

Question 23

সাধারণ স্ট্রিংয়ের জন্য এ জাতীয় নির্মাণ ব্যবহার করা সম্ভব:

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

Question 24

এর সাথে একটি সাধারণ স্ট্রোক rune:

func ReverseString(s string) string {
    runes := []rune(s)
    size := len(runes)
    for i := 0; i < size/2; i++ {
        runes[size-i-1], runes[i] = runes[i],  runes[size-i-1]
    }
    return string(runes)
}

func main() {
    fmt.Println(ReverseString("Abcdefg 汉语 The God"))
}

: doG ehT 语汉 gfedcbA

Question 25

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

Question 26

এখানে আরও একটি সমাধান রয়েছে:

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

যাইহোক, উপরে ইয়াজুর সমাধানটি আরও মার্জিত কারণ যেহেতু তিনি এই []runeজায়গায় ফালিটি বিপরীত করেছেন ।

Question 27

তবুও আরেকটি সমাধান (টিএম):

package main 
import "fmt"

type Runes []rune

func (s Runes) Reverse() (cp Runes) {
    l := len(s); cp = make(Runes, l)
    // i <= 1/2 otherwise it will mess up with odd length strings
    for i := 0; i <= l/2; i++ { 
        cp[i], cp[l-1-i] = s[l-1-i], s[i] 
    }
    return cp
}

func (s Runes) String() string {
    return string(s)
}

func main() { 
    input := "The quick brown 狐 jumped over the lazy 犬 +odd" 
    r := Runes(input)
    output := r.Reverse()
    valid := string(output.Reverse()) == input
    fmt.Println(len(r), len(output), r, output.Reverse(), valid)
}

Question 28

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

পরীক্ষা

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

আউটপুট

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

Question 29

    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
    }