Concurrency

In multi-threaded programming, concurrent execution allows tasks to be performed simultaneously, making programs faster and more efficient. Rust's std::thread module facilitates this by enabling the creation and management of threads in a straightforward and safe manner.

In this challenge, you will implement a function concurrent_add that spawns threads to add a specified value to each element of a list. Each thread will handle one element of the list, returning the result of the addition. By leveraging threads, you'll distribute the workload across multiple cores for concurrent execution.

Your Task

Your task is to implement the function concurrent_add that takes a list of items (Vec<T>) and a number (T) as inputs. For each item in the list, the function should spawn a new thread that adds the given number to the item. The function will return a vector of JoinHandle<T> representing the handles to all the threads, allowing the results to be retrieved later.

Requirements

The function should accept a Vec<T> and a value of type T.
T can be, integer, floating-point, or any other number type in Rust.
The function should return a vector of JoinHandle<T>.

Hints

Click here to reveal hints

The std::thread::spawn function creates a new thread to execute a given closure.
The std::ops::Add trait allows addition between two values of the same type.
In order for a type to be passed to threads safely, they must implement the Send trait.
The type should also have a lifetime of 'static to make sure the thread can not outlive the data it references.
Ensure the type T implements Copy since threads require ownership of their inputs.

Editor not available on Mobile!

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

Solutions

AKA.MoneyTaker

M4Bo2

2 days ago

6.42ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + 'static,
{
    let mut handles = Vec::new();
    for item in items {
        let num_clone = num; // Clone the number for each thread
        let handle = thread::spawn(move || {
            item + num_clone
        });
        handles.push(handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

manuelmj

4 days ago

33.70ms

90.52kb

use std::thread;
// use core::ops::Add;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T : Add<Output = T > + Send + 'static + Copy 
{
    // Implement the function here
    let mut vector_handler: Vec<thread::JoinHandle<T>> = Vec::new(); 
    for item in items.iter(){
        let item = *item; 
        let handler = thread::spawn(move ||{
            item + num 
        });
        vector_handler.push(handler);
    }
    vector_handler 
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Ayushman Rathore

Spartan09

5 days ago

6.94ms

90.52kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + Copy + Send + Sync + 'static,
{
    let mut handles = Vec::new();
    for &item in items.iter() {
        handles.push(thread::spawn(move || item + num));
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Dyaa Adel

dyaa-adel

5 days ago

8.28ms

90.10kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T : std::ops::Add<Output = T> + Send + Copy + 'static,
 {
    // Implement the function here
    let mut handles : Vec<thread::JoinHandle<T>> = Vec::new();
    items.into_iter().for_each(|item| {handles.push(std::thread::spawn(move || item + num));});
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

automata-studio

5 days ago

14.98ms

90.52kb

use std::thread;
use std::thread::JoinHandle;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where T: std::ops::Add<Output=T> + Send + Copy + 'static
{
    // Implement the function here
    let mut handles: Vec<JoinHandle<T>> = vec![];
    for item in items {
        let handle = thread::spawn(
            move || {
                item + num
            }
        );
        handles.push(handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

iamforgettable

7 days ago

6.58ms

90.02kb

use std::thread::{self, spawn};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    
    items.into_iter().map(|item| spawn(move || {
        item + num
    })).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

ludovicknecht

8 days ago

5.35ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where T: Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    let mut handles = vec![];
    for &item in items.iter() {
        handles.push(thread::spawn(move || item + num));
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Jun Huang

leemars

9 days ago

20.85ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: std::ops::Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    items.into_iter().map(|item| thread::spawn(move || {
        item + num
    })).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Algorab

10 days ago

4.97ms

90.02kb

use std::ops::Add;
use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: Add<Output = T> + Send + Copy + 'static
{
    // Implement the function here
    items.into_iter().map(|item| thread::spawn(move || {
        item + num
    })).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Kyle Diaz

kylediaz

11 days ago

5.05ms

90.02kb

use std::thread;
use std::ops::Add;
use std::marker::Send;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: Add<Output = T> + Send + Copy + 'static
{
    items
        .into_iter()
        .map(|v| thread::spawn(move || v + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Jordan

Jordan-Haidee

11 days ago

6.42ms

90.02kb

use std::thread;
pub fn concurrent_add<T >(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where 
    T: std::ops::Add<Output = T> + 'static + Copy + Send
{
    // Implement the function here
    items.into_iter().map(|item| thread::spawn(move || item + num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Jordan

Jordan-Haidee

11 days ago

6.23ms

90.52kb

use std::thread;
pub fn concurrent_add<T >(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where 
    T: Send + std::ops::Add<Output = T> + 'static + Copy
{
    // Implement the function here
    let mut threads = vec![];
    for i in 0..items.len() {
        let item = items[i];  // Copy the value from the vector
        let num = num;        // Copy num into the closure
        let t = thread::spawn(move || { item + num });
        threads.push(t);
    }
    threads
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

rawar089

12 days ago

8.73ms

90.02kb

use std::thread;
use std::thread::spawn;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: Add<Output = T> + Copy + Send + 'static{
    // Implement the function here
    items.into_iter()
    .map(|item| spawn(move || item + num))
    .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Nikita Smirnov

Nismirno

13 days ago

8.96ms

90.03kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add + Send + 'static + Copy + Add<Output = T>,
{
    // Implement the function here
    items
        .into_iter()
        .map(|i| thread::spawn(move || i + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

alemack17

14 days ago

6.40ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T> (items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
    where T: 'static+Send+Copy+Add<Output=T> {
    // Implement the function here
    items.into_iter().map( |i| thread::spawn(move || i+num)).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Kenneth Love

kennethlove

14 days ago

7.69ms

90.52kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
    where
        T: 'static + Send + Copy + Add<Output = T>
{
    // Implement the function here
    let mut output: Vec<thread::JoinHandle<T>> = vec![];
    for item in items {
        output.push(thread::spawn(move || { item + num }));
    }
    output
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Christopher Nielson

c-nielson

16 days ago

5.04ms

90.52kb

use std::ops::Add;
use std::thread;
use std::thread::spawn;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
T: 'static + Send + Copy + Add<Output = T>
{
    let mut joins: Vec<thread::JoinHandle<T>> = Vec::new();
    for item in items.into_iter() {
        joins.push(spawn(move || item.add(num)))
    }
    joins
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Elliott Draper

ejdraper

19 days ago

5.83ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> where T: std::ops::Add<Output = T> + Send + Copy + 'static {
    items
        .into_iter()
        .map(|i| thread::spawn(move || i + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

kosay

sarub0b0

19 days ago

5.53ms

90.04kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + Copy + Send + 'static,
{
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Oebelus

oebelus

21 days ago

9.54ms

90.02kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + Send + 'static + Copy,
{
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

TaiPoole

22 days ago

5.52ms

90.02kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> where T: Send + std::ops::Add<Output = T> + 'static + Copy {
    items.into_iter().map(|item| thread::spawn(move || {
        item + num
    })).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Jonathan Voss

jvoss

23 days ago

5.22ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Add<Output = T> + Copy + Send + 'static
{
    // Implement the function here
    items
        .into_iter()
        .map(|i| thread::spawn(move || { i.add(num).into() }))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Justin Maillet

justy777

23 days ago

7.78ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: Add<Output = T> + Copy + Send + 'static
 {
    items.into_iter().map(move |item| std::thread::spawn( move || item + num )).collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Jim Lawton

jimlawton

23 days ago

4.79ms

90.03kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + Sync + 'static,
{
    items
        .into_iter()
        .map(move |item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

Stefan Roas

sroas

24 days ago

5.43ms

90.02kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy + Send + Sync + 'static,
{
    // Implement the function here
    items
        .into_iter()
        .map(move |item| thread::spawn(move || item + num))
        .collect()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

dawwestk

a month ago

5.33ms

90.52kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
    T: Send + Copy + Add<Output = T> + 'static
{
    // Implement the function here
    let mut handles: Vec<thread::JoinHandle<T>> = vec![];
    for i in items.into_iter() {
        let join_handle: thread::JoinHandle<T> = thread::spawn(move || {
            let result = i.add(num);
            result
        });
        handles.push(join_handle);
    }
    handles
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}

PangoSea

kapaseker

a month ago

5.13ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T: Add<Output = T> + Send + Clone + 'static>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    items
        .into_iter()
        .map(|item| {
            thread::spawn({
                let value = num.clone();
                move || {
                    item.add(value)
                }
            })
        })
        .collect::<Vec<thread::JoinHandle<T>>>()
}
// Example Usage
pub fn main() {
    {
        let mut list = vec![1, 2, 3, 4, 5];
        let handles = concurrent_add(list.clone(), 3);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 3);
        }
    }
    {
        let mut list = vec![10., 20., 30., 40., 50.];
        let handles = concurrent_add(list.clone(), 5.);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.);
        }
    }
}