Vectors

Vectors are one of Rust's most commonly used collections. They are growable arrays that can hold multiple elements of the same type. They are defined in Rust using the Vec<T> type, where T is the type of elements the vector contains.

In this challenge, you will perform basic operations on a vector, such as adding, removing, and accessing elements. Understanding how to work with vectors is essential for building efficient and idiomatic Rust applications.

Your Task

You are required to implement the following functions:

add_elements: This function takes a mutable reference to a vector of integers and a slice of integers. It appends all elements from the slice to the vector.
remove_element: This function takes a mutable reference to a vector of integers and an index. It removes the element at the given index if it exists.
get_element: This function takes a reference to a vector of integers and an index. It returns the element at the given index as an Option<i32>.

Hints

Click here to reveal hints

You can use vec.extend_from_slice(elements) to add all elements from a slice to a vector.
Use Vec::remove to remove an element by index.
To safely access an element by index, use the get method on vectors.
Keep in mind that Vec::remove will panic if the index is out of bounds, so handle it carefully in remove_element.

Editor not available on Mobile!

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

Solutions

Octavian

orouwk

9 hours ago

4.67ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if vec.len() as usize > index {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if vec.len() as usize > index {
        Some(vec[index])
    } else {
        None
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Gurneet singh

GS-Jatt

3 days ago

5.34ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if  index >= 0 &&  vec.len() > index {   
     vec.remove(index);
   }   // Your code here
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
    
    }
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

anhdoo

TuanAnhDoHoang

3 days ago

5.38ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements.iter().map(|value| value));
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index >= 0 && index < vec.len(){
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    match vec.get(index){
        Some(value) => {
            let ret = value.clone();
            return Some(ret);
        }
        None => { return None;}
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Tristan Young

DragonBeast829

7 days ago

4.22ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend(elements.iter());
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index <= vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Teimur Gasanov

teimurjan

7 days ago

4.56ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if vec.get(index) != None {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Seth Wood

seth-wood

7 days ago

5.63ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements)
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    match vec.get(index) {
        Some(_) => {
            vec.remove(index);
        }
        None => {
            return;
        }
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    match vec.get(index) {
        Some(&index) => Some(index),
        None => None,
    }
}

Kanak Shilledar

kanakshilledar

8 days ago

4.52ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index > vec.len() {
        return;
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Nicolai

Posmac

9 days ago

7.90ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index > vec.len() {
        return;
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

LLukeDB

10 days ago

4.58ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

zazapalm3012

10 days ago

4.63ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    match vec.get(index){
        Some(_) => {
            vec.remove(index);
            },
        None => {
            return;
        },
    }
   
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Thomastienn

12 days ago

4.67ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    return vec.get(index).copied();
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Thomastienn

12 days ago

12.21ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    return vec.get(index).copied();
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Elizabeth Doughty

Thymelizabeth

12 days ago

4.53ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Health-Care-Movie

12 days ago

5.09ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements)
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index <= vec.len() {vec.remove(index);}
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if index >= vec.len() {None} else {Some(vec[index])}
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

adamegao

12 days ago

6.27ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // vec.append(&mut Vec::from(elements));
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    //let result = vec.get(index).map_or(None, |num| Some(*num));
    //result
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

adamegao

12 days ago

5.37ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // vec.append(&mut Vec::from(elements));
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    //let result = vec.get(index).map_or(None, |num| Some(*num));
    //result
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

adamegao

12 days ago

5.65ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // vec.append(&mut Vec::from(elements));
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    let result = vec.get(index).map_or(None, |num| Some(*num));
    result
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

adamegao

12 days ago

14.07ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // vec.append(&mut Vec::from(elements));
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index.lt(&vec.len()) && index.ge(&0usize) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    let result = vec.get(index).map_or(None, |num| Some(*num));
    result
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Splatrac

splatrac

13 days ago

5.47ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index <= vec.len() - 1 {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if vec.is_empty() {
        return None;
    }
    if index <= vec.len() - 1 {
        return Some(vec[index]);
    } else {
        return None;
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Trịnh Chấn Duy

Duyyy123

16 days ago

5.48ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index >= vec.len() {
        // Remove the element at the specified index
        return ();
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Liyqq

18 days ago

4.55ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

cyberspace lee

cyberspacelee

19 days ago

4.46ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index >= vec.len() {
        return;
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

cyberspace lee

cyberspacelee

19 days ago

4.25ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < 0 || index >= vec.len() {
        return;
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

agamaontherock

21 days ago

4.09ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Sergey Zubkov

ksevelyar

24 days ago

4.44ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    for e in elements {
        vec.push(*e)
    };
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if get_element(vec, index).is_some() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Jes

KSJeshin

25 days ago

4.10ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

TestingPurpose14

a month ago

4.66ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Neel Knight

NeelKnight

a month ago

5.23ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Felix Kiprotich

penscola

a month ago

4.64ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for i in elements {
        vec.push(*i)
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    match vec.get(index) {
        Some(_) => {
            vec.remove(index);
            },
        None => {
            return;
        }
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Nathan GAUD

Natchica

a month ago

5.01ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    elements.iter().for_each( |&e|
        vec.push(e)
    );
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    if index < vec.len() {
        return Some(vec[index]);
    } else {
        return None;
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Sergey

Themelok

a month ago

4.47ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for i in elements {
        vec.push(*i)
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
        match vec.get(index) {
        Some(_) => {
            vec.remove(index);
        },
        None => {
            return;
        }
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

mishbah

a month ago

4.46ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

mishbah

a month ago

3.82ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Paolo Cancedda

Pac72

a month ago

4.21ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements)
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
     match vec.get(index) {
        Some(i32_ref) => Some(*i32_ref),
        None => None,
     }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Maintain

duonghb53

a month ago

4.85ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Maintain

duonghb53

a month ago

4.00ms

100.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    let mut vec1 = elements.to_vec();
    vec.append(&mut vec1);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

torbenhardt

a month ago

5.94ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend(elements)
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() { vec.remove(index); }
    
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).cloned()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Max

maxemontio

a month ago

5.17ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if vec.get(index).is_some() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

RASHMOR

RASHMOR1

a month ago

5.51ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Check if index is valid
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
    
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Jakub Wiśniewski

wisniewskij

a month ago

4.35ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend(elements)
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Jason

Jason-fy-wang

a month ago

8.68ms

100.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    let mut vec2 = elements.to_vec();
    vec.append(&mut vec2);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if index < vec.len() {
        vec.get(index).copied()
    }else{
        None
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Nguyen Vo Hoang Son

sonmessia

a month ago

4.72ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Nhat Vu

NhatTinyVu

a month ago

4.26ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

Leo Phạm

HongThaiPham

a month ago

6.85ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

pop_eax

pop-eax

a month ago

5.19ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    elements.into_iter().for_each(|x| {
        vec.push(*x)
    });
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if !(index > vec.len() || index < 0) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

vijayabhaskar badireddi

ptcte

a month ago

5.28ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for (_i,&n) in elements.iter().enumerate() {
        vec.push(n);
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
    ()
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if index < vec.len() {
        return Some(vec[index]);
    }
    None
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

AtlasVakyrie

a month ago

3.80ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

AtlasVakyrie

a month ago

3.94ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

EduardoFernandess

a month ago

4.47ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    
    elements.iter().for_each( |&x| vec.push(x));
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if index < vec.len() {
    vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if index < vec.len() {
        return Some(vec[index])
    } else {
       return None
    }
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}

laiaga

a month ago

4.40ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if vec.len() > index {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
}
// Example usage
pub fn main() {
    let mut vec = vec![1, 2, 3];
    add_elements(&mut vec, &[4, 5]);
    assert_eq!(vec, vec![1, 2, 3, 4, 5]);
    remove_element(&mut vec, 2);
    assert_eq!(vec, vec![1, 2, 4, 5]);
    assert_eq!(get_element(&vec, 1), Some(2));
    assert_eq!(get_element(&vec, 10), None);
}