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

michdorf

5 hours ago

3.77ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    /* for e in elements {
        vec.push(*e); 
    } */
    vec.extend_from_slice(elements);
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index < vec.len() {
        Vec::remove(vec, 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);
}

vojta stefan

vojtastefan

6 hours ago

4.17ms

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
    if vec.len() > 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);
}

AnKarl

Zythophilus

2 days ago

4.22ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for num in elements {
        vec.push(*num);
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
        if index < vec.len() {
        vec.remove(index);
    } 
    // Your code here
}
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);
}

Pranav Garg

PranavGarg01

2 days ago

4.42ms

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 {
        let x = 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);
}

Hung Dinh

nhdinh

2 days ago

4.03ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for n in elements {
        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() {
        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);
}

amaneru

7ma8no9

3 days ago

5.53ms

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.get(index).is_some() {
        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);
}

Artyom Chebotarev

Derik117

4 days ago

6.15ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for el in elements {
        vec.push(*el)
    }
}
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);
}

AKA.MoneyTaker

M4Bo2

5 days ago

4.14ms

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); // Use Vec::remove to remove the element at the given 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);
}

Kamuran

karapy

5 days ago

3.99ms

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

zawwwu

5 days ago

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

Dyaa Adel

dyaa-adel

7 days ago

4.20ms

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

Éric Villani

TheTrueCaligari

7 days ago

4.99ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    for el in elements.iter() {
        vec.push(*el);
    }
}
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() {
        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);
}

Lê Minh Quân

aleister1102

8 days ago

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

Lê Minh Quân

aleister1102

8 days ago

4.06ms

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

Lê Minh Quân

aleister1102

8 days ago

5.07ms

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

Vladimir

PavluninVladimir

9 days ago

8.13ms

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

Yi Hao

leongyihao

10 days ago

4.57ms

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

Guilherme Cesário Strachan

strachan

10 days ago

4.14ms

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

Anıl Şenay

anilsenay

10 days ago

5.76ms

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

TiagONTOP

10 days ago

4.90ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for &element in elements.iter(){
        vec.push(element)
    }
        
}
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);
}

Ayushman Rathore

Spartan09

11 days ago

8.28ms

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

norabbito

11 days ago

5.82ms

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

Jordan

Jordan-Haidee

13 days ago

3.79ms

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
    if index < vec.len() {
        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);
}

Benjamin Falk

lumio

15 days ago

4.07ms

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

Benjamin Falk

lumio

15 days ago

3.78ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    for e in elements.iter() {
        vec.push(*e);
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    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);
}

McToady.eth

McCoady

15 days ago

3.99ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for element in elements {
        vec.push(*element);
    }
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    let last_index = vec.len() - 1;
    if index <= last_index {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    if index >= vec.len() {
        return None;
    }
    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);
}

Douglas Campbell

CampbellD84

16 days ago

3.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> {
    if index < vec.len() {
        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);
}

Kenneth Love

kennethlove

16 days ago

4.44ms

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 (0..vec.len()).contains(&index) {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    if vec.len() > 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);
}

Kenneth Love

kennethlove

16 days ago

4.45ms

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 >= 0 && vec.len() > index {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    if vec.len() > 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);
}

Prafful

iamsahu

17 days ago

3.68ms

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

Diego Maia

diegocmsantos

18 days ago

4.63ms

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

ludovicknecht

18 days ago

3.95ms

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()
}

Joe Schneider

josschne

18 days ago

4.25ms

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() {
        let _ = 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);
}

Whisper_icoma

1378046967

19 days ago

4.52ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for &el in elements {
        vec.push(el)
    }
}
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).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);
}

Muhammad-Dennis

19 days ago

4.51ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for &el in elements {
        vec.push(el)
    }
}
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).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);
}

Dimas Avrian Fachriza.

FForFachriza

19 days ago

3.66ms

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

alemack17

20 days ago

3.92ms

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

manuelmj

20 days ago

6.35ms

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

manuelmj

20 days ago

4.89ms

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

automata-studio

20 days ago

6.34ms

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

kosay

sarub0b0

20 days ago

4.12ms

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

Denis SOURON

Brack0

20 days ago

3.73ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    for element in elements {
        vec.push(*element);
    }
}
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()
}

Donald Huber-Youmans

dHuberYoumans

20 days ago

5.65ms

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

TeDeMos

22 days ago

5.26ms

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

RiyadDz22

22 days 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 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);
}

Nikita Smirnov

Nismirno

22 days ago

8.36ms

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

Viktor Merkurev

fennr

22 days ago

4.11ms

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

Jun Huang

leemars

22 days ago

4.35ms

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

iamforgettable

22 days ago

5.91ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    
    for element in elements.iter() {
        vec.push(*element);
    }
}
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);
}

tzmijewski

23 days ago

3.96ms

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.len() >= index {
        vec.remove(index);
    } else {}
    
}
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);
}