baidu/ernie-5.5-flash-preview:free on Rust Quick Ten

Turn #1Raw score: 1

112 in576 out505 reasoning688 total2.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

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

112 in406 out334 reasoning518 total2.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

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

Turn #3Raw score: 1

112 in347 out276 reasoning459 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 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();
    filtered.iter().eq(filtered.iter().rev())
}

Turn #4Raw score: 1

121 in339 out270 reasoning460 total2.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 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

121 in272 out203 reasoning393 total2.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;

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

121 in277 out208 reasoning398 total1.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 #7Raw score: 1

119 in292 out242 reasoning411 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 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 #8Raw score: 1

119 in238 out188 reasoning357 total1.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 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

119 in209 out159 reasoning328 total1.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 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

179 in468 out383 reasoning647 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 (left, right) = s.split_once(sep)?;
    let a = left.parse::<T>().ok()?;
    let b = right.parse::<T>().ok()?;
    Some((a, b))
}

Turn #11Raw score: 1

179 in380 out296 reasoning559 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 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 (left, right) = s.split_once(sep)?;
    let a = left.parse::<T>().ok()?;
    let b = right.parse::<T>().ok()?;
    Some((a, b))
}

Turn #12Raw score: 1

179 in480 out396 reasoning659 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 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 (left, right) = s.split_once(sep)?;
    let a = left.parse::<T>().ok()?;
    let b = right.parse::<T>().ok()?;
    Some((a, b))
}

Turn #13Raw score: 1

139 in513 out366 reasoning652 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 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

/// Returns a closure that applies `f` and then `g`, i.e. `|x| g(f(x))`.
///
/// `f` and `g` are taken by value and moved into the returned closure, so the
/// result does not borrow from the caller's stack frame and stays valid after
/// `compose` (and the function that called it) has returned.
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: A| g(f(x))
}

Turn #14Raw score: 1

139 in588 out521 reasoning727 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 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: A| g(f(x))
}

Turn #15Raw score: 1

139 in390 out323 reasoning529 total2.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: A| g(f(x))
}

Turn #16Raw score: 1

152 in24,963 out24,782 reasoning25,115 total102.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 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 {
    current: u64,
    next: Option<u64>,
    done: bool,
}

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

impl Default for Fib {
    fn default() -> Self {
        Self::new()
    }
}

impl Iterator for Fib {
    type Item = u64;

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

Turn #17Raw score: 0

152 in32,000 out32,000 reasoning32,152 total131.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.

Turn #18Raw score: 0

152 in698 out459 reasoning850 total3.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 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

/// An iterator over the Fibonacci sequence: 0, 1, 1, 2, 3, 5, ...
///
/// Yields every Fibonacci number representable as a `u64`, then `None`.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Fib {
    current: u64,
    next: u64,
    done: bool,
}

impl Fib {
    /// Creates a new iterator starting at 0.
    pub fn new() -> Self {
        Self {
            current: 0,
            next: 1,
            done: false,
        }
    }
}

impl Iterator for Fib {
    type Item = u64;

    fn next(&mut self) -> Option<u64> {
        if self.done {
            return None;
        }

        let current = self.current;

        // `checked_add` avoids overflow panics when overflow checks are enabled.
        match current.checked_add(self.next) {
            Some(next) => {
                self.current = self.next;
                self.next = next;
            }
            None => self.done = true,
        }

        Some(current)
    }
}

Turn #19Raw score: 1

254 in2,734 out2,385 reasoning2,988 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.

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)]
enum TempError {
    Empty,
    BadUnit(char),
    BadNumber(ParseFloatError),
}

fn parse_temp(s: &str) -> Result<f64, TempError> {
    let mut chars = s.chars();
    let unit = chars.next_back().ok_or(TempError::Empty)?;
    if unit != 'C' && unit != 'F' {
        return Err(TempError::BadUnit(unit));
    }
    let value: f64 = chars.as_str().parse()?;
    Ok(match unit {
        'F' => (value - 32.0) * 5.0 / 9.0,
        _ => value,
    })
}

impl fmt::Display for TempError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TempError::Empty => f.write_str("empty temperature string"),
            TempError::BadUnit(c) => write!(f, "invalid unit character {c:?}"),
            TempError::BadNumber(e) => write!(f, "invalid 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(e: ParseFloatError) -> Self {
        TempError::BadNumber(e)
    }
}

Turn #20Raw score: 1

254 in6,506 out6,143 reasoning6,760 total23.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::fmt;
use std::num::ParseFloatError;

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

fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }
    let (idx, unit) = s.char_indices().last().unwrap();
    if unit != 'C' && unit != 'F' {
        return Err(TempError::BadUnit(unit));
    }
    let value: f64 = s[..idx].parse()?;
    if unit == 'F' {
        Ok((value - 32.0) * 5.0 / 9.0)
    } else {
        Ok(value)
    }
}

impl fmt::Display for TempError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TempError::Empty => f.write_str("empty temperature string"),
            TempError::BadUnit(c) => write!(f, "invalid temperature unit {c:?}"),
            TempError::BadNumber(e) => write!(f, "invalid temperature 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(e: ParseFloatError) -> Self {
        TempError::BadNumber(e)
    }
}

Turn #21Raw score: 1

254 in4,112 out3,731 reasoning4,366 total14.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;
use std::num::ParseFloatError;

#[derive(Debug)]
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 string"),
            TempError::BadUnit(c) => write!(f, "invalid unit character: {c:?}"),
            TempError::BadNumber(e) => write!(f, "invalid 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(e: ParseFloatError) -> Self {
        TempError::BadNumber(e)
    }
}

fn parse_temp(s: &str) -> Result<f64, TempError> {
    if s.is_empty() {
        return Err(TempError::Empty);
    }
    let unit = s.chars().next_back().unwrap();
    if unit != 'C' && unit != 'F' {
        return Err(TempError::BadUnit(unit));
    }
    let number = &s[..s.len() - unit.len_utf8()];
    let value: f64 = number.parse()?;
    let celsius = if unit == 'F' {
        (value - 32.0) * 5.0 / 9.0
    } else {
        value
    };
    Ok(celsius)
}

Turn #22Raw score: 1

156 in2,057 out1,918 reasoning2,213 total8.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 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 0");
    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(|h| h.join().unwrap()).sum()
    })
}

Turn #23Raw score: 1

156 in1,564 out1,368 reasoning1,720 total6.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 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;
    }

    // Never spawn more threads than there are elements.
    let n = data.len().min(workers);
    // Ceil division so every element is covered.
    let chunk_size = (data.len() + n - 1) / n;
    let chunks: Vec<&[u64]> = data.chunks(chunk_size).collect();

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

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

Turn #24Raw score: 1

156 in3,157 out2,999 reasoning3,313 total10.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 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 thread_count = workers.min(data.len());
    let chunk_size = data.len().div_ceil(thread_count);

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

146 in3,716 out3,414 reasoning3,862 total14.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 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 {
    fn pairs(self) -> Pairs<Self>
    where
        Self: Sized;
}

impl<I: Iterator> PairsExt for I {
    fn pairs(self) -> Pairs<Self> {
        Pairs { iter: self, prev: None }
    }
}

pub struct Pairs<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 prev = match self.prev.take() {
            Some(prev) => prev,
            None => self.iter.next()?,
        };
        let current = self.iter.next()?;
        self.prev = Some(current.clone());
        Some((prev, current))
    }

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

impl<I> std::iter::FusedIterator for Pairs<I>
where
    I: Iterator + std::iter::FusedIterator,
    I::Item: Clone,
{
}

Turn #26Raw score: 1

146 in3,294 out3,089 reasoning3,440 total12.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 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 {
    fn pairs(self) -> Pairs<Self>
    where
        Self::Item: Clone,
    {
        Pairs {
            iter: self,
            prev: None,
        }
    }
}

impl<I: Iterator> PairsExt for I {}

pub struct Pairs<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() {
            Some(prev) => {
                let curr = self.iter.next()?;
                self.prev = Some(curr.clone());
                Some((prev, curr))
            }
            None => {
                let first = self.iter.next()?;
                self.prev = Some(first);
                self.next()
            }
        }
    }
}

Turn #27Raw score: 1

146 in6,670 out6,461 reasoning6,816 total23.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 struct Pairs<I: Iterator> {
    iter: I,
    prev: Option<I::Item>,
}

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

impl<I: Iterator> PairsExt for I {}

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

Turn #28Raw score: 1

206 in2,101 out1,854 reasoning2,307 total7.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 {
    value: i32,
    parent: RefCell<Weak<TreeNode>>,
    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,
        }
    }
}

Turn #29Raw score: 1

206 in1,642 out1,395 reasoning1,848 total6.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 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 {
    value: i32,
    parent: RefCell<Weak<TreeNode>>,
    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 {
        self.value
            + self
                .children
                .borrow()
                .iter()
                .map(|child| child.sum())
                .sum::<i32>()
    }

    pub fn depth(&self) -> usize {
        match self.parent.borrow().upgrade() {
            Some(parent) => 1 + parent.depth(),
            None => 0,
        }
    }
}

Turn #30Raw score: 1

206 in1,804 out1,557 reasoning2,010 total6.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 {
    value: i32,
    parent: RefCell<Weak<TreeNode>>,
    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(parent) => 1 + parent.depth(),
            None => 0,
        }
    }
}

Run Detail

Recorded for these videos

Turns (30)