Interior Mutability

Rust provides powerful abstractions for managing memory safely and efficiently. One such abstraction is Rc (Reference Counting), which allows multiple ownership of data. When combined with RefCell, it unlocks the ability to mutate data through shared ownership safely at runtime.

In this challenge, you'll use Rc and RefCell together to explore the concept of Interior Mutability in Rust.

Your Task

Implement the following functions to demonstrate shared ownership and interior mutability:

push:
- Accept an Rc<RefCell<Vec<T>>> as input.
- Append an element to the shared vector inside the RefCell.
iterate_and_print_shared_data:
- Take an Rc<RefCell<Vec<T>>> as input.
- Iterate through the vector and print each element.
plus_one:
- Accept an Rc<RefCell<i32> as input.
- Increment the value inside the RefCell by one.

Requirements

Use Rc to share ownership of the vector.
Use RefCell to allow interior mutability.
Avoid using unsafe code.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use Rc::clone to share ownership of the vector.
Use RefCell's .borrow_mut() for mutable access and .borrow() for immutable access.
T: Display is needed to format the output with println!.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

StevenCanDrink

2 days ago

1468.95ms

93.88kb

use std::cell::RefCell;
use std::fmt::Display;
use std::ops::{ Add, Sub };
use std::rc::Rc;
pub fn push<T: Clone>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for item in data.as_ref().take().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Chih Ying Yen

xavierforge

3 days ago

1426.15ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|item| println!("{item}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

amdfxlucas

5 days ago

1387.44ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T: Display>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x|{ println!("{x}"); });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

undefeated_

boyboi86

7 days ago

1350.44ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|a| println!("{}", a))
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

GunGraveCpp

8 days ago

1491.94ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    let mut  v = data.borrow_mut();
    v.push(element); 
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    for i in data.borrow().iter(){
        println!("{}",i);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

toto

11 days ago

1391.04ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|value| println!("{value}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

manu3618

13 days ago

1339.54ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    Rc::clone(&data).borrow_mut().push(element)
}
pub fn iterate_and_print_shared_data<T:Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for elt in Rc::clone(&data).borrow().iter(){
        println!("{}", &elt);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *Rc::clone(&data).borrow_mut() += 1
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Lvfalue

14 days ago

1483.48ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|item| println!("{item}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut data = data.borrow_mut();
    *data += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

visanr

17 days ago

1460.39ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
    // 1. Finish the function
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    for item in data.borrow().iter() {
        println!("{}", item);
    }
    // 2. Borrow the data and print each item
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
    // 3. Finish the function
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

AtlasVakyrie

22 days ago

1333.72ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut vec = data.borrow_mut();
    vec.push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for i in data.borrow().iter() {
        println!("{}", i);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut value = data.borrow_mut();
    *value += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Luka Bračun

lbracun

22 days ago

1371.10ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::ops::{AddAssign};
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    data.borrow_mut().add_assign(1);
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

bzdula

22 days ago

1476.60ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    for item in &*data.borrow() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

bzdula

22 days ago

1399.45ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    for item in &*data.borrow() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Oscar Aspelin

OscarAspelin95

23 days ago

1406.87ms

93.84kb

use std::cell::RefCell;
use std::ops::Add;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // We use borrow mut to borrow the vec as mutable.
    let mut s = data.borrow_mut();
    s.push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|element| {
        println!("{}", element);
    });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    let mut s = data.borrow_mut();
    *s += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Wouter

WouterMartens

a month ago

1377.86ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: std::fmt::Display,
{
    data.borrow().iter().for_each(|item| println!("{item}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1
}
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

m1031

monorail103

a month ago

1361.92ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|e| println!("{}", e));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Daniel Mestas

miel-codeai

a month ago

1414.39ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|el| println!("{}", el));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

slaws

a month ago

1404.76ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T)
where
T: Display
{
    // 1. Finish the function
    let data_ref = &mut *data.borrow_mut();
    data_ref.push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where 
T: Display
{
    // 2. Borrow the data and print each item
    for d in &*data.borrow() {
        println!("{}",d);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let refe = &mut *data.borrow_mut();
    *refe += 1
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Baron Curtin

baroncurtin2

a month ago

1356.93ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|item| println!("{}", item))
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Marco-Normal

a month ago

1421.65ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|e| println!("{e}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1; 
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Evrins Hu

evrins

a month ago

1320.46ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|element| {
        println!("{}", element);
    });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

medzernik

a month ago

1325.06ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
 use std::ops::Deref;
pub fn push<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.deref().borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.deref().borrow().iter().for_each(|x| println!("{}", *x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

johndoe30bc

a month ago

1485.96ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|e| println!("{e}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Procybit

a month ago

1348.31ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    for i in data.borrow().iter() {
        println!("{i}")
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Cristian Prieto

cprieto

a month ago

1412.02ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|elem| println!("{elem}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Miguel Ángel Allende

maallende

a month ago

1482.49ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::{Debug, Display};
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Debug+Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

xxxxsk

a month ago

1407.31ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|item| {
        println!("{}", item);
    });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

FredoPo

a month ago

1432.94ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T: Copy>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|val| println!("{}", val));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

FredoPo

a month ago

1485.62ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T: Copy>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|val| println!("{}", val));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Evgenii Grigorenko

grevgeny

a month ago

1533.36ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    for item in data.borrow().iter() {
        println!("{item}");
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

brucecox01

2 months ago

1381.86ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut v = data.borrow_mut();
    v.push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    // 2. Borrow the data and print each item
    let v = data.borrow();
    for x in &*v {
        println!("{x}")
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut count = data.borrow_mut();
    *count += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Krzysztof Atłasik

katlasik

2 months ago

1344.21ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
  data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
  for item in data.borrow().iter() {
    println!("{}", item)
  }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
  let mut r = data.borrow_mut();
  *r += 1
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Tengz Mao

MaoX-Yu

2 months ago

1297.20ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut data = data.borrow_mut();
    *data += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Philippe Massicotte

PMassicotte

2 months ago

1305.24ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: std::fmt::Display,
{
    data.borrow().iter().for_each(|i| println!("{i}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Enes

enesscevik

2 months ago

1328.03ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) where T: std::fmt::Display {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Ushakov Andrey

stdstring

2 months ago

1396.54ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) where T : std::fmt::Display {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut data_ref = data.borrow_mut();
    *data_ref += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

0x0f1

Paul4673

2 months ago

1417.44ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T)
{ 
    // 1. Finish the function
    (*data.borrow_mut()).push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where T: std::fmt::Display,
{
    // 2. Borrow the data and print each item
    (*data.borrow()).iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() +=1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

vanos001

2 months ago

1327.08ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    (*data.borrow_mut()).push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where 
    T : std::fmt::Display,    
{
    // 2. Borrow the data and print each item
    (*data.borrow()).iter().for_each(|e| println!("{}",e));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

alexsavio

2 months ago

1396.78ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    (*data).borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    (*data).borrow().iter().for_each(|item| println!("{item}"))
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

alexsavio

2 months ago

1442.40ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    (*data).borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    (*data).borrow().iter().for_each(|item| println!("{item}"))
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

whhc

2 months ago

1363.21ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::ops::Add;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    // 2. Borrow the data and print each item
    data.borrow()
        .iter()
        .for_each(|element| println!("{element}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

ikatlinsky

2 months ago

1345.00ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    for d in data.borrow().iter() {
        println!("{d}");
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Seth Wood

seth-wood

2 months ago

1466.44ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: std::fmt::Display,
{
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}

diucicd

2 months ago

1344.18ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    let mut d = data.borrow_mut();
    d.push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|e| println!("{}", e));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    let mut d = data.borrow_mut();
    *d += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Sergey Matyash

matiaspub

2 months ago

1624.38ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|d| println!("{}", d));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

LeonardoPinheiro23

3 months ago

1535.47ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|element| println!("{element}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Tommytto

3 months ago

1539.43ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut data = data.borrow_mut();
    data.push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    let data = data.borrow();
    for item in data.iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut data = data.borrow_mut();
    *data += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

sjmellor

3 months ago

1508.07ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: std::fmt::Display,
{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x| println!("{x}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Nicolai

Posmac

3 months ago

1550.41ms

93.84kb

use core::fmt;
use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) where T : fmt::Display {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

ggnne

3 months ago

1623.14ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for v in data.borrow().iter() {
        println!("{v}");
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}