反轉 UTF-8 編碼的字元串

實作一個 reverse 函數，反轉 UTF-8 編碼的字元串中的字元元素。傳入的參數是字元串對應的位元組切片類型（[]byte）。

簡單的實作

首先，不考慮效率，先用一個簡單的邏輯來實作。切片的反轉方法如下：

func reverse(s []int) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

隻要将資料轉成字元切片，然後套用切片反轉的代碼就可以了：

// 先轉成字元切片，然後再用切片的反轉的方法，最後更新參數指向的底層數組
func reverse_rune(slice []byte) {
    r := []rune(string(slice))
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    for i := range slice {
        slice[i] = []byte(string(r))[i]
    }
}

這個方法邏輯清晰，适合之後拿來做随機測試

原地反轉

下面的函數實作了原地反轉。每次讀取第一個字元，把尾部标志位之前的一串字元移到開頭，再把之前讀的字元放到标志位的位置，然後向前移動标志位：

func reverse_byte(slice []byte) {
    for l := len(slice); l > 0; {
        r, size := utf8.DecodeRuneInString(string(slice[0:]))
        copy(slice[0:l], slice[0+size:l])
        copy(slice[l-size:l], []byte(string(r)))
        l -= size
    }
}

這個實作效率還是稍差，之後會做測試比較。

高效的原地反轉

下面的函數，用了很多的标志位，實作了一個高效的原地反轉：

func reverse(s []byte) {
    var (
        lRd, rRd           int  // 讀指針
        lWr, rWr           int  // 寫指針
        lHasRune, rHasRune bool // 是否有字元
        lr, rr             rune // 讀取到的字元
        lsize, rsize       int  // 讀取到字元的寬度
    )
    rRd, rWr = len(s), len(s)
    for lRd < rRd {
        if !lHasRune {
            lr, lsize = utf8.DecodeRune(s[lRd:])
            lRd += lsize
            lHasRune = true
        }
        if !rHasRune {
            rr, rsize = utf8.DecodeLastRune(s[:rRd])
            rRd -= rsize
            rHasRune = true
        }

        if lsize <= rWr-rRd {
            utf8.EncodeRune(s[rWr-lsize:], lr)
            rWr -= lsize
            lHasRune = false
        }
        if rsize <= lRd-lWr {
            utf8.EncodeRune(s[lWr:], rr)
            lWr += rsize
            rHasRune = false
        }
    }

    // 最後還可能會剩個字元沒寫
    if lHasRune {
        utf8.EncodeRune(s[rWr-lsize:], lr)
    }
    if rHasRune {
        utf8.EncodeRune(s[lWr:], rr)
    }
}

測試驗證

下面是測試代碼，來驗證上面的函數的正确性以及效率。

功能測試

基于表的測試很直覺也很簡單，可以友善的添加更多測試用例：

var tests = []struct {
    input string
    want string
}{
    {"abc", "cba"},
    {"123", "321"},
    {"你好，世界!", "!界世，好你"},
    {"a一二三,四五.六,z", "z,六.五四,三二一a"},
}

func TestReverse_rune(t *testing.T) {
    for _, test := range tests {
        s := []byte(test.input)
        reverse_rune(s)
        if string(s) != test.want {
            t.Errorf("reverse(%q) = %q, want %q\n", test.input, string(s), test.want)
        }
    }
}

func TestReverse_byte(t *testing.T) {
    for _, test := range tests {
        s := []byte(test.input)
        reverse_byte(s)
        if string(s) != test.want {
            t.Errorf("reverse(%q) = %q, want %q\n", test.input, string(s), test.want)
        }
    }
}

func TestReverse(t *testing.T) {
    for _, test := range tests {
        s := []byte(test.input)
        reverse(s)
        if string(s) != test.want {
            t.Errorf("reverse(%q) = %q, want %q\n", test.input, string(s), test.want)
        }
    }
}

測試結果：

PS H:\Go\src\gopl\exercise4\e7> go test -run TestReverse -v
=== RUN   TestReverse_rune
--- PASS: TestReverse_rune (0.00s)
=== RUN   TestReverse_byte
--- PASS: TestReverse_byte (0.00s)
=== RUN   TestReverse
--- PASS: TestReverse (0.00s)
PASS
ok      gopl/exercise4/e7       0.263s
PS H:\Go\src\gopl\exercise4\e7>

随機測試

随機測試也是功能測試的一種，通過建構随機輸入來擴充測試的覆寫範圍。有兩種政策：

額外寫一個函數，這個函數使用低效但是清晰的算法，然後檢查兩種實作的輸出是否一緻
建構符合某種模式的輸入，這樣就可以知道對應的輸出。

下面就是用第一種政策寫的随機測試。為了讓輸出的内容有更好的可讀性，選擇了一些熟悉的字元生成随機字元：

// randomSte 傳回一個随機字元串，它的長度和内容都是随機生成的
func randomStr(rng *rand.Rand) string {
    n := rng.Intn(25) // 随機字元串最大長度24
    runes := make([]rune, n)
    for i := 0; i < n; i++ {
        var r rune
        switch rune(rng.Intn(6)) {
        case 0: // ASCII 字母，1個位元組
            r = rune(rng.Intn(0x4B) + 0x30)
        case 1: // 希臘字母，2個位元組
            r = rune(rng.Intn(57) + 0x391)
        case 2: // 日文
            r = rune(rng.Intn(0xBF) + 0x3041)
        case 3: // 韓文
            r = rune(rng.Intn(0x2BA4) + 0xAC00)
        case 4, 5, 6: // 中文
            r = rune(rng.Intn(0x4E00) + 0x51D6)
        }
        runes[i] = r
    }
    return string(runes)
}

func TestRandomReverse(t *testing.T) {
    seed := time.Now().UTC().UnixNano()
    t.Logf("Random seed: %d", seed)
    rng := rand.New(rand.NewSource(seed))
    for i := 0; i < 1000; i++ {
        test := randomStr(rng)
        s1 := []byte(test)
        reverse_rune(s1)
        t.Logf("%s => %s\n", test, string(s1))

        s2 := []byte(test)
        reverse_byte(s2)
        if string(s1) != string(s2) {
            t.Errorf("reverse_byte(%q) = %q, want %q\n", test, string(s2), string(s1))
        }

        s3 := []byte(test)
        reverse(s3)
        if string(s1) != string(s3) {
            t.Errorf("reverse_byte(%q) = %q, want %q\n", test, string(s3), string(s1))
        }
    }
}

測試結果：

PS H:\Go\src\gopl\exercise4\e7> go test -run Random
PASS
ok      gopl/exercise4/e7       0.298s
PS H:\Go\src\gopl\exercise4\e7>

還可以加上 -v 參數，檢視詳細的測試日志。

基準測試

基準測試也沒什麼特别的，把功能測試的測試用例全部跑一遍：

func BenchmarkReverse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, test := range tests {
            reverse([]byte(test.input))
        }
    }
}

func BenchmarkReverse_rune(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, test := range tests {
            reverse_rune([]byte(test.input))
        }   }
}

func BenchmarkReverse_byte(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, test := range tests {
            reverse_byte([]byte(test.input))
        }   }
}

測試結果：

PS H:\Go\src\gopl\exercise4\e7> go test -benchmem -bench .
goos: windows
goarch: amd64
pkg: gopl/exercise4/e7
BenchmarkReverse-8               5000000               286 ns/op               0 B/op          0 allocs/op
BenchmarkReverse_rune-8           500000              3610 ns/op               0 B/op          0 allocs/op
BenchmarkReverse_byte-8          3000000               583 ns/op               0 B/op          0 allocs/op
PASS
ok      gopl/exercise4/e7       6.226s
PS H:\Go\src\gopl\exercise4\e7>

轉載于:https://blog.51cto.com/steed/2389489

反轉 UTF-8 編碼的字元串反轉 UTF-8 編碼的字元串測試驗證

反轉 UTF-8 編碼的字元串

簡單的實作

原地反轉

高效的原地反轉

測試驗證

功能測試

随機測試

基準測試

繼續閱讀

c++ 比對相鄰元素相等的元素（adjacent_find）

DateTimePicker 控件的格式設定

CentOS7下TestLink環境的部署

軟體測試基礎_對應TestLink整理的測試計劃流程步驟

[HTML5]自定義屬性 data-* 和 jQuery.data 詳解

七牛雲-C#SDK-上傳-前期準備

2021-2025年中國運動療法（KT）帶行業市場供需與戰略研究報告

[轉]iOS微信小視訊優化心得

2021年危險化學品經營機關安全管理人員考試題庫及危險化學品經營機關安全管理人員考試技巧

C++數組引用C++數組引用

[C++學習曆程]基礎部分 C++中的函數學習

無人機--飛控科普

使用遞減運算符在循環中按遞減順序列印10到0之間的整數

指針，常量和類型别名

VS C++常見問題集錦1.在Vs中編C出現這兩個錯誤是什麼原因？錯誤1：error LNK2005: _main 已經在 *** 中定義

測試面試題整理