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

Omar Saber Talaat Abdelrahman

omar-s-ta

9 hours ago

4.87ms

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: Send + 'static,
    T: Add<Output = T> + Copy,
{
    let mut handles = Vec::new();
    for item in items {
        let handle = thread::spawn(move || item + num);
        handles.push(handle);
    }
    handles
}
pub fn concurrent_add<T>(items: Vec<T>, num: T) -> Vec<thread::JoinHandle<T>>
where
    T: Add<Output = T> + Copy,
    T: Send + 'static,
{
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}
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.);
        }
    }
}

Omar Saber Talaat Abdelrahman

omar-s-ta

9 hours ago

4.94ms

90.52kb

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

makinpaper

8 days ago

5.06ms

90.02kb

use std::{
    ops::{self, Add},
    thread::{self, spawn},
};
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_clone = num.clone();
            spawn(move || item + num_clone)
        })
        .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.);
        }
    }
}

Harsha Aswath

raharsha

9 days ago

5.59ms

90.06kb

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 + 'static + Send,
{
    // 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.);
        }
    }
}

<YoungAncient/>

youngancient

9 days ago

5.21ms

90.55kb

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

Dan Wayne

danwayne-me

11 days ago

4.67ms

90.52kb

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

Asrul Firdaus

AsrulF

11 days ago

5.46ms

90.40kb

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

kasaxpong

12 days ago

5.23ms

90.07kb

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

Jai

jsat97

14 days ago

5.17ms

90.04kb

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

银雀Sparrxw

Sparr0www820

18 days ago

8.41ms

90.02kb

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

Dharm Singh

dharmvr1

20 days ago

6.58ms

90.52kb

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

Kishan

wdcs-kishansudani

a month ago

6.13ms

90.52kb

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

Yummy-Yums

a month ago

5.37ms

90.40kb


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::new();
    for item in items.into_iter(){
        let handle = thread::spawn(move || {
            let result = item.add(num);
            result
        });
        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.);
        }
    }
}

Yummy-Yums

a month ago

7.00ms

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::new();
    for item in items.into_iter(){
        let handle = thread::spawn(move || {
            let result = item.add(num);
            result
        });
        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.);
        }
    }
}

Ari Karim

arikarim

a month ago

4.77ms

90.52kb

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

Rocky.C

cloki0610

a month ago

5.35ms

90.03kb

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

Vincent SAMY

vsamy

a month ago

16.43ms

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

shahab-tplus

a month ago

6.56ms

90.06kb

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

shahab-tplus

a month ago

6.72ms

90.52kb

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

Abhishek Sharma

0xAbhiDev

a month ago

6.85ms

90.52kb

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

QuJohan

a month ago

6.14ms

90.52kb

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

nojae15

a month ago

12.00ms

90.55kb

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

jfloresremar

a month ago

5.26ms

90.52kb

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

jh4vision

2 months ago

5.07ms

90.52kb

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

Omar

OmniKobra

2 months ago

5.46ms

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

TheJanzap

2 months ago

5.65ms

90.04kb

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

TheJanzap

2 months ago

6.40ms

90.09kb

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

artemnistuley

2 months ago

5.40ms

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

Christophe Mohimont

mohic

2 months ago

6.73ms

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> + Copy + Send + 'static,
{
    items
        .into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect()
}

Smith, Taylor

a647965_fidelity

2 months ago

5.43ms

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: Copy + Send + Sync + Add<Output=T> + 'static {
    // Implement the function here
    items.into_iter()
        .map(|item| thread::spawn(move || item + num))
        .collect::<Vec<_>>()
}
// 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.);
        }
    }
}

StevenCanDrink

2 months ago

5.49ms

90.02kb

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

Chih Ying Yen

xavierforge

2 months ago

4.90ms

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: Copy + Send + Add<Output = T> + 'static
{
    // Implement the function here
    let mut handles = vec![];
    for idx in 0..items.len() {
        let item = items[idx];
        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.);
        }
    }
}

amdfxlucas

2 months ago

7.19ms

90.02kb

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

undefeated_

boyboi86

3 months ago

5.11ms

90.03kb

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

GunGraveCpp

3 months ago

5.19ms

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: 'static + Send + Copy + Add<Output = T> {
     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.);
        }
    }
}

toto

3 months ago

6.53ms

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 + Copy + Add<Output = T>,
{
    // 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.);
        }
    }
}

toto

3 months ago

5.69ms

90.52kb

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

Lvfalue

3 months ago

5.44ms

90.03kb

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

manu3618

3 months ago

5.55ms

90.02kb

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

visanr

3 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: Add<Output=T> + Send + Copy + 'static
{
    items
        .into_iter()
        .map(
            move |item| {
                thread::spawn(move || { item + num})
            }
        ).collect()
    // Implement the function here
}
// 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.);
        }
    }
}

AtlasVakyrie

3 months ago

4.87ms

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: Copy + Send + Add<Output=T> + 'static
{
    // Implement the function here
    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.);
        }
    }
}

Luka Bračun

lbracun

3 months ago

6.27ms

90.03kb

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

bzdula

3 months ago

5.07ms

90.03kb

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

Wouter

WouterMartens

3 months ago

6.01ms

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 + Add<Output = T> + 'static,
{
    items
        .iter()
        .map(|&item| thread::spawn(move || item + num))
        .collect()
}
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.);
        }
    }
}

m1031

monorail103

3 months ago

35.30ms

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

miel-codeai

3 months ago

5.28ms

90.03kb

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

slaws

3 months ago

6.36ms

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 vjh: Vec<thread::JoinHandle<T>> = Vec::new();
    for i in items {
        vjh.push(thread::spawn(move || {
            i + num
        }))
    } 
    vjh
}
// 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.);
        }
    }
}

Baron Curtin

baroncurtin2

3 months ago

5.17ms

90.02kb

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

David Manca

medzernik

3 months ago

5.54ms

90.02kb

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

Evrins Hu

evrins

3 months ago

5.08ms

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