nex-agi/nex-n2.6 on Rust Quick Ten

Turn #1Raw score: 1

99 in1,467 out1,397 reasoning1,566 total17.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 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 chars: Vec<char> = s
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();
    chars.iter().eq(chars.iter().rev())
}

Turn #2Raw score: 1

99 in1,101 out1,031 reasoning1,200 total16.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 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 chars: Vec<char> = s
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();
    chars.iter().eq(chars.iter().rev())
}

Turn #3Raw score: 1

99 in273 out203 reasoning372 total3.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 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 chars: Vec<char> = s
        .chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_lowercase())
        .collect();

    chars.iter().eq(chars.iter().rev())
}

Turn #4Raw score: 1

109 in273 out205 reasoning382 total3.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.

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() {
        *counts.entry(word.to_lowercase()).or_insert(0) += 1;
    }
    counts
}

Turn #5Raw score: 1

109 in588 out514 reasoning697 total7.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 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<String, usize> = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word.to_lowercase()).or_insert(0) += 1;
    }
    counts
}

Turn #6Raw score: 1

109 in397 out323 reasoning506 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 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<String, usize> = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word.to_lowercase()).or_insert(0) += 1;
    }
    counts
}

Turn #7Raw score: 1

106 in382 out332 reasoning488 total4.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 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>(first: &'a str, second: &'a str) -> &'a str {
    if second.len() > first.len() {
        second
    } else {
        first
    }
}

Turn #8Raw score: 1

106 in180 out130 reasoning286 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 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>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() {
        x
    } else {
        y
    }
}

Turn #9Raw score: 1

106 in287 out237 reasoning393 total4.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 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>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() {
        x
    } else {
        y
    }
}

Turn #10Raw score: 1

166 in1,175 out1,099 reasoning1,341 total14.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 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 (left, right) = s.split_once(sep)?;
    Some((T::from_str(left).ok()?, T::from_str(right).ok()?))
}

Turn #11Raw score: 1

166 in578 out508 reasoning744 total7.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 (left, right) = s.split_once(sep)?;
    Some((left.parse().ok()?, right.parse().ok()?))
}

Turn #12Raw score: 1

166 in969 out895 reasoning1,135 total11.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 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 (left, right) = s.split_once(sep)?;
    Some((left.parse::<T>().ok()?, right.parse::<T>().ok()?))
}

Turn #13Raw score: 1

127 in2,783 out2,718 reasoning2,910 total34.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

pub 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 #14Raw score: 1

127 in3,432 out3,367 reasoning3,559 total39.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

pub 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

127 in659 out595 reasoning786 total9.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 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 #16Raw score: 1

142 in7,620 out7,502 reasoning7,762 total84.7s

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(Option<(u64, u64)>);

impl Fib {
    pub fn new() -> Self {
        Fib(Some((1, 0)))
    }
}

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        let (a, b) = self.0.take()?;
        let value = b;
        if let Some(sum) = a.checked_add(b) {
            self.0 = Some((b, sum));
        }
        Some(value)
    }
}

Turn #17Raw score: 1

142 in7,818 out7,659 reasoning7,960 total85.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 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 {
    prev: u64,
    curr: u64,
    finished: bool,
}

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

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        if self.finished {
            return None;
        }
        let value = self.curr;
        match self.prev.checked_add(self.curr) {
            Some(sum) => {
                self.prev = self.curr;
                self.curr = sum;
            }
            None => {
                self.finished = true;
            }
        }
        Some(value)
    }
}

Turn #18Raw score: 1

142 in8,323 out8,170 reasoning8,465 total90.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 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: Option<u64>,
    done: bool,
}

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

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        if self.done {
            return None;
        }
        let current = self.a;
        match self.b {
            Some(b) => {
                self.a = b;
                self.b = current.checked_add(b);
            }
            None => self.done = true,
        }
        Some(current)
    }
}

Turn #19Raw score: 1

243 in2,436 out2,047 reasoning2,679 total25.7s

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;
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 temperature input"),
            TempError::BadUnit(c) => write!(f, "bad temperature unit: {c}"),
            TempError::BadNumber(e) => write!(f, "bad temperature number: {e}"),
        }
    }
}

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

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

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }

    let mut chars = s.chars();
    let unit = chars.next_back().expect("non-empty string has a last char");

    match unit {
        'C' | 'F' => {}
        _ => return Err(TempError::BadUnit(unit)),
    }

    let number_part: String = chars.collect();
    let value: f64 = number_part.parse()?;

    Ok(match unit {
        'F' => (value - 32.0) * 5.0 / 9.0,
        _ => value,
    })
}

Turn #20Raw score: 1

243 in2,482 out2,137 reasoning2,725 total23.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.

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;
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 temperature input"),
            TempError::BadUnit(unit) => write!(f, "invalid temperature unit: {unit}"),
            TempError::BadNumber(err) => write!(f, "invalid temperature number: {err}"),
        }
    }
}

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

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

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    let Some((split, unit)) = s.char_indices().next_back() else {
        return Err(TempError::Empty);
    };
    let number = &s[..split];
    match unit {
        'C' => Ok(number.parse()?),
        'F' => Ok((number.parse::<f64>()? - 32.0) * 5.0 / 9.0),
        other => Err(TempError::BadUnit(other)),
    }
}

Turn #21Raw score: 1

243 in2,431 out2,069 reasoning2,674 total24.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 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;

#[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 character: {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,
        }
    }
}

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

pub fn parse_temp(s: &str) -> Result<f64, TempError> {
    let Some(unit) = s.chars().last() else {
        return Err(TempError::Empty);
    };

    let number_part = match unit {
        'C' | 'F' => &s[..s.len() - 1],
        _ => return Err(TempError::BadUnit(unit)),
    };

    let value: f64 = number_part.parse()?;

    Ok(match unit {
        'F' => (value - 32.0) * 5.0 / 9.0,
        _ => value,
    })
}

Turn #22Raw score: 1

144 in539 out381 reasoning683 total5.7s

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 {
    if workers == 0 {
        panic!("workers must be greater than zero");
    }

    if data.is_empty() {
        return 0;
    }

    let active_workers = workers.min(data.len());
    let chunk_size = data.len().div_ceil(active_workers);

    thread::scope(|scope| {
        let handles: Vec<_> = data
            .chunks(chunk_size)
            .map(|chunk| scope.spawn(move || chunk.iter().sum::<u64>()))
            .collect();

        handles
            .into_iter()
            .map(|handle| handle.join().unwrap())
            .sum()
    })
}

Turn #23Raw score: 1

144 in2,446 out2,298 reasoning2,590 total23.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::thread;

pub fn parallel_sum(data: &[u64], workers: usize) -> u64 {
    assert!(workers > 0, "workers must be greater than zero");

    if data.is_empty() {
        return 0;
    }

    let chunk_size = data.len().div_ceil(workers);

    thread::scope(|scope| {
        let handles: Vec<_> = data
            .chunks(chunk_size)
            .map(|chunk| scope.spawn(move || chunk.iter().sum::<u64>()))
            .collect();

        handles
            .into_iter()
            .map(|handle| handle.join().unwrap())
            .sum::<u64>()
    })
}

Turn #24Raw score: 1

144 in2,302 out2,153 reasoning2,446 total23.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 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 greater than zero");

    if data.is_empty() {
        return 0;
    }

    let chunk_size = data.len().div_ceil(workers);

    thread::scope(|scope| {
        let handles: Vec<_> = data
            .chunks(chunk_size)
            .map(|chunk| scope.spawn(move || chunk.iter().sum::<u64>()))
            .collect();

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

Turn #25Raw score: 0

134 in32,000 out32,000 reasoning32,134 total650.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 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.

Turn #26Raw score: 1

134 in5,387 out5,044 reasoning5,521 total65.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.

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

use std::iter::FusedIterator;

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> {
        let first = match self.prev.take() {
            Some(item) => item,
            None => self.iter.next()?,
        };
        let second = match self.iter.next() {
            Some(item) => item,
            None => {
                self.prev = Some(first);
                return None;
            }
        };
        self.prev = Some(second.clone());
        Some((first, second))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let (lower, upper) = self.iter.size_hint();
        if self.prev.is_some() {
            (lower, upper)
        } else {
            (lower.saturating_sub(1), upper.map(|n| n.saturating_sub(1)))
        }
    }
}

impl<I> FusedIterator for Pairs<I>
where
    I: FusedIterator,
    I::Item: Clone,
{
}

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

impl<T> PairsExt for T where T: Iterator {}

Turn #27Raw score: 0

134 in3,811 out3,450 reasoning3,945 total38.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.

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

use std::iter::FusedIterator;

/// Iterator adapter yielding consecutive overlapping pairs from a source.
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> {
        let item = self.iter.next()?;
        let prev = self.prev.replace(item.clone())?;
        Some((prev, item))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let (lower, upper) = self.iter.size_hint();
        (
            lower.saturating_sub(1),
            upper.map(|upper| upper.saturating_sub(1)),
        )
    }
}

impl<I> FusedIterator for Pairs<I>
where
    I: FusedIterator,
    I::Item: Clone,
{
}

/// Extension trait adding a lazy overlapping-pairs iterator to any iterator
/// whose items implement `Clone`.
pub trait PairsExt: Iterator {
    /// Yields each consecutive overlapping pair `(items[i], items[i + 1])`.
    ///
    /// The source is advanced lazily, one item per `next` call, so infinite
    /// iterators work. A source with fewer than two items yields nothing.
    fn pairs(self) -> Pairs<Self>
    where
        Self: Sized,
        Self::Item: Clone,
    {
        Pairs {
            iter: self,
            prev: None,
        }
    }
}

impl<I: Iterator> PairsExt for I {}

Turn #28Raw score: 0

189 in4,952 out4,660 reasoning5,141 total57.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.

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 = 0;
        let mut stack: Vec<&TreeNode> = vec![self];

        while let Some(node) = stack.pop() {
            total += node.value;

            for child in node.children.borrow().iter() {
                stack.push(child.as_ref());
            }
        }

        total
    }

    pub fn depth(&self) -> usize {
        let mut count = 0;
        let mut ancestor = self.parent.borrow().upgrade();

        while let Some(node) = ancestor {
            count += 1;
            ancestor = node.parent.borrow().upgrade();
        }

        count
    }
}

Turn #29Raw score: 0

189 in1,265 out1,003 reasoning1,454 total29.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};

#[derive(Debug)]
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 count = 0;
        let mut ancestor = self.parent.borrow().clone();
        while let Some(node) = ancestor {
            count += 1;
            ancestor = node.parent.borrow().clone();
        }
        count
    }
}

Turn #30Raw score: 1

189 in2,157 out1,909 reasoning2,346 total47.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 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};

#[derive(Debug, Default)]
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 parent = self.parent.borrow().upgrade();
        match parent {
            Some(p) => 1 + p.depth(),
            None => 0,
        }
    }
}

Run Detail

Recorded for these videos

Turns (30)