sounio-benchmarks/020_run_length_encode.sio at main · Sounio-lang/sounio-benchmarks · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
//@ run-pass
// HumanEval 020: Run-Length Encoding
//
// RLE encode a byte array. Output format: each run is stored as
// (count, value) pairs in the output array. Returns the number of
// pairs (output length = pairs * 2).

struct RLEResult { data: [i64; 512], num_pairs: i64 }

fn rle_encode(input: [i64; 256], n: i64) -> RLEResult with Mut, Panic {
    var result = RLEResult { data: [0; 512], num_pairs: 0 }
    if n == 0 { return result }

    var i: i64 = 0
    var out_idx: i64 = 0
    while i < n {
        let val = input[i]
        var count: i64 = 1
        while i + count < n && input[i + count] == val {
            count = count + 1
        }
        result.data[out_idx] = count
        result.data[out_idx + 1] = val
        out_idx = out_idx + 2
        result.num_pairs = result.num_pairs + 1
        i = i + count
    }
    result
}

fn main() -> i64 with IO, Mut, Panic, Div {
    // Test 1: [1,1,1,2,2,3] -> [(3,1),(2,2),(1,3)]
    var a1: [i64; 256] = [0; 256]
    a1[0] = 1
    a1[1] = 1
    a1[2] = 1
    a1[3] = 2
    a1[4] = 2
    a1[5] = 3
    let r1 = rle_encode(a1, 6)
    assert(r1.num_pairs == 3)
    assert(r1.data[0] == 3)
    assert(r1.data[1] == 1)
    assert(r1.data[2] == 2)
    assert(r1.data[3] == 2)
    assert(r1.data[4] == 1)
    assert(r1.data[5] == 3)

    // Test 2: [5,5,5,5,5] -> [(5,5)]
    var a2: [i64; 256] = [0; 256]
    a2[0] = 5
    a2[1] = 5
    a2[2] = 5
    a2[3] = 5
    a2[4] = 5
    let r2 = rle_encode(a2, 5)
    assert(r2.num_pairs == 1)
    assert(r2.data[0] == 5)
    assert(r2.data[1] == 5)

    // Test 3: [1,2,3,4] -> [(1,1),(1,2),(1,3),(1,4)] (no repeats)
    var a3: [i64; 256] = [0; 256]
    a3[0] = 1
    a3[1] = 2
    a3[2] = 3
    a3[3] = 4
    let r3 = rle_encode(a3, 4)
    assert(r3.num_pairs == 4)
    assert(r3.data[0] == 1)
    assert(r3.data[1] == 1)
    assert(r3.data[2] == 1)
    assert(r3.data[3] == 2)
    assert(r3.data[4] == 1)
    assert(r3.data[5] == 3)
    assert(r3.data[6] == 1)
    assert(r3.data[7] == 4)

    // Test 4: single element [42] -> [(1,42)]
    var a4: [i64; 256] = [0; 256]
    a4[0] = 42
    let r4 = rle_encode(a4, 1)
    assert(r4.num_pairs == 1)
    assert(r4.data[0] == 1)
    assert(r4.data[1] == 42)

    // Test 5: empty -> 0 pairs
    var a5: [i64; 256] = [0; 256]
    let r5 = rle_encode(a5, 0)
    assert(r5.num_pairs == 0)

    // Test 6: [7,7,3,3,3,7,7] -> [(2,7),(3,3),(2,7)]
    var a6: [i64; 256] = [0; 256]
    a6[0] = 7
    a6[1] = 7
    a6[2] = 3
    a6[3] = 3
    a6[4] = 3
    a6[5] = 7
    a6[6] = 7
    let r6 = rle_encode(a6, 7)
    assert(r6.num_pairs == 3)
    assert(r6.data[0] == 2)
    assert(r6.data[1] == 7)
    assert(r6.data[2] == 3)
    assert(r6.data[3] == 3)
    assert(r6.data[4] == 2)
    assert(r6.data[5] == 7)

    println("020_run_length_encode: ALL TESTS PASSED")
    0
}