rs-04-group-consecutive

# Group consecutive runs

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

```rust
pub fn group_consecutive<T: PartialEq + Clone>(items: &[T]) -> Vec<(T, usize)>
```

Collapse runs of consecutive equal elements (a form of run-length encoding).
Walk `items` left to right; each maximal run of equal adjacent elements becomes a
single `(value, run_length)` pair in the output. Pairs appear in the same order
the runs occur, and `run_length` is always at least `1`.

The function is **generic**: it must work for any element type `T` that is
`PartialEq + Clone` (e.g. `i32`, `char`, `String`). Use `PartialEq` to compare
adjacent elements and `Clone` to copy the representative value into the result.
Do not require `T: Copy`, `T: Hash`, or `T: Ord`.

Behavior:

- Empty input returns an empty `Vec`.
- Only **consecutive** equal elements are merged; equal elements separated by a
  different element form separate runs.

Examples:

- `group_consecutive(&[1, 1, 2, 3, 3, 3])` → `vec![(1, 2), (2, 1), (3, 3)]`
- `group_consecutive(&['a', 'a', 'b', 'a'])` → `vec![('a', 2), ('b', 1), ('a', 1)]`
- `group_consecutive::<i32>(&[])` → `vec![]`
- `group_consecutive(&[1, 2, 3])` → `vec![(1, 1), (2, 1), (3, 1)]`
- `group_consecutive(&[7, 7, 7])` → `vec![(7, 3)]`

Use only the standard library. Tests live in `tests/` and call it as
`challenge::group_consecutive`.

use challenge::group_consecutive;

#[test]
fn ints_with_runs() {
    assert_eq!(
        group_consecutive(&[1, 1, 2, 3, 3, 3]),
        vec![(1, 2), (2, 1), (3, 3)]
    );
}

#[test]
fn chars_prove_generic() {
    assert_eq!(
        group_consecutive(&['a', 'a', 'b', 'a']),
        vec![('a', 2), ('b', 1), ('a', 1)]
    );
}

#[test]
fn works_for_owned_strings() {
    let v = vec!["x".to_string(), "x".to_string(), "y".to_string()];
    assert_eq!(
        group_consecutive(&v),
        vec![("x".to_string(), 2), ("y".to_string(), 1)]
    );
}

#[test]
fn empty_input() {
    let out = group_consecutive::<i32>(&[]);
    assert_eq!(out, Vec::<(i32, usize)>::new());
}

#[test]
fn all_distinct() {
    assert_eq!(
        group_consecutive(&[1, 2, 3]),
        vec![(1, 1), (2, 1), (3, 1)]
    );
}

#[test]
fn all_same() {
    assert_eq!(group_consecutive(&[7, 7, 7]), vec![(7, 3)]);
}

#[test]
fn single_element() {
    assert_eq!(group_consecutive(&[42]), vec![(42, 1)]);
}

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
// src/lib.rs

pub fn group_consecutive<T: PartialEq + Clone>(items: &[T]) -> Vec<(T, usize)> {
    let mut result = Vec::new();
    let mut count = 1;

    for i in 1..items.len() {
        if items[i - 1].clone() == items[i] {
            count += 1;
        } else {
            result.push((items[i - 1].clone(), count));
            count = 1;
        }
    }

    // Handle the last run
    if !result.is_empty() {
        result.push((items[result.len() - 1].clone(), count));
    }

    result
}
```

[
  {
    "total": 7,
    "answer": "```rust\n// src/lib.rs\n\npub fn group_consecutive<T: PartialEq + Clone>(items: &[T]) -> Vec<(T, usize)> {\n    let mut result = Vec::new();\n    let mut count = 1;\n\n    for i in 1..items.len() {\n        if items[i - 1].clone() == items[i] {\n            count += 1;\n        } else {\n            result.push((items[i - 1].clone(), count));\n            count = 1;\n        }\n    }\n\n    // Handle the last run\n    if !result.is_empty() {\n        result.push((items[result.len() - 1].clone(), count));\n    }\n\n    result\n}\n```",
    "passed": 2,
    "test_error": "running 0 tests\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n\n\nrunning 7 tests\n. 1/7\nall_same --- FAILED\nall_distinct --- FAILED\n. 4/7\nsingle_element --- FAILED\nints_with_runs --- FAILED\nworks_for_owned_strings --- FAILED\n\nfailures:\n\n---- all_same stdout ----\n\nthread 'all_same' (883083) panicked at tests/group.rs:44:5:\nassertion `left == right` failed\n  left: []\n right: [(7, 3)]\n\n---- all_distinct stdout ----\n\nthread 'all_distinct' (883082) panicked at tests/group.rs:36:5:\nassertion `left == right` failed\n  left: [(1, 1), (2, 1), (2, 1)]\n right: [(1, 1), (2, 1), (3, 1)]\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n\n---- single_element stdout ----\n\nthread 'single_element' (883087) panicked at tests/group.rs:49:5:\nassertion `left == right` failed\n  left: []\n right: [(42, 1)]\n\n---- ints_with_runs stdout ----\n\nthread 'ints_with_runs' (883086) panicked at tests/group.rs:5:5:\nassertion `left == right` failed\n  left: [(1, 2), (2, 1), (1, 3)]\n right: [(1, 2), (2, 1), (3, 3)]\n\n---- works_for_owned_strings stdout ----\n\nthread 'works_for_owned_strings' (883088) panicked at tests/group.rs:22:5:\nassertion `left == right` failed\n  left: [(\"x\", 2), (\"x\", 1)]\n right: [(\"x\", 2), (\"y\", 1)]\n\n\nfailures:\n    all_distinct\n    all_same\n    ints_with_runs\n    single_element\n    works_for_owned_strings\n\ntest result: FAILED. 2 passed; 5 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n\n\nerror: test failed, to rerun pass `--test group`"
  },
  {
    "total": 7,
    "answer": "```rust\n// src/lib.rs\n\npub fn group_consecutive<T: PartialEq + Clone>(items: &[T]) -> Vec<(T, usize)> {\n    let mut result = Vec::new();\n    let mut count = 1;\n\n    for i in 1..items.len() {\n        if items[i - 1].clone() == items[i] {\n            count += 1;\n        } else {\n            result.push((items[i - 1].clone(), count));\n            count = 1;\n        }\n    }\n\n    // Handle the last run\n    if !result.is_empty() {\n        result.push((items[result.len() - 1].clone(), count));\n    }\n\n    result\n}\n```",
    "passed": 2,
    "test_error": "running 0 tests\n\ntest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n\n\nrunning 7 tests\n.. 2/7\nall_distinct --- FAILED\nall_same --- FAILED\nsingle_element --- FAILED\nints_with_runs --- FAILED\nworks_for_owned_strings --- FAILED\n\nfailures:\n\n---- all_distinct stdout ----\n\nthread 'all_distinct' (883214) panicked at tests/group.rs:36:5:\nassertion `left == right` failed\n  left: [(1, 1), (2, 1), (2, 1)]\n right: [(1, 1), (2, 1), (3, 1)]\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n\n---- all_same stdout ----\n\nthread 'all_same' (883215) panicked at tests/group.rs:44:5:\nassertion `left == right` failed\n  left: []\n right: [(7, 3)]\n\n---- single_element stdout ----\n\nthread 'single_element' (883219) panicked at tests/group.rs:49:5:\nassertion `left == right` failed\n  left: []\n right: [(42, 1)]\n\n---- ints_with_runs stdout ----\n\nthread 'ints_with_runs' (883218) panicked at tests/group.rs:5:5:\nassertion `left == right` failed\n  left: [(1, 2), (2, 1), (1, 3)]\n right: [(1, 2), (2, 1), (3, 3)]\n\n---- works_for_owned_strings stdout ----\n\nthread 'works_for_owned_strings' (883220) panicked at tests/group.rs:22:5:\nassertion `left == right` failed\n  left: [(\"x\", 2), (\"x\", 1)]\n right: [(\"x\", 2), (\"y\", 1)]\n\n\nfailures:\n    all_distinct\n    all_same\n    ints_with_runs\n    single_element\n    works_for_owned_strings\n\ntest result: FAILED. 2 passed; 5 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n\n\nerror: test failed, to rerun pass `--test group`"
  },
  {
    "total": 7,
    "answer": "```rust\n// src/lib.rs\n\npub fn group_consecutive<T: PartialEq + Clone>(items: &[T]) -> Vec<(T, usize)> {\n    let mut result = Vec::new();\n    let mut count = 1;\n\n    for i in 1..items.len() {\n        if items[i - 1].clone() == items[i] {\n            count += 1;\n        } else {\n            result.push((items[i - 1].clone(), count));\n            count = 1;\n        }\n    }\n\n    // Handle the last run\n    if !result.is_empty() {\n        result.push((items[result.len() - 1].clone(), count));\n    }\n\n    result\n}\n```",
    "passed": 2,
    "test_error": ""
  }
]