Slice Manipulation

Now that you have an overview of slices, let's make it a little bit more challenging. In this problem, you will implement a function that updates specific elements of a mutable slice.

Your Task

Write a function update_slice(slice: &mut [i32], indices: &[usize], value: i32) that updates specific elements of a mutable slice. The function should:

Take a mutable slice of integers (slice) as the first argument.
Take a slice of indices (indices) that specify which elements of the mutable slice to update.
Update each specified index in the slice to the given value.

The function should handle the following:

If an index in indices is out of bounds for the slice, the function should skip it without causing a panic.
Modify only the elements specified by valid indices.
Ensure that out-of-bound indices in the indices slice do not cause runtime errors.
Remember that slices are views into arrays or vectors; they cannot be resized, but their contents can be modified.

How it Works

let mut data = vec![1, 2, 3, 4, 5];
update_slice(&mut data, &[1, 3, 4], 7);
assert_eq!(data, vec![1, 7, 3, 7, 7]);
 
let mut data = vec![10, 20, 30];
update_slice(&mut data, &[2, 5], 100); // Index 5 is out of bounds
assert_eq!(data, vec![10, 20, 100]);

Hints

If you're having trouble, consider these hints:

Click here to reveal hints

Use the .get_mut(index) method to safely access a mutable reference to an element at a given index. This avoids panics for out-of-bound accesses.
A for loop is useful for iterating through the indices slice.

Editor not available on Mobile!

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

Solutions

wassie1256

5 hours ago

3.79ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for &index in indices {
        if index < slice.len() {
            slice[index] = value;  // Update only valid indices
        }
    }
}
// Example Usage
fn main() {
    let mut numbers = [1, 2, 3, 4, 5];
    update_slice(&mut numbers, &[0, 2, 4], 10);
    assert_eq!(numbers, [10, 2, 10, 4, 10]);  // Updated at indices 0, 2, and 4
    let mut short_array = [7, 8];
    update_slice(&mut short_array, &[1, 2], 99);
    assert_eq!(short_array, [7, 99]);  // Index 2 is out of bounds, so only index 1 is updated
    println!("All tests passed!");
}

Elizabeth Doughty

Thymelizabeth

6 hours ago

3.79ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    slice
        .iter_mut()
        .enumerate()
        .filter(|(i, _)| indices.contains(i))
        .for_each(|(_, i)| {
            *i = value;
        });
}

Esteban Pérez

lep511

6 hours ago

3.14ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &index in indices {
        if index < slice.len() {
            slice[index] = value;
        }
    }
}

kustrun

8 hours ago

3.05ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &i in indices {
        if i >= slice.len() {
            continue;
        }
        slice[i] = value;
    }
}

Max

maxemontio

a day ago

3.26ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for &i in indices {
        if i < slice.len() {
            slice[i] = value;
        }
    }
}

Lucas Deprit

lucasdeprit

a day ago

3.56ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
        for &i in indices {
            if i < slice.len() {
                slice[i] = value;
            }
        }
}

Facundo Hernandez

facuhernandez99

2 days ago

3.06ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &i in indices {
        if i < slice.len(){slice[i] = value;}
    }
}

Nelly

nellyisanon

2 days ago

3.29ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &i in indices {
        if let Some(element) = slice.get_mut(i) {
            *element = value;
        }
    }
}

G Towers

gtowers-dukosi

2 days ago

3.43ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for i in indices {
        if let Some(n) = slice.get_mut(*i) {
            *n = value;
        }
    }
}

Hung Dinh

nhdinh

3 days ago

3.73ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &i in indices {
        if i < slice.len() {
            slice[i] = value;
        }
    }
}

Madhankumar Anandan

amkumar072

3 days ago

3.83ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here 
    for i in indices{
        if slice.len() >= i+1{
            slice[*i] = value;
        }
    }
      
   
}

amaneru

7ma8no9

3 days ago

4.26ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
   for &i in indices {
        if let Some(target) = slice.get_mut(i) {
            *target = value;
        }
   }
}

Lauri Sarap

LauriSarap

4 days ago

3.11ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for &index in indices {
        if let Some(element) = slice.get_mut(index) {
            *element = value;
        }
    }
}

Pranav Garg

PranavGarg01

4 days ago

3.71ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

Heatiche Mix

HeaticheTakachi

5 days ago

3.57ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for index in indices.iter() {
        if *index + 1 <= slice.len(){
            slice[*index] = value;
        }
    }
}

vojta stefan

vojtastefan

5 days ago

3.62ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices{
        if *i<slice.len(){
        slice[*i]= value;
        }
    }
    
}

Artyom Chebotarev

Derik117

5 days ago

4.14ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
        for i in indices {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

zawwwu

6 days ago

5.97ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    slice.iter_mut().enumerate().for_each(|(i, elem)| if indices.contains(&i) {*elem = value})
}

Léa Narzis

lean-apple

6 days ago

3.44ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for index in 0..slice.len() {
        if indices.contains(&index) {
            slice[index] = value as i32; 
        }
    }
}

AKA.MoneyTaker

M4Bo2

6 days ago

4.08ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic hereDescription
 for &index in indices.iter() {
        // Check if the index is within bounds
        if index < slice.len() {
            slice[index] = value; // Update the element at the valid index
        }
    }
}
// Result
// Submissions
// Solutions
// Slice Manipulation
// Open Locally
// 410 views
// Join the Discord
// Now that you have an overview of slices, let's make it a little bit more challenging. In this problem, you will implement a function that updates specific elements of a mutable slice.
// Your Task
// Write a function update_slice(slice: &mut [i32], indices: &[usize], value: i32) that updates specific elements of a mutable slice. The function should:
// Take a mutable slice of integers (slice) as the first argument.
// Take a slice of indices (indices) that specify which elements of the mutable slice to update.
// Update each specified index in the slice to the given value.
// The function should handle the following:
// If an index in indices is out of bounds for the slice, the function should skip it without causing a panic.
// Modify only the elements specified by valid indices.
// Ensure that out-of-bound indices in the indices slice do not cause runtime errors.
// Remember that slices are views into arrays or vectors; they cannot be resized, but their contents can be modified.

AnKarl

Zythophilus

7 days ago

3.42ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

AnKarl

Zythophilus

7 days ago

3.21ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

pagyeman

7 days ago

3.65ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    let max_index: usize = slice.len();
    for i in indices.iter() {
        if *i < max_index {
            slice[*i] = value;
        }
    }
}

Rafik

RafikGadzhiyev

8 days ago

3.97ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &index in indices.iter() {
        if index >= slice.len() {
            continue
        }
        slice[index] = value
    }
}

Rafik

RafikGadzhiyev

8 days ago

4.12ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &index in indices.iter() {
        if index < 0 || index >= slice.len() {
            continue
        }
        slice[index] = value
    }
}

JackY

Scorpio24

8 days ago

3.98ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    let len = slice.len();
    for &indice in indices.iter(){
        if indice > (len - 1) || indice < 0 {
            continue;
        }
        slice[indice] = value;
    }
}

Éric Villani

TheTrueCaligari

9 days ago

3.57ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices.iter() {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

Lê Minh Quân

aleister1102

9 days ago

4.71ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &index in indices {
        // Handle out-of-bound case
        if index >= slice.len() {
            continue;
        }
        slice[index] = value;
    }
}

EduardoFernandess

10 days ago

3.33ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for item in indices.iter() {
        if *item > slice.len() - 1 {
            continue;
        }
    slice[*item] = value;
    }
}

Yi Hao

leongyihao

10 days ago

3.25ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
	indices.iter().for_each(|&idx| {
		match slice.get_mut(idx) {
			None => (),
			Some(val) => *val = value
		}
	});
}

chuyuanlinzi

10 days ago

3.63ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    let len: usize = slice.len();
    
    for &i in indices.iter() {
        if i >= len {
            continue;
        }
        slice[i] = value;
    }
}

fyroostr

10 days ago

3.85ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices {
        if *i< slice.len() {
            slice[*i] = value;
        }
    }
}

PixelForg

11 days ago

3.59ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for index in indices {
        if *index < slice.len() {
            slice[*index] = value;
        }
    }
}

ahmedzghal

11 days ago

4.06ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for (inx,el) in slice.iter_mut().enumerate() {
        if indices.contains(&inx) {
            *el = value;
        }
    }
}

ahmedzghal

11 days ago

5.43ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for (inx,el) in slice.iter_mut().enumerate() {
        if indices.contains(&inx) {
            *el = value;
        }
    }
}

MESTRE Sylvain

Shult

11 days ago

6.32ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for (index_slice, value_slice) in slice.iter_mut().enumerate() {
        for value_indices in indices.iter() {
            if index_slice == *value_indices {
                *value_slice = value;
            }
        }
    }
}
// Best solution 
// pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
//     for &index in indices {
//         if let Some(elem) = slice.get_mut(index) {
//             *elem = value;
//         }
//     }
// }

Muhammad Najib Bala

NAJIB-B

11 days ago

4.09ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
  
   for i in indices.iter() {
      if *i > slice.len() - 1 {
        return
    }
    slice[*i] = value
   }
}

Tomaz Azinhal

tomazinhal

11 days ago

10.03ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for index in indices {
        if *index >= slice.len() {
            continue;
        }
        slice[*index] = value
    }
}

Ayushman Rathore

Spartan09

12 days ago

4.19ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for i in indices.iter() {
        if let Some(v) = slice.get_mut(*i) {
            *v = value;
        }
    }
}

Deaddy3

12 days ago

20.51ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &index in indices {
        if let Some(i) = slice.get_mut(index) {
            *i = value;
        }
    }
}

Dyaa Adel

dyaa-adel

13 days ago

3.60ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for v in indices.iter() {
        match slice.get_mut(*v) {
            Some(n) => { *n = value;},
            _ => continue
        }
    }
}

Alberto Nidasio

NidasioAlberto

13 days ago

3.91ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for &i in indices {
        if i < slice.len() {
            slice[i] = value;
        }
    }
}

Anıl Şenay

anilsenay

13 days ago

5.40ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &idx in indices {
        if let Some(num) = slice.get_mut(idx) {
            *num = value;
        }
    }
}

Evan

0xIchigo

13 days ago

3.36ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for i in indices.iter() {
        if *i < slice.len() {
            slice[*i] = value
        }
    }
}

Babuuu

aynugek

14 days ago

3.25ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for index in indices.iter() {
        match slice.get(*index) {
            Some(_) => slice[*index] = value,
            None => continue,
        }
    }
}

Jordan

Jordan-Haidee

14 days ago

3.31ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices {
        if let Some(v) = slice.get_mut(*i) {
            *v = value;
        }
    }
}

Icarus

IcarusxB

15 days ago

3.01ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    for &x in indices {
        if let Some(elem) = slice.get_mut(x) {
            *elem = value;
        }
    }
}

Kyle Diaz

kylediaz

15 days ago

4.78ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices.iter() {
        if *i < slice.len() {
            slice[*i] = value;
        }
    }
}

TiagONTOP

15 days ago

3.18ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for &ind in indices.iter() {
        if let Some(elem) = slice.get_mut(ind) {
            *elem = value;
        }
    }
}

SeinPierre

15 days ago

3.16ms

87.38kb

pub fn update_slice(slice: &mut [i32], indices: &[usize], value: i32) {
    // Implement your logic here
    for i in indices{
        if *i < slice.len(){
            slice[*i] = value
        }
    }
}