ricursiveai/ripple-65b-preview on Rust Quick Ten

Turn #1Raw score: 0

95 in179 out274 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 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 mut left = s.chars().find(|c| c.is_ascii_alphanumeric());
    let mut right = s.chars().rev().find(|c| c.is_ascii_alphanumeric());

    while let (Some(l), Some(r)) = (left, right) {
        if l == right {
            break;
        }

        let lc = s.chars().nth(l).unwrap().to_ascii_lowercase();
        let rc = s.chars().nth(r).unwrap().to_ascii_lowercase();

        if lc != rc {
            return false;
        }

        left = s.chars().skip(l + 1).find(|c| c.is_ascii_alphanumeric());
        right = s.chars().rev().skip(r + 1).find(|c| c.is_ascii_alphanumeric());
    }

    true
}

Turn #2Raw score: 1

95 in114 out64 cached209 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 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 mut left = 0;
    let mut right = filtered.len();

    while left < right {
        right -= 1;
        if filtered[left] != filtered[right] {
            return false;
        }
        left += 1;
    }

    true
}

Turn #3Raw score: 1

95 in138 out64 cached233 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 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 bytes = filtered.iter().map(|&c| c as u8).collect::<Vec<u8>>();

    let mut left = 0usize;
    let mut right = bytes.len();

    while left < right {
        right -= 1;
        if bytes[left] != bytes[right] {
            return false;
        }
        left += 1;
    }

    true
}

Turn #4Raw score: 1

105 in74 out179 total1.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 key = word.to_lowercase();
        *counts.entry(key).or_insert(0) += 1;
    }
    counts
}

Turn #5Raw score: 1

105 in343 out64 cached448 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 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 key = word.to_lowercase();
        *counts.entry(key).or_insert(0) += 1;
    }

    counts
}

Turn #6Raw score: 1

105 in306 out64 cached411 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.

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

    counts
}

Turn #7Raw score: 1

102 in1,758 out1,860 total28.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>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() {
        a
    } else {
        b
    }
}

Turn #8Raw score: 1

102 in1,994 out2,096 total28.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

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

Turn #9Raw score: 1

102 in1,302 out64 cached1,404 total20.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 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 b.len() > a.len() {
        b
    } else {
        a
    }
}

Turn #10Raw score: 1

162 in1,092 out1,254 total15.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 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 idx = s.find(sep)?;
    let left = &s[..idx];
    let right = &s[idx + sep.len_utf8()..];
    Some((left.parse().ok()?, right.parse().ok()?))
}

Turn #11Raw score: 1

162 in2,295 out128 cached2,457 total43.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 = T::from_str(left).ok()?;
    let b = T::from_str(right).ok()?;
    Some((a, b))
}

Turn #12Raw score: 1

162 in448 out128 cached610 total17.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 (left, right) = s.split_once(sep)?;
    Some((left.parse::<T>().ok()?, right.parse::<T>().ok()?))
}

Turn #13Raw score: 1

123 in3,098 out3,221 total52.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 #14Raw score: 1

123 in2,503 out64 cached2,626 total46.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

123 in4,535 out64 cached4,658 total64.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<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

138 in7,678 out7,816 total94.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 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

struct Fib {
    a: u64,
    b: u64,
    last: bool,
    done: bool,
}

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

impl Iterator for Fib {
    type Item = u64;

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

        let current = self.a;

        if self.last {
            self.done = true;
            return Some(current);
        }

        match self.a.checked_add(self.b) {
            Some(next) => {
                self.a = self.b;
                self.b = next;
                Some(current)
            }
            None => {
                self.a = self.b;
                self.last = true;
                Some(current)
            }
        }
    }
}

Turn #17Raw score: 1

138 in4,680 out128 cached4,818 total72.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

struct Fib {
    current: u64,
    next: u64,
    last: bool,
    done: bool,
}

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

impl Iterator for Fib {
    type Item = u64;

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

        let result = self.current;

        if self.last {
            self.done = true;
        } else if self.next > u64::MAX - self.current {
            self.current = self.next;
            self.last = true;
        } else {
            let sum = self.current + self.next;
            self.current = self.next;
            self.next = sum;
        }

        Some(result)
    }
}

Turn #18Raw score: 1

138 in2,006 out128 cached2,144 total40.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 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: u128,
    b: u128,
    done: bool,
}

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

impl Iterator for Fib {
    type Item = u64;

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

        if self.a > u64::MAX as u128 {
            self.done = true;
            return None;
        }

        let current = self.a as u64;
        let next = self.a + self.b;
        self.a = self.b;
        self.b = next;

        Some(current)
    }
}

Turn #19Raw score: 1

239 in2,092 out2,331 total30.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::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 input"),
            TempError::BadUnit(c) => write!(f, "invalid unit: {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> {
    let Some(last) = s.chars().last() else {
        return Err(TempError::Empty);
    };

    let num_part = &s[..s.len() - last.len_utf8()];

    let value: f64 = num_part.parse().map_err(TempError::BadNumber)?;

    match last {
        'C' => Ok(value),
        'F' => Ok((value - 32.0) * 5.0 / 9.0),
        _ => Err(TempError::BadUnit(last)),
    }
}

Turn #20Raw score: 0

239 in10,560 out192 cached10,799 total125.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)]
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 => f.write_str("empty input"),
            TempError::BadUnit(c) => {
                f.write_str("invalid unit: ")?;
                f.write_char(*c)
            }
            TempError::BadNumber(e) => {
                f.write_str("invalid number: ")?;
                fmt::Display::fmt(e, f)
            }
        }
    }
}

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> {
    let Some((idx, unit)) = s.char_indices().last() else {
        return Err(TempError::Empty);
    };
    let number = &s[..idx];
    match unit {
        'C' => number.parse::<f64>().map_err(TempError::BadNumber),
        'F' => number
            .parse::<f64>()
            .map_err(TempError::BadNumber)
            .map(|f| (f - 32.0) * 5.0 / 9.0),
        c => Err(TempError::BadUnit(c)),
    }
}

Turn #21Raw score: 1

239 in5,042 out192 cached5,281 total55.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;
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(c) => write!(f, "invalid unit: {c}"),
            TempError::BadNumber(e) => write!(f, "invalid number: {e}"),
        }
    }
}

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

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

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

    if last != 'C' && last != 'F' {
        return Err(TempError::BadUnit(last));
    }

    let number_part = &s[..s.len() - last.len_utf8()];
    let number: f64 = number_part.parse().map_err(TempError::BadNumber)?;

    if last == 'F' {
        Ok((number - 32.0) * 5.0 / 9.0)
    } else {
        Ok(number)
    }
}

Turn #22Raw score: 1

140 in5,994 out6,134 total86.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 {
    if workers == 0 {
        panic!("workers must be greater than zero");
    }
    if data.is_empty() {
        return 0;
    }

    let workers = workers.min(data.len());
    let len = data.len();
    let mut total: u64 = 0;

    thread::scope(|scope| {
        let mut handles = Vec::with_capacity(workers);
        for i in 0..workers {
            let start = i * len / workers;
            let end = (i + 1) * len / workers;
            let chunk = &data[start..end];
            handles.push(scope.spawn(move || chunk.iter().sum::<u64>()));
        }
        for handle in handles {
            total += handle.join().unwrap();
        }
    });

    total
}

Turn #23Raw score: 1

140 in2,745 out128 cached2,885 total46.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

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

    let n = workers.min(data.len());
    let chunk_size = (data.len() + n - 1) / n;

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

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

Turn #24Raw score: 1

140 in6,830 out128 cached6,970 total86.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

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

    let n = data.len();
    let base = n / workers;
    let rem = n % workers;
    let mut total = 0;

    std::thread::scope(|scope| {
        let mut handles = Vec::new();
        let mut start = 0;
        for i in 0..workers {
            let size = if i < rem { base + 1 } else { base };
            let end = start + size;
            let chunk = &data[start..end];
            start = end;
            handles.push(scope.spawn(move || chunk.iter().sum::<u64>()));
        }
        for handle in handles {
            total += handle.join().unwrap();
        }
    });

    total
}

Turn #25Raw score: 0

130 in11,267 out11,397 total136.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 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::Item: Clone;
}

pub struct Pairs<I: Iterator> {
    inner: I,
    prev: Option<I::Item>,
    started: bool,
    done: bool,
}

impl<I: Iterator> Pairs<I> {
    fn new(inner: I) -> Self {
        Pairs {
            inner,
            prev: None,
            started: false,
            done: false,
        }
    }
}

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

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

        if !self.started {
            match self.inner.next() {
                Some(first) => {
                    self.prev = Some(first);
                    self.started = true;
                }
                None => {
                    self.done = true;
                    return None;
                }
            }
        }

        let prev = self.prev.take().expect("previous item must exist");
        match self.inner.next() {
            Some(next) => {
                self.prev = Some(next.clone());
                Some((prev, next))
            }
            None => {
                self.done = true;
                None
            }
        }
    }
}

impl<I: Iterator> PairsExt for I
where
    I::Item: Clone,
{
    fn pairs(self) -> Pairs<Self> {
        Pairs::new(self)
    }
}

Turn #26Raw score: 0

130 in10,370 out128 cached10,500 total115.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

use std::iter::Iterator;

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

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

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

impl<I: Iterator> Iterator for Pairs<I>
where
    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 => {
                let first = self.iter.next()?;
                let second = self.iter.next()?;
                self.prev = Some(second.clone());
                return Some((first, second));
            }
        };

        let next = self.iter.next()?;
        self.prev = Some(next.clone());
        Some((prev, next))
    }
}

Turn #27Raw score: 1

130 in13,528 out128 cached13,658 total150.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 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> PairsExt for I
where
    I: Iterator,
    I::Item: Clone,
{
    fn pairs(self) -> Pairs<Self>
    where
        Self: Sized,
    {
        Pairs { iter: self, prev: None }
    }
}

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

impl<I: Iterator> Iterator for Pairs<I>
where
    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()?;
                let second = self.iter.next()?;
                self.prev = Some(second.clone());
                Some((first, second))
            }
            Some(prev) => {
                let next = self.iter.next()?;
                self.prev = Some(next.clone());
                Some((prev, next))
            }
        }
    }
}

Turn #28Raw score: 0

185 in14,745 out14,930 total127.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.

Turn #29Raw score: 0

185 in262 out128 cached447 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.

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, Weak};
use std::rc::Rc;

#[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>) {
        parent.children.borrow_mut().push(child.clone());
        child.parent.borrow_mut().replace(Rc::downgrade(parent));
    }

    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 current = self.parent.borrow().upgrade();
        while let Some(node) = current {
            count += 1;
            current = node.parent.borrow().upgrade();
        }
        count
    }
}

Turn #30Raw score: 0

185 in276 out128 cached461 total2.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>) {
        parent.children.borrow_mut().push(Rc::clone(&child));
        child.parent.replace(Rc::downgrade(parent));
    }

    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 = current.parent.borrow();
            match parent.upgrade() {
                Some(p) => {
                    depth += 1;
                    current = &p;
                }
                None => break,
            }
        }
        depth
    }
}

Run Detail

Recorded for these videos

Turns (30)