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

Enes

enesscevik

a day ago

5.00ms

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> + std::marker::Send + Copy + 'static
{
    // Implement the function here
    items.into_iter().map(|n| {
        thread::spawn(move || n + 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.);
        }
    }
}

0x0f1

Paul4673

3 days ago

5.03ms

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> + std::marker::Send + 'static + Copy
{
    // Implement the function here
    items.into_iter().map(|n| {
        thread::spawn(move || n + 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.);
        }
    }
}

vanos001

4 days ago

5.66ms

90.58kb

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> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    // print!("{}",isize::BITS);
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// 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.);
        }
    }
}

vanos001

4 days ago

5.60ms

90.58kb

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> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// 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.);
        }
    }
}

vanos001

4 days ago

5.95ms

90.58kb

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> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::with_capacity(items.len());
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// 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.);
        }
    }
}

vanos001

4 days ago

4.99ms

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> + std::marker::Send + Copy + 'static,
{
    // Implement the function here
    let mut res = Vec::new();
    for i in items{
        res.push(thread::spawn(move || i + num))
    }
    return res;
}
// 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.);
        }
    }
}

whhc

5 days ago

6.86ms

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> + Send + Copy + '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.);
        }
    }
}

whhc

5 days ago

4.91ms

90.52kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Send + Copy + 'static,
{
    let mut handles = 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.);
        }
    }
}

alexsavio

6 days ago

5.37ms

90.52kb

use std::thread;
use std::marker::{Send, Copy};
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
{
    let mut handles = vec![];
    for item in items {
        let handle = std::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.);
        }
    }
}

ikatlinsky

16 days ago

7.30ms

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>,
{
    let mut handles = vec![];
    for item in items {
        let handle = thread::spawn(move || {
            item + num
        });
        handles.push(handle);
    }
    return 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.);
        }
    }
}

diucicd

17 days ago

5.63ms

90.52kb

use std::thread;
pub fn concurrent_add<T: Copy + Send + 'static + std::ops::Add<Output = T>>(
    items: Vec<T>,
    num: T,
) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    let mut handles = Vec::new();
    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.);
        }
    }
}

Seth Wood

seth-wood

18 days ago

4.94ms

90.03kb

use std::ops::Add;
use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<<T as Add<T>>::Output>>
where
    T: Add<T> + Copy + Send + 'static, // T must implement Add, be Copy (for num), Send and 'static (for threads)
    <T as Add<T>>::Output: Send + 'static, // The result of addition must also be Send and 'static
{
    // Implement the function here
    items
        .into_iter()
        .map(|item| {
            // item is moved into the closure
            // num is copied into the closure environment because T is Copy
            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.);
        }
    }
}

Sergey Matyash

matiaspub

22 days ago

6.47ms

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>
{
    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.);
        }
    }
}

LeonardoPinheiro23

25 days ago

5.03ms

90.02kb

use std::{ops::Add, thread};
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: 'static + Send + Add<Output = T> + Copy {
    items
        .into_iter()
        .map(|element| thread::spawn(move || element + num))
        .collect()
}
// Example Usage
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.0, 20.0, 30.0, 40.0, 50.0];
        let handles = concurrent_add(list.clone(), 5.0);
        for handle in handles {
            let result = handle.join().unwrap();
            let original = list.remove(0);
            assert_eq!(result, original + 5.0);
        }
    }
}

Tommytto

a month ago

15.36ms

90.02kb

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.iter().map(|&item| {
        let num = num;
        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.);
        }
    }
}

Tommytto

a month ago

33.85ms

90.02kb

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.iter().map(|&item| {
        let num = num;
        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.);
        }
    }
}

sjmellor

a month ago

6.09ms

90.40kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: std::ops::Add<Output = T> + std::marker::Send + 'static + Copy,
{
    // Implement the function here
    let mut handles: Vec<thread::JoinHandle<T>> = Vec::new();
    for item in items {
        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.);
        }
    }
}

ggnne

a month ago

8.19ms

90.04kb

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> + Clone + Send + 'static {
    items.into_iter().map(|item| thread::spawn({let num = num.clone(); 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.);
        }
    }
}

ggnne

a month ago

5.17ms

90.58kb

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 + Clone + Copy + std::marker::Sync + 'static
{
    let mut out: Vec<thread::JoinHandle<T>> = Vec::with_capacity(items.len());
    for n in items.into_iter() {
        out.push(std::thread::spawn(move || n + num.clone()))
    }
    out
}
// 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.);
        }
    }
}

Nicolai

Posmac

a month ago

6.80ms

90.52kb

use std::{ops::Add, thread, vec};
pub fn concurrent_add<T>(items: Vec<T>, num: T )-> Vec<thread::JoinHandle<T>> 
where T: Add<Output = T> + Send + 'static + Clone + Copy {
    // Implement the function here
    let value = num.clone();
    let mut handles = Vec::new();
    for i in items {
        let join_handle = thread::spawn(move || {
           i + value 
        });
        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.);
        }
    }
}

Elizabeth Doughty

Thymelizabeth

a month ago

5.36ms

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> + Clone + Send + 'static {
    items.into_iter().map(|item| thread::spawn({let num = num.clone(); 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.);
        }
    }
}

Splatrac

splatrac

2 months ago

6.24ms

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 + 'static + Clone + Copy {
    // Implement the function here
    let value = num.clone();
    let mut handles = Vec::new();
    for i in items {
        let join_handle = thread::spawn(move || {
           i + value 
        });
        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.);
        }
    }
}

Viktor Merkurev

fennr

2 months ago

8.32ms

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> + Copy + Send + Sync + '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.);
        }
    }
}

Viktor Merkurev

fennr

2 months ago

10.59ms

90.62kb

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 {
    // Implement the function here
    let mut handles = Vec::with_capacity(items.len());
    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.);
        }
    }
}

Nguyen Vo Hoang Son

sonmessia

2 months ago

6.75ms

90.06kb

use std::thread;
use core::ops::Add; 
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
    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.);
        }
    }
}

Health-Care-Movie

2 months ago

6.61ms

90.03kb

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 + Clone + 'static ,
{
    items.into_iter()
        .map(|item| {
            let num = num.clone();
            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.);
        }
    }
}

Liyqq

2 months ago

6.21ms

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 + Clone + 'static ,
{
    // Implement the function here
    items.into_iter()
        .map(|item| {
            let num = num.clone();
            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.);
        }
    }
}

shibu-t

2 months ago

7.95ms

90.01kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T::Output>>
where
    T: std::ops::Add + Clone + Send + 'static,
    T::Output: Send + 'static,
{
    items
        .into_iter()
        .map(|x| {
            let num = num.clone();
            thread::spawn(move || x + 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.);
        }
    }
}

Jason

Jason-fy-wang

3 months ago

6.20ms

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 result: Vec<thread::JoinHandle<T>> = Vec::new();
    // Implement the function here
    for itm in items.into_iter() {
        let handler = thread::spawn(move || {
            let sum = itm + num;
            sum
        });
        result.push(handler);
    }
    result
}
// 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.);
        }
    }
}

Romain Grimau

Herrgrim0

3 months ago

5.05ms

90.52kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Copy + Send + std::ops::Add<Output = T> + 'static, {
    // Implement the function here
    let mut res: Vec<thread::JoinHandle<T>> = vec![];
    for elem in items {
        let handle = thread::spawn(move || elem + num);
        res.push(handle);
    }
    return res;
}
// 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.);
        }
    }
}

sriharsha madala

sriharshamadala

3 months ago

5.42ms

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> + Send + Copy + 'static
{
    // Implement the function here
    let mut handles = Vec::new();
    for item in items {
        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.);
        }
    }
}

AnKarl

Zythophilus

3 months ago

6.60ms

90.55kb

use std::thread;
pub fn concurrent_add<T: std::ops::Add<Output = T> + Send + 'static + Copy>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> {
    // Implement the function here
    let mut res: Vec<thread::JoinHandle<T>> = Vec::new();
    for n in items {
        let handle = std::thread::spawn(move | | n + num);
        res.push(handle);
    }
    res
}
// 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.);
        }
    }
}

vijayabhaskar badireddi

ptcte

3 months ago

5.35ms

90.02kb

use std::thread;
pub fn concurrent_add<T: 'static + Copy + Send + std::ops::Add<Output = T>>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<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.);
        }
    }
}

lugtester

3 months ago

5.72ms

90.02kb

use std::thread;
pub fn concurrent_add<T: 'static + Copy + Send + std::ops::Add<Output = T>>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<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.);
        }
    }
}

Jason

chenjie1219

3 months ago

5.48ms

90.02kb

use std::{
    ops::Add,
    thread::{self, spawn},
};
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(|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.);
        }
    }
}

Yixian Du

duyixian1234

3 months ago

11.36ms

90.02kb

use std::{
    ops::Add,
    thread::{self, spawn},
};
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(|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.);
        }
    }
}

Aurimas Kuniutis

auriku

3 months ago

7.15ms

90.02kb

use std::{
    ops::Add,
    thread::{self, spawn},
};
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(|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.);
        }
    }
}

Artem

tich31337

3 months ago

5.50ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> 
where
 T: Send + 'static + Add<Output = T> + Copy,
{
    // Implement the function here
    items.into_iter().map(|x| thread::spawn(move ||{x+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.);
        }
    }
}

Kentaro Abe

abekem

3 months ago

6.36ms

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> + 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.);
        }
    }
}

Paulo Lins

pblins

3 months ago

17.64ms

89.97kb

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 + 'static,
{
    // Implement the function here
    items
        .into_iter()
        .map(|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.);
        }
    }
}

Anna Komarova

Vlasanya

3 months ago

7.88ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Copy + Send + 'static + Add<Output = T>,
{
    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.);
        }
    }
}

Icarus

IcarusxB

4 months ago

5.12ms

90.03kb

use std::thread;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Send + 'static + std::ops::Add<Output = T> + 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.);
        }
    }
}

Hung Dinh

nhdinh

4 months ago

7.38ms

90.06kb

use std::ops::Add;
use std::thread;
pub fn concurrent_add<T: Add<Output = T> + Copy + 'static>(
    items: Vec<T>,
    num: T,
) -> Vec<thread::JoinHandle<T>>
where
    <T as Add>::Output: Send,
{
    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.);
        }
    }
}

Matthew Li

circles-png

4 months ago

6.81ms

90.03kb

use std::thread;
pub fn concurrent_add<T: std::ops::Add<Output = T> + Copy + 'static>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>> where <T as std::ops::Add>::Output: Send {
    items.into_iter().map(move |a| thread::spawn(move || a + 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.);
        }
    }
}

Zeiion

4 months ago

5.49ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: 'static + Add<Output = T> + Send + Copy
{
    // Implement the function here
    items.into_iter().map(|x| thread::spawn(move || {
       x + 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.);
        }
    }
}

arilet

4 months ago

5.07ms

90.02kb

use std::thread;
use std::ops::Add;
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: 'static + Add<Output = T> + Send + Copy
{
    // Implement the function here
    items.into_iter().map(|x| thread::spawn(move || {
       x + 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.);
        }
    }
}

amaneru

7ma8no9

4 months ago

19.88ms

90.10kb

use std::thread;
    // Implement the function here
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where T: std::ops::Add<T, Output = T> + Send + 'static + Copy {
    // Implement the function here
    let mut handles = Vec::new();
    items.into_iter().for_each(|item| {
        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.);
        }
    }
}

AKA.MoneyTaker

M4Bo2

4 months 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.);
        }
    }
}

Manuel Manjarres R.

manuelmj

4 months 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

4 months 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.);
        }
    }
}