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

Eliettetheegeek

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

khadre07

5 hours ago

4.02ms

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

Hariom

om-secadvice

2 days ago

4.60ms

96.71kb

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

PreppyMiguel

lusuo9

2 days ago

4.11ms

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

Egu0

egu0

4 days ago

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

Egu0

egu0

4 days ago

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

karthick121

4 days ago

3.86ms

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

karthick121

4 days ago

4.48ms

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

DjukicDragan01

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

Özgür

AyikOzgur

4 days ago

4.93ms

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

azmahflameheart

4 days ago

4.62ms

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
    (index < vec.len() && index >= 0).then(|| 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);
}

Vendra000

4 days ago

4.01ms

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

emiludenz

4 days ago

3.79ms

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

LawisChen

6 days ago

3.70ms

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

Anthony Young

A-Young-Git

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

Marouan Boulahtouf

MBoulahtouf

6 days ago

3.75ms

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

ffrie

7 days ago

3.92ms

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

idorocodes

8 days ago

3.87ms

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

Ramon Silva

rsilva1

8 days ago

4.70ms

96.71kb

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

Sheren Yogesh Narayanan

Nsy97

8 days ago

4.05ms

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

something238892

8 days ago

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

winter

winter-08

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

winter

winter-08

9 days ago

4.35ms

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

Hossein Adib

hosseinadib-hub

10 days ago

4.12ms

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> {
    let val = vec.get(index)?;
    Some(*val)
}
// 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);
}

Hossein Adib

hosseinadib-hub

10 days ago

3.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 index > vec.len(){
        return;
    }
    vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    let val = vec.get(index)?;
    Some(*val)
}
// 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);
}

Snoweuph

snoweuph

10 days ago

3.86ms

100.61kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    vec.append(&mut elements.to_vec());
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if index >= vec.len(){
        return;
    }
    let _ = vec.remove(index);
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    let value = vec.get(index)?;
    Some(*value)
}

penmanglewood

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

vqk-2003

10 days ago

4.13ms

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

vqk-2003

10 days ago

4.01ms

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
    match vec.get(index) {
        Some(value) => Some(*value),
        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);
}

Rishika Sharma

Rishika-dev

11 days ago

4.77ms

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

makinpaper

11 days ago

3.59ms

96.61kb

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

Amit Patel

amitpatel-wstf

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

Amit Patel

amitpatel-wstf

11 days ago

4.08ms

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

Dan Wayne

danwayne-me

12 days ago

4.21ms

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

Camiam144

12 days ago

4.89ms

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).map(ToOwned::to_owned)
}
// 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);
}

fasolyee

fasolyeedev

12 days ago

3.87ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    // Your code here
    for elem in elements.iter(){
        vec.push(*elem);
    }
}
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
    if let res = vec.get(index){
        return res.copied()
    }
    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);
}

batblerone

12 days ago

3.69ms

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

DebroyeAntoine

13 days ago

3.70ms

96.71kb

pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) {
    elements.iter().for_each(|n| vec.push(*n))
    // Your code here
}
pub fn remove_element(vec: &mut Vec<i32>, index: usize) {
    if let Some(_) = vec.get(index) {
        vec.remove(index);
    }
    // Your code here
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    vec.get(index).copied()
    // Your code here
}
// 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);
}

Tanvi Sharma

wdcs-tanvisharma

14 days ago

3.67ms

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

Nteli1

NteliFake

15 days ago

3.61ms

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

traderdude123

15 days ago

3.76ms

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

Sameer

shaiksameer1604

15 days ago

4.49ms

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(v) => Some(*v),
        _ => 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);
}

Retroz

Fungichi

15 days ago

4.47ms

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

Istvan Basa

pottom

15 days ago

3.64ms

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> {
    match vec.get(index) {
        Some(v) => Some(*v),
        _ => 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);
}

Nanda Arta

Nansky

16 days ago

3.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() {
        vec.remove(index);
    }
}
pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> {
    // Your code here
    match vec.get(index) {
        Some(v) => Some(*v),
        _ => 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);
}

gtakacse

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

SpontaneousOverthrow

16 days ago

4.16ms

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) {
    match vec.get(index) {
        Some(x) => vec.remove(index),
        _ => 0,
    };
    return
    // 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);
}

SpontaneousOverthrow

16 days ago

4.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) {
    match vec.get(index) {
        Some(x) => vec.remove(index),
        _ => 0,
    };
    return
    // 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);
}

Shivam Jain

shivam-jainn

17 days ago

4.23ms

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

Rodrigo Gimenez

rodrigoegimenez

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