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

Smith, Taylor

a647965_fidelity

an hour ago

3.83ms

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

Selim Gökmen

sgoekmen

4 hours ago

4.47ms

96.71kb

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

Raj

irajgill

18 hours ago

3.88ms

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

greg95000

a day ago

3.79ms

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

fomulate

finbaromahony

a day 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 let Some(_) = get_element(vec, index) {
        vec.remove(index);
    } else {
        println!("Index {} is out of bounds, no element removed.", 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);
}

AyotuntosimiLoye

2 days ago

4.28ms

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 index < vec.len() {
        true => vec.get(index).cloned(),
        false => 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);
}

Yury

Just-Captain

3 days ago

4.00ms

96.71kb

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

Christophe Mohimont

mohic

3 days ago

3.74ms

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

Christophe Mohimont

mohic

3 days ago

4.03ms

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

JIA

bytesxz

3 days ago

4.31ms

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

Paolo Deidda

DePoli97

4 days ago

3.77ms

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

Solange

SolangeLL

4 days ago

3.81ms

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

Heorhii

Kagev

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

Heorhii

Kagev

5 days ago

3.87ms

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

firefly

KamisAyaka

6 days ago

4.09ms

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); // ✅ 正确的方法调用
    }
    // 或者直接使用：vec.remove(index); 但这样会在越界时 panic
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // 使用 copied() 或 map(|x| *x) 来转换类型
    vec.get(index).copied() // ✅ 正确转换 &i32 到 i32
}
// 示例使用保持不变
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);
}

amdfxlucas

6 days ago

5.71ms

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

L. Gasc

L-GASC

7 days ago

4.44ms

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

P S

psvr

7 days ago

4.78ms

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

Jean-Luc Brouillet

jeanlucbr

8 days ago

6.05ms

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 >= 0 && 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);
}

DBrouillet

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

Varun D

varun-d

8 days ago

4.18ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    // takes in &mut ref to mutate the og vec, and elements ref to be added in
    // not returning value because its modifying the og
    vec.extend_from_slice(elements);
}
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
    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);
}

Juan Mejia

juan-mejia

9 days ago

4.65ms

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).is_some() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
     return 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);
}

Bryan

yuyangchen23

9 days ago

4.23ms

96.61kb

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

ashishkr2912

9 days ago

3.93ms

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

muemart

10 days ago

4.80ms

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 index >= 0 && 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);
}

Phong H.

doivjpxx

10 days ago

5.12ms

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

Siallus

12 days ago

4.73ms

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

Siallus

12 days ago

4.00ms

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

Sasank Yadavalli

sasankyadavalli

12 days ago

4.03ms

96.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    vec.extend(elements.iter().copied());
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    // Your code here
    if vec.len() > index {
        vec.remove(index as usize);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    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);
}

RASOANOMENJANAHARY Matio Mamy Nantenaina

devlucazh

13 days ago

4.77ms

96.71kb

// pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
//     // Your code here
// }
// pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
//     // Your code here
// }
// pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
//     // Your code here
// }
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 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);
}

Cristian Banu

cbanu96

13 days ago

4.60ms

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

Sergei Kaznakhovskii

fredeastside

14 days ago

5.22ms

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

StevenCanDrink

15 days ago

3.95ms

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

Felipe Marques de Almeida

fmalmeida

15 days ago

4.97ms

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

Fanzzzd

15 days ago

3.90ms

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

achla95

16 days ago

4.45ms

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

lurah11

17 days ago

4.13ms

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

Lvfalue

17 days ago

4.73ms

96.71kb

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

David Rasch

dcrasch

18 days ago

4.06ms

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

GunGraveCpp

19 days ago

4.13ms

96.71kb

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

GunGraveCpp

19 days ago

4.05ms

96.71kb

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

GunGraveCpp

19 days ago

4.21ms

96.71kb

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

Harold Indra

hindra2

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

Thomas Michiels

mithom

19 days ago

3.80ms

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

Christophe Pronier

chrpron

19 days ago

8.28ms

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

johnson

ssebide

19 days ago

4.04ms

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

Jean-baptiste JOFFRE

Indy79

19 days ago

5.03ms

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

guinrt

20 days ago

4.60ms

96.71kb

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

Anni Hoege

annitannenbaum

20 days ago

3.88ms

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

wytsier

21 days ago

3.95ms

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