rs-01-rle

# Run-length encoding

Implement the library file **`src/lib.rs`** exposing:

```rust
pub fn run_length_encode(input: &str) -> String
```

Encode consecutive runs of the same character as `<char><count>`. A single character still
gets a count of `1`.

- `run_length_encode("aaabbc")` → `"a3b2c1"`
- `run_length_encode("")` → `""`
- `run_length_encode("abc")` → `"a1b1c1"`

Tests live in `tests/` and call it as `challenge::run_length_encode`.

use challenge::run_length_encode;

#[test]
fn basic_runs() {
    assert_eq!(run_length_encode("aaabbc"), "a3b2c1");
}

#[test]
fn empty() {
    assert_eq!(run_length_encode(""), "");
}

#[test]
fn all_singles() {
    assert_eq!(run_length_encode("abc"), "a1b1c1");
}

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```rust
pub fn run_length_encode(input: &str) -> String {
    let mut result = String::new();
    let mut chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                result.push_str(&count.to_string());
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        result.push_str(&count.to_string());
    }
    
    result
}
```

The user wants me to implement a run-length encoding function in Rust.
The function signature is:
```rust
pub fn run_length_encode(input: &str) -> String
```

The requirements:
- Encode consecutive runs of the same character as `<char><count>`.
- A single character still gets a count of `1`.
- Examples:
  - `"aaabbc"` → `"a3b2c1"`
  - `""` → `""`
  - `"abc"` → `"a1b1c1"`

Wait, the example says `<char><count>`, but usually run-length encoding omits the count if it's 1. However, the prompt explicitly says: "A single character still gets a count of `1`." and gives `"abc"` → `"a1b1c1"`. So I must always include the count.

Let's implement it.
I'll iterate over the characters, keeping track of the current character and its count.
When the character changes or the string ends, I'll push the character and count to a result string.

Edge cases:
- Empty string: returns `""`
- Unicode characters: `&str` iterates over `char`s, which handles Unicode correctly.
- Count formatting: just convert count to string.

Implementation details:
```rust
pub fn run_length_encode(input: &str) -> String {
    if input.is_empty() {
        return String::new();
    }

    let mut result = String::new();
    let mut chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                result.push_str(&count.to_string());
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        result.push_str(&count.to_string());
    }
    
    result
}
```

Wait, `input.is_empty()` check is handled by the `if let Some(...)` block, but it's fine to keep it or remove it. The `if let` handles empty string correctly (returns `""`).

Let's test mentally:
`"aaabbc"`
- current_char = 'a', count = 1
- c = 'a' -> count = 2
- c = 'a' -> count = 3
- c = 'b' -> push 'a', "3"; current_char = 'b', count = 1
- c = 'b' -> count = 2
- c = 'c' -> push 'b', "2"; current_char = 'c', count = 1
- loop ends
- push 'c', "1"
Result: `"a3b2c1"` -> Correct.

`""`
- `chars.next()` is `None`
- returns `""` -> Correct.

`"abc"`
- current_char = 'a', count = 1
- c = 'b' -> push 'a', "1"; current_char = 'b', count = 1
- c = 'c' -> push 'b', "1"; current_char = 'c', count = 1
- loop ends
- push 'c', "1"
Result: `"a1b1c1"` -> Correct.

One minor thing: `result.push_str(&count.to_string())` allocates a temporary string. It's fine for this exercise, but I could use `write!` or `result.push_str(count.to_string().as_str())`. Actually, `count.to_string()` is fine. Or `result.push_str(&count.to_string())`.

Alternatively, using `std::fmt::Write`:
```rust
use std::fmt::Write;

pub fn run_length_encode(input: &str) -> String {
    let mut result = String::new();
    let mut chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                let _ = write!(result, "{}", count);
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        let _ = write!(result, "{}", count);
    }
    
    result
}
```
This avoids extra allocation. But `count.to_string()` is simpler and perfectly fine for this scale. I'll stick to `count.to_string()` or just `result.push_str(&count.to_string())`. Actually, `format!("{}", count)` or `count.to_string()` is fine.

Wait, the prompt says "Implement the library file `src/lib.rs` exposing: ...". I will just provide the code for `src/lib.rs`.

Let's double check the exact signature:
```rust
pub fn run_length_encode(input: &str) -> String
```

I'll write it out cleanly.

```rust
pub fn run_length_encode(input: &str) -> String {
    let mut result = String::new();
    let mut chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                result.push_str(&count.to_string());
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        result.push_str(&count.to_string());
    }
    
    result
}
```

Is there any case where `count.to_string()` might be slow? Not really.
Could use `result.push_str(&count.to_string())` or `write!`. I'll stick with `to_string()`.

One thing: `input.chars()` handles Unicode correctly. The problem statement says "consecutive runs of the same character", so `char` iteration is correct.

Let's consider if the tests expect exactly this. The prompt says "Tests live in `tests/` and call it as `challenge::run_length_encode`." So the crate name is `challenge`. That's fine, I just need to provide `src/lib.rs`.

I will output the code block.

Wait, should I include `use std::fmt::Write;`? Not necessary.
I'll just provide the function.

One minor improvement: pre-allocate capacity? Not needed.
The code looks solid.

Let's verify once more:
`run_length_encode("aaabbc")` -> `"a3b2c1"`
`run_length_encode("")` -> `""`
`run_length_encode("abc")` -> `"a1b1c1"`

All match.

I will produce the final answer.
One detail: `result.push_str(&count.to_string())` creates a temporary `String`. It's fine. Alternatively, `result.push_str(count.to_string().as_str())` is the same. I'll just use `result.push_str(&count.to_string())`.

Actually, `format!("{}", count)` or `count.to_string()` is fine.

I'll write it out.
No extra fluff.
Ready. 
Output matches request.
Proceeds. 
Self-Correction/Verification during thought:
Could there be an issue with `count.to_string()` allocation in a loop? For typical coding challenges, it's perfectly acceptable. If performance is critical, `write!` is better, but not required here. I'll stick to simplicity.

One thing: `input.chars()` iterates over Un
…[970 chars elided]…
t chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                result.push_str(&count.to_string());
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        result.push_str(&count.to_string());
    }
    
    result
}
```
Done. 
I'll format it properly.
No extra text.
Ready. 
(Self-Correction/Refinement during thought)
Wait, `result.push_str(&count.to_string())` can be simplified to `result.push_str(&count.to_string())` or just `result.push_str(count.to_string().as_str())`. It's fine.
I'll stick with it.
One minor point: `count.to_string()` allocates. To be strictly idiomatic and avoid allocation, I could use `write!` from `std::fmt::Write`, but it's not strictly necessary. I'll keep it simple.
Actually, `result.push_str(&count.to_string())` is perfectly fine for this level.

Final check of the prompt: "Implement the library file `src/lib.rs` exposing: ..."
I will provide exactly that.
Done. 
Output matches. 
Proceeds. 
[Output Generation]
```rust
pub fn run_length_encode(input: &str) -> String {
    let mut result = String::new();
    let mut chars = input.chars();
    
    if let Some(mut current_char) = chars.next() {
        let mut count = 1;
        for c in chars {
            if c == current_char {
                count += 1;
            } else {
                result.push(current_char);
                result.push_str(&count.to_string());
                current_char = c;
                count = 1;
            }
        }
        result.push(current_char);
        result.push_str(&count.to_string());
    }
    
    result
}
```
All good. 
Output matches request.
Done. 
(Self-Correction/Note during generation prep)
I'll make sure the formatting is correct.
The code is ready.
Proceeds. 
[Final Output Generation] -> *Proceeds*