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.
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>
.vec.extend_from_slice(elements)
to add all elements from a slice to a vector.Vec::remove
to remove an element by index.get
method on vectors.Vec::remove
will panic if the index is out of bounds, so handle it carefully in remove_element
.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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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()}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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()}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) { elements.iter().for_each(|element| 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()}// Example usagepub 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);}
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 usagepub 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);}
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() { return None; } Some(vec[index])}// Example usagepub 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);}
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 usagepub 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);}
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); // } 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 usagepub 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);}
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> { return vec.get(index).copied();}// Example usagepub 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);}
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 usagepub 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);}
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: &[i32], index: usize) -> Option<i32> { // Your code here vec.get(index).copied()}// Example usagepub 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);}
pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) { // Your code here vec.extend_from_slice(elements);}pub fn remove_element(vec: &mut Vec<i32>, index: usize) { // Your code here if index > vec.len() { return; } vec.remove(index);}pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> { // Your code here vec.get(index).cloned()}// Example usagepub 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);}
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 match vec.get(index) { Some(i) => Some(*i), None => None, }}// Example usagepub 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);}
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) { vec .get(index) .is_some() .then(||{ vec.remove(index) });}pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> { vec.get(index).copied()}// Example usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) { // Your code here vec.extend_from_slice(elements);}pub fn remove_element(vec: &mut Vec<i32>, index: usize) { // Your code here if index > vec.len() { return; } vec.remove(index);}pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> { // Your code here vec.get(index).copied()}// Example usagepub 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);}
pub fn add_elements(vec: &mut Vec<i32>, elements: &[i32]) { // Your code here vec.append(&mut elements.to_vec())}pub fn remove_element(vec: &mut Vec<i32>, index: usize) { if index >= vec.len() || index < 0 { return (); } vec.remove(index);}pub fn get_element(vec: &Vec<i32>, index: usize) -> Option<i32> { vec.get(index).copied()}// Example usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}
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 usagepub 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);}