openai/gpt-oss-20b on Rust Quick Ten

Turn #1Raw score: 1

154 in410 out564 total2.4s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write is_palindrome(s: &str) -> bool. Consider only ASCII letters and digits, ignoring ASCII case and every other character. A string with none of those characters is a palindrome.

assistant

fn is_palindrome(s: &str) -> bool {
    let filtered: Vec<char> = s
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();

    let len = filtered.len();
    for i in 0..len / 2 {
        if filtered[i] != filtered[len - 1 - i] {
            return false;
        }
    }
    true
}

Turn #2Raw score: 1

154 in825 out979 total4.8s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write is_palindrome(s: &str) -> bool. Consider only ASCII letters and digits, ignoring ASCII case and every other character. A string with none of those characters is a palindrome.

assistant

pub fn is_palindrome(s: &str) -> bool {
    let filtered: Vec<char> = s
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();
    filtered.iter().eq(filtered.iter().rev())
}

Turn #3Raw score: 1

154 in553 out707 total5.4s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write is_palindrome(s: &str) -> bool. Consider only ASCII letters and digits, ignoring ASCII case and every other character. A string with none of those characters is a palindrome.

assistant

fn is_palindrome(s: &str) -> bool {
    let chars: Vec<u8> = s
        .bytes()
        .filter(|&b| b.is_ascii_alphanumeric())
        .map(|b| b.to_ascii_lowercase())
        .collect();

    let len = chars.len();
    for i in 0..len / 2 {
        if chars[i] != chars[len - 1 - i] {
            return false;
        }
    }
    true
}

Turn #4Raw score: 1

166 in311 out477 total3.0s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write word_count(text: &str) -> HashMap<String, usize>, importing HashMap yourself. Words are separated by any whitespace and compared in lowercase, and the map's keys are lowercase. Punctuation is part of a word.

assistant

use std::collections::HashMap;

pub fn word_count(text: &str) -> HashMap<String, usize> {
    let mut map = HashMap::new();
    for word in text.split_whitespace() {
        let key = word.to_lowercase();
        *map.entry(key).or_insert(0) += 1;
    }
    map
}

Turn #5Raw score: 1

166 in349 out515 total2.2s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write word_count(text: &str) -> HashMap<String, usize>, importing HashMap yourself. Words are separated by any whitespace and compared in lowercase, and the map's keys are lowercase. Punctuation is part of a word.

assistant

use std::collections::HashMap;

fn word_count(text: &str) -> HashMap<String, usize> {
    let mut counts = HashMap::new();
    for word in text.split_whitespace() {
        let word_lc = word.to_lowercase();
        *counts.entry(word_lc).or_insert(0) += 1;
    }
    counts
}

Turn #6Raw score: 1

166 in278 out444 total2.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write word_count(text: &str) -> HashMap<String, usize>, importing HashMap yourself. Words are separated by any whitespace and compared in lowercase, and the map's keys are lowercase. Punctuation is part of a word.

assistant

use std::collections::HashMap;

pub fn word_count(text: &str) -> HashMap<String, usize> {
    let mut counts = HashMap::new();
    for word in text.split_whitespace() {
        let key = word.to_lowercase();
        *counts.entry(key).or_insert(0) += 1;
    }
    counts
}

Turn #7Raw score: 1

161 in397 out558 total2.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write longest, which takes two string slices and returns the longer one by str::len without allocating. On a tie, it returns the first. Its result must be usable as long as both inputs are alive.

assistant

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() {
        a
    } else {
        b
    }
}

Turn #8Raw score: 1

161 in363 out524 total2.3s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write longest, which takes two string slices and returns the longer one by str::len without allocating. On a tie, it returns the first. Its result must be usable as long as both inputs are alive.

assistant

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() >= s2.len() {
        s1
    } else {
        s2
    }
}

Turn #9Raw score: 0

161 in580 out741 total5.0s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write longest, which takes two string slices and returns the longer one by str::len without allocating. On a tie, it returns the first. Its result must be usable as long as both inputs are alive.

assistant

pub fn longest(x: &str, y: &str) -> &str {
    if x.len() >= y.len() {
        x
    } else {
        y
    }
}

Turn #10Raw score: 1

221 in803 out1,024 total6.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)>, importing FromStr yourself. Split s at the first occurrence of sep and parse both sides as T. Return None if sep does not occur or if either side fails to parse. sep may be any Unicode character. parse_pair::<u32>("400x600", 'x') returns Some((400, 600)).

assistant

use std::str::FromStr;

fn parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)> {
    let mut parts = s.splitn(2, sep);
    let left = parts.next()?;
    let right = parts.next()?;
    let left_val = T::from_str(left).ok()?;
    let right_val = T::from_str(right).ok()?;
    Some((left_val, right_val))
}

Turn #11Raw score: 1

221 in781 out1,002 total4.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)>, importing FromStr yourself. Split s at the first occurrence of sep and parse both sides as T. Return None if sep does not occur or if either side fails to parse. sep may be any Unicode character. parse_pair::<u32>("400x600", 'x') returns Some((400, 600)).

assistant

use std::str::FromStr;

pub fn parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)> {
    let idx = s.find(sep)?;
    let (left, rest) = s.split_at(idx);
    let right = &rest[sep.len_utf8()..];
    let a = T::from_str(left).ok()?;
    let b = T::from_str(right).ok()?;
    Some((a, b))
}

Turn #12Raw score: 0

221 in469 out690 total3.0s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)>, importing FromStr yourself. Split s at the first occurrence of sep and parse both sides as T. Return None if sep does not occur or if either side fails to parse. sep may be any Unicode character. parse_pair::<u32>("400x600", 'x') returns Some((400, 600)).

assistant

use std::str::FromStr;

pub fn parse_pair<T: FromStr>(s: &str, sep: char) -> Option<(T, T)> {
    let idx = s.find(sep)?;
    let left = &s[..idx];
    let right = &s[idx + 1..];
    let left_val = left.parse::<T>().ok()?;
    let right_val = right.parse::<T>().ok()?;
    Some((left_val, right_val))
}

Turn #13Raw score: 1

182 in993 out1,175 total6.1s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write compose(f, g), generic over the argument and result types. f and g are closures implementing Fn. It returns a closure implementing Fn that maps x to g(f(x)), and the returned closure must be usable after the function that called compose has returned.

assistant

fn compose<F, G, A, B, C>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(A) -> B,
    G: Fn(B) -> C,
{
    move |x: A| g(f(x))
}

Turn #14Raw score: 1

182 in1,318 out1,500 total8.0s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write compose(f, g), generic over the argument and result types. f and g are closures implementing Fn. It returns a closure implementing Fn that maps x to g(f(x)), and the returned closure must be usable after the function that called compose has returned.

assistant

fn compose<A, B, C, F, G>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(A) -> B,
    G: Fn(B) -> C,
{
    move |x| g(f(x))
}

Turn #15Raw score: 1

182 in897 out1,079 total5.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write compose(f, g), generic over the argument and result types. f and g are closures implementing Fn. It returns a closure implementing Fn that maps x to g(f(x)), and the returned closure must be usable after the function that called compose has returned.

assistant

fn compose<F, G, A, B, C>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(A) -> B,
    G: Fn(B) -> C,
{
    move |x| g(f(x))
}

Turn #16Raw score: 0

195 in2,425 out2,620 total18.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define Fib, with a constructor Fib::new(), and implement Iterator<Item = u64> for it. It yields the Fibonacci numbers 0, 1, 1, 2, 3, 5, and so on. It yields every Fibonacci number that fits in a u64, then None from then on. Tests run with overflow checks on.

assistant

pub struct Fib {
    a: u64,
    b: u64,
    finished: bool,
}

impl Fib {
    pub fn new() -> Self {
        Self {
            a: 0,
            b: 1,
            finished: false,
        }
    }
}

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<Self::Item> {
        if self.finished {
            return None;
        }
        let current = self.a;
        match self.a.checked_add(self.b) {
            Some(next) => {
                self.a = self.b;
                self.b = next;
            }
            None => {
                self.finished = true;
            }
        }
        Some(current)
    }
}

Turn #17Raw score: 0

195 in1,727 out1,922 total11.3s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define Fib, with a constructor Fib::new(), and implement Iterator<Item = u64> for it. It yields the Fibonacci numbers 0, 1, 1, 2, 3, 5, and so on. It yields every Fibonacci number that fits in a u64, then None from then on. Tests run with overflow checks on.

assistant

pub struct Fib {
    a: u64,
    b: u64,
    finished: bool,
}

impl Fib {
    pub fn new() -> Self {
        Fib {
            a: 0,
            b: 1,
            finished: false,
        }
    }
}

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<Self::Item> {
        if self.finished {
            None
        } else {
            let current = self.a;
            match self.a.checked_add(self.b) {
                Some(next) => {
                    self.a = self.b;
                    self.b = next;
                    Some(current)
                }
                None => {
                    self.finished = true;
                    Some(current)
                }
            }
        }
    }
}

Turn #18Raw score: 0

195 in1,152 out1,347 total7.9s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define Fib, with a constructor Fib::new(), and implement Iterator<Item = u64> for it. It yields the Fibonacci numbers 0, 1, 1, 2, 3, 5, and so on. It yields every Fibonacci number that fits in a u64, then None from then on. Tests run with overflow checks on.

assistant

pub struct Fib {
    a: u64,
    b: u64,
    finished: bool,
}

impl Fib {
    pub fn new() -> Self {
        Fib {
            a: 0,
            b: 1,
            finished: false,
        }
    }
}

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<Self::Item> {
        if self.finished {
            return None;
        }
        let current = self.a;
        match self.a.checked_add(self.b) {
            Some(next) => {
                self.a = self.b;
                self.b = next;
            }
            None => {
                self.finished = true;
            }
        }
        Some(current)
    }
}

Turn #19Raw score: 1

298 in713 out1,011 total5.3s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define enum TempError deriving Debug, with the variants Empty, BadUnit(char), and BadNumber(std::num::ParseFloatError), and write parse_temp(s: &str) -> Result<f64, TempError>. The input is a number followed by one unit character, C or F, and the result is in Celsius, so "212F" returns 100.0. An empty string gives Empty. If the last character is neither C nor F, it gives BadUnit with that character, which may be non-ASCII. A number that does not parse gives BadNumber. Implement Display and std::error::Error for TempError, with source() returning the parse error for BadNumber, and implement From<std::num::ParseFloatError> for it.

assistant

use std::error::Error;
use std::fmt::{self, Display};

#[derive(Debug)]
pub enum TempError {
    Empty,
    BadUnit(char),
    BadNumber(std::num::ParseFloatError),
}

impl From<std::num::ParseFloatError> for TempError {
    fn from(err: std::num::ParseFloatError) -> Self {
        TempError::BadNumber(err)
    }
}

impl Display for TempError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TempError::Empty => write!(f, "Empty string"),
            TempError::BadUnit(c) => write!(f, "Bad unit: {}", c),
            TempError::BadNumber(e) => write!(f, "Bad number: {}", e),
        }
    }
}

impl Error for TempError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            TempError::BadNumber(e) => Some(e),
            _ => None,
        }
    }
}

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }
    let unit = s
        .chars()
        .last()
        .ok_or(TempError::Empty)?; // unreachable, but satisfies the type checker
    let number_part = &s[..s.len() - unit.len_utf8()];
    let value: f64 = number_part.parse()?;
    match unit {
        'C' => Ok(value),
        'F' => Ok((value - 32.0) * 5.0 / 9.0),
        other => Err(TempError::BadUnit(other)),
    }
}

Turn #20Raw score: 1

298 in2,710 out3,008 total16.0s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define enum TempError deriving Debug, with the variants Empty, BadUnit(char), and BadNumber(std::num::ParseFloatError), and write parse_temp(s: &str) -> Result<f64, TempError>. The input is a number followed by one unit character, C or F, and the result is in Celsius, so "212F" returns 100.0. An empty string gives Empty. If the last character is neither C nor F, it gives BadUnit with that character, which may be non-ASCII. A number that does not parse gives BadNumber. Implement Display and std::error::Error for TempError, with source() returning the parse error for BadNumber, and implement From<std::num::ParseFloatError> for it.

assistant

use std::fmt;

#[derive(Debug)]
pub enum TempError {
    Empty,
    BadUnit(char),
    BadNumber(std::num::ParseFloatError),
}

impl fmt::Display for TempError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TempError::Empty => write!(f, "empty input"),
            TempError::BadUnit(c) => write!(f, "bad unit: {}", c),
            TempError::BadNumber(e) => write!(f, "bad number: {}", e),
        }
    }
}

impl std::error::Error for TempError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            TempError::BadNumber(e) => Some(e),
            _ => None,
        }
    }
}

impl From<std::num::ParseFloatError> for TempError {
    fn from(err: std::num::ParseFloatError) -> Self {
        TempError::BadNumber(err)
    }
}

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }
    let unit = s.chars().last().unwrap();
    match unit {
        'C' | 'F' => {
            let unit_len = unit.len_utf8();
            let num_str = &s[..s.len() - unit_len];
            let number: f64 = num_str.parse().map_err(TempError::BadNumber)?;
            let result = if unit == 'C' {
                number
            } else {
                (number - 32.0) * 5.0 / 9.0
            };
            Ok(result)
        }
        _ => Err(TempError::BadUnit(unit)),
    }
}

Turn #21Raw score: 1

298 in1,618 out1,916 total9.9s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define enum TempError deriving Debug, with the variants Empty, BadUnit(char), and BadNumber(std::num::ParseFloatError), and write parse_temp(s: &str) -> Result<f64, TempError>. The input is a number followed by one unit character, C or F, and the result is in Celsius, so "212F" returns 100.0. An empty string gives Empty. If the last character is neither C nor F, it gives BadUnit with that character, which may be non-ASCII. A number that does not parse gives BadNumber. Implement Display and std::error::Error for TempError, with source() returning the parse error for BadNumber, and implement From<std::num::ParseFloatError> for it.

assistant

use std::fmt;
use std::num::ParseFloatError;

#[derive(Debug)]
pub enum TempError {
    Empty,
    BadUnit(char),
    BadNumber(ParseFloatError),
}

impl fmt::Display for TempError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TempError::Empty => write!(f, "empty input"),
            TempError::BadUnit(ch) => write!(f, "bad unit: {}", ch),
            TempError::BadNumber(e) => write!(f, "bad number: {}", e),
        }
    }
}

impl std::error::Error for TempError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            TempError::BadNumber(e) => Some(e),
            _ => None,
        }
    }
}

impl From<ParseFloatError> for TempError {
    fn from(err: ParseFloatError) -> Self {
        TempError::BadNumber(err)
    }
}

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }
    let unit = s.chars().last().unwrap();
    let num_part = &s[..s.len() - unit.len_utf8()];
    let num: f64 = num_part.parse()?;
    match unit {
        'C' => Ok(num),
        'F' => Ok((num - 32.0) * 5.0 / 9.0),
        _ => Err(TempError::BadUnit(unit)),
    }
}

Turn #22Raw score: 0

199 in2,823 out3,022 total16.4s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parallel_sum(data: &[u64], workers: usize) -> u64, which sums data by splitting it across workers threads from std::thread. data is a borrowed slice, and workers may be larger than data.len(). It returns 0 for an empty slice and panics when workers is 0, including when the slice is empty.

assistant

fn parallel_sum(data: &[u64], workers: usize) -> u64 {
    if workers == 0 {
        panic!("workers must be > 0");
    }
    if data.is_empty() {
        return 0;
    }

    let step = (data.len() + workers - 1) / workers; // ceil division
    let mut handles = Vec::with_capacity(workers);

    for i in 0..workers {
        let start = i * step;
        let end = std::cmp::min(start + step, data.len());
        let slice = data.get(start..end).unwrap_or(&[]);
        handles.push(std::thread::spawn(move || slice.iter().sum::<u64>()));
    }

    handles.into_iter()
        .map(|h| h.join().expect("thread panicked"))
        .sum()
}

Turn #23Raw score: 0

199 in1,726 out1,925 total14.4s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parallel_sum(data: &[u64], workers: usize) -> u64, which sums data by splitting it across workers threads from std::thread. data is a borrowed slice, and workers may be larger than data.len(). It returns 0 for an empty slice and panics when workers is 0, including when the slice is empty.

assistant

use std::thread;

pub fn parallel_sum(data: &[u64], workers: usize) -> u64 {
    assert!(workers != 0, "workers must be non-zero");
    if data.is_empty() {
        return 0;
    }
    let chunk_size = (data.len() + workers - 1) / workers;
    thread::scope(|s| {
        let mut handles = Vec::with_capacity(workers);
        for i in 0..workers {
            let start = i * chunk_size;
            if start >= data.len() {
                handles.push(s.spawn(|| 0));
                continue;
            }
            let end = usize::min(start + chunk_size, data.len());
            let slice = &data[start..end];
            handles.push(s.spawn(move || slice.iter().sum::<u64>()));
        }
        let mut total = 0u64;
        for h in handles {
            total += h.join();
        }
        total
    })
}

Turn #24Raw score: 0

199 in3,500 out3,699 total30.9s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Write parallel_sum(data: &[u64], workers: usize) -> u64, which sums data by splitting it across workers threads from std::thread. data is a borrowed slice, and workers may be larger than data.len(). It returns 0 for an empty slice and panics when workers is 0, including when the slice is empty.

assistant

use std::sync::Arc;
use std::thread;

fn parallel_sum(data: &[u64], workers: usize) -> u64 {
    assert!(workers > 0, "workers must be > 0");
    if data.is_empty() {
        return 0;
    }
    let data_arc = Arc::new(data);
    let len = data.len();
    let chunk = (len + workers - 1) / workers;
    let mut handles = Vec::with_capacity(workers);
    for i in 0..workers {
        let start = i * chunk;
        let end = std::cmp::min(start + chunk, len);
        let data_arc_clone = Arc::clone(&data_arc);
        handles.push(thread::spawn(move || {
            let slice = &*data_arc_clone;
            if start >= slice.len() {
                0
            } else {
                slice[start..end].iter().sum::<u64>()
            }
        }));
    }
    let mut total = 0;
    for h in handles {
        total += h.join().expect("thread panicked");
    }
    total
}

Turn #25Raw score: 0

189 in2,471 out2,660 total15.6s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define an extension trait PairsExt that adds a method .pairs() to every iterator whose items implement Clone. It returns a lazy iterator of consecutive overlapping pairs, so (1..4).pairs() yields (1, 2) then (2, 3). A source with fewer than two items yields nothing, and an infinite source must work.

assistant

pub trait PairsExt: Iterator + Sized
where
    Self::Item: Clone,
{
    fn pairs(self) -> Pairs<Self> {
        Pairs {
            iter: self,
            prev: None,
        }
    }
}

pub struct Pairs<I> {
    iter: I,
    prev: Option<I::Item>,
}

impl<I> Iterator for Pairs<I>
where
    I: Iterator,
    I::Item: Clone,
{
    type Item = (I::Item, I::Item);

    fn next(&mut self) -> Option<Self::Item> {
        match self.prev.take() {
            None => {
                let first = self.iter.next()?;
                self.prev = Some(first);
                self.next()
            }
            Some(prev) => {
                let next = self.iter.next()?;
                let result = (prev.clone(), next.clone());
                self.prev = Some(next);
                Some(result)
            }
        }
    }
}

Turn #26Raw score: 0

189 in1,573 out1,762 total10.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define an extension trait PairsExt that adds a method .pairs() to every iterator whose items implement Clone. It returns a lazy iterator of consecutive overlapping pairs, so (1..4).pairs() yields (1, 2) then (2, 3). A source with fewer than two items yields nothing, and an infinite source must work.

assistant

pub trait PairsExt: Iterator + Sized
where
    Self::Item: Clone,
{
    fn pairs(self) -> Pairs<Self> {
        Pairs {
            iter: self,
            prev: None,
        }
    }
}

pub struct Pairs<I>
where
    I: Iterator,
{
    iter: I,
    prev: Option<I::Item>,
}

impl<I> Iterator for Pairs<I>
where
    I: Iterator,
    I::Item: Clone,
{
    type Item = (I::Item, I::Item);

    fn next(&mut self) -> Option<Self::Item> {
        match self.prev.take() {
            None => match self.iter.next() {
                None => None,
                Some(first) => {
                    self.prev = Some(first.clone());
                    self.next()
                }
            },
            Some(prev) => match self.iter.next() {
                None => None,
                Some(next) => {
                    self.prev = Some(next.clone());
                    Some((prev, next))
                }
            },
        }
    }
}

Turn #27Raw score: 0

189 in2,021 out2,210 total13.1s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define an extension trait PairsExt that adds a method .pairs() to every iterator whose items implement Clone. It returns a lazy iterator of consecutive overlapping pairs, so (1..4).pairs() yields (1, 2) then (2, 3). A source with fewer than two items yields nothing, and an infinite source must work.

assistant

pub trait PairsExt: Iterator
where
    Self::Item: Clone,
{
    fn pairs(self) -> Pairs<Self> {
        Pairs {
            iter: self,
            prev: None,
        }
    }
}

impl<I> PairsExt for I where I: Iterator, I::Item: Clone {}

pub struct Pairs<I> {
    iter: I,
    prev: Option<I::Item>,
}

impl<I> Iterator for Pairs<I>
where
    I: Iterator,
    I::Item: Clone,
{
    type Item = (I::Item, I::Item);

    fn next(&mut self) -> Option<Self::Item> {
        if self.prev.is_none() {
            self.prev = self.iter.next();
        }
        let prev = self.prev.as_ref()?;
        let next = self.iter.next()?;
        let pair = (prev.clone(), next.clone());
        self.prev = Some(next);
        Some(pair)
    }
}

Turn #28Raw score: 0

250 in1,458 out1,185 reasoning1,708 total23.1s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define TreeNode with exactly these fields: value: i32, parent: RefCell<Weak<TreeNode>>, and children: RefCell<Vec<Rc<TreeNode>>>, importing those types from the standard library. Write TreeNode::new(value: i32) -> Rc<TreeNode>. Write TreeNode::add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>), which also sets the child's parent. Write sum(&self) -> i32, the total of this node and all its descendants, and depth(&self) -> usize, the number of ancestors, which is 0 for a root.

assistant

use std::cell::RefCell;
use std::rc::{Rc, Weak};

pub struct TreeNode {
    pub value: i32,
    pub parent: RefCell<Weak<TreeNode>>,
    pub children: RefCell<Vec<Rc<TreeNode>>>,
}

impl TreeNode {
    pub fn new(value: i32) -> Rc<TreeNode> {
        Rc::new(TreeNode {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(Vec::new()),
        })
    }

    pub fn add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>) {
        child.parent.borrow_mut().replace(Rc::downgrade(parent));
        parent.children.borrow_mut().push(child);
    }

    pub fn sum(&self) -> i32 {
        let mut total = self.value;
        for child in self.children.borrow().iter() {
            total += child.sum();
        }
        total
    }

    pub fn depth(&self) -> usize {
        let mut depth = 0;
        let mut current = self.parent.borrow().upgrade();
        while let Some(parent) = current {
            depth += 1;
            current = parent.parent.borrow().upgrade();
        }
        depth
    }
}

Turn #29Raw score: 0

250 in1,628 out1,878 total15.6s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define TreeNode with exactly these fields: value: i32, parent: RefCell<Weak<TreeNode>>, and children: RefCell<Vec<Rc<TreeNode>>>, importing those types from the standard library. Write TreeNode::new(value: i32) -> Rc<TreeNode>. Write TreeNode::add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>), which also sets the child's parent. Write sum(&self) -> i32, the total of this node and all its descendants, and depth(&self) -> usize, the number of ancestors, which is 0 for a root.

assistant

use std::cell::RefCell;
use std::rc::{Rc, Weak};

pub struct TreeNode {
    pub value: i32,
    pub parent: RefCell<Weak<TreeNode>>,
    pub children: RefCell<Vec<Rc<TreeNode>>>,
}

impl TreeNode {
    pub fn new(value: i32) -> Rc<TreeNode> {
        Rc::new(TreeNode {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(Vec::new()),
        })
    }

    pub fn add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>) {
        *child.parent.borrow_mut() = Rc::downgrade(parent);
        parent.children.borrow_mut().push(child);
    }

    pub fn sum(&self) -> i32 {
        let mut total = self.value;
        for child in self.children.borrow().iter() {
            total += child.sum();
        }
        total
    }

    pub fn depth(&self) -> usize {
        let mut depth = 0;
        let mut current = self;
        loop {
            let parent_opt = current.parent.borrow().upgrade();
            match parent_opt {
                Some(p) => {
                    depth += 1;
                    current = &*p;
                }
                None => break,
            }
        }
        depth
    }
}

Turn #30Raw score: 0

250 in1,734 out1,453 reasoning1,984 total28.5s

user

Write Rust for the 2024 edition on stable, using only the standard library. Answer with one ```rust code block that defines what the question describes. Do not include fn main, tests, examples, explanations, or print statements.

Define TreeNode with exactly these fields: value: i32, parent: RefCell<Weak<TreeNode>>, and children: RefCell<Vec<Rc<TreeNode>>>, importing those types from the standard library. Write TreeNode::new(value: i32) -> Rc<TreeNode>. Write TreeNode::add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>), which also sets the child's parent. Write sum(&self) -> i32, the total of this node and all its descendants, and depth(&self) -> usize, the number of ancestors, which is 0 for a root.

assistant

use std::cell::RefCell;
use std::rc::{Rc, Weak};

pub struct TreeNode {
    pub value: i32,
    pub parent: RefCell<Weak<TreeNode>>,
    pub children: RefCell<Vec<Rc<TreeNode>>>,
}

impl TreeNode {
    pub fn new(value: i32) -> Rc<TreeNode> {
        Rc::new(TreeNode {
            value,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(Vec::new()),
        })
    }

    pub fn add_child(parent: &Rc<TreeNode>, child: Rc<TreeNode>) {
        child.parent.borrow_mut().replace(Rc::downgrade(parent));
        parent.children.borrow_mut().push(child);
    }

    pub fn sum(&self) -> i32 {
        let mut total = self.value;
        for child in self.children.borrow().iter() {
            total += child.sum();
        }
        total
    }

    pub fn depth(&self) -> usize {
        let mut depth = 0;
        let mut current_parent_opt = self.parent.borrow().upgrade();
        while let Some(parent_rc) = current_parent_opt {
            depth += 1;
            current_parent_opt = parent_rc.parent.borrow().upgrade();
        }
        depth
    }
}

Run Detail

Recorded for these videos

Turns (30)