Option to Result

In the previous challenge we converted a Result<T, E> to an Option<T> by using the .ok() method, Rust provides us other mechanisms to convert an Option<T> to a Result<T, E> as well. In this challenge, you will learn how to use the .ok_or() method to convert an Option<T> to a Result<T, E>.

Your Task

Implement the function get_first_element:

Takes two parameters:
- A vector of integers (Vec<i32>).
- A minimum allowed value (i32).
Use the .first() method to retrieve the first element of the vector, this returns Option<&T>.
If the value is None, convert it to a Result<T, E> using the .ok_or() method with the error message "Vector is empty".
Then run a validation check to ensure the first element is greater than or equal to the minimum allowed value provided. If not, return an error with message "First element is below the minimum allowed value".
If everything is ok, return a Ok(T) with the first element.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

You can use the .ok_or() method and propagate the error cleanly. e.g.

let first_element = numbers.first().ok_or("Vector is empty".to_string())?;

Editor not available on Mobile!

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

Solutions

Luigi Terrone

LuigiTer

17 hours ago

2.94ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    
    if min_value > *first_element {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

0x0f1

Paul4673

20 hours ago

3.64ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if first_element < &min_value {
        return Err("First element is below the minimum allowed value".to_string())
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

esl

esl07

a day ago

3.58ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let &first_element = numbers.first().ok_or("Vector is empty".to_string())?;
    if first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Heino Mortensen

hmortensen83

2 days ago

3.16ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?;
    if first_element >= &min_value {
        Ok(*first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

AlphaN00mer1cal

7 days ago

3.29ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first = numbers.first().ok_or("Vector is empty".to_string())?;
    if *first < min_value{
        return Err("First element is below the minimum allowed value".to_string());
    }
    return Ok(*first);
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

ikatlinsky

8 days ago

3.82ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?;
    if *first_element >= min_value {
        return Ok(*first_element)
    }
    Err("First element is below the minimum allowed value".to_string())
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

0x90

riccio8

8 days ago

3.94ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if first_element < &min_value {
        return Err("First element is below the minimum allowed value".to_string())
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Saksinkarn Petchkuljinda

dward2nd

12 days ago

3.64ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

diucicd

13 days ago

3.48ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let &first_element = numbers.first().ok_or(String::from("Vector is empty"))?;
    if first_element < min_value {
        return Err(String::from(
            "First element is below the minimum allowed value",
        ));
    }
    Ok(first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Sergey Matyash

matiaspub

16 days ago

3.56ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first()
        .ok_or("Vector is empty".to_string())?;
    if *first_element >= min_value {
        Ok(*first_element)
    } else {
        Err(String::from("First element is below the minimum allowed value"))
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

AQian

AQian0

16 days ago

3.14ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string())
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

LeonardoPinheiro23

21 days ago

4.04ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let &first_element = numbers.first().ok_or(String::from("Vector is empty"))?;
    if first_element >= min_value {
        return Ok(first_element);
    }
    Err(String::from("First element is below the minimum allowed value"))
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Kenas Zogara

kenaszogara

22 days ago

5.25ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if first_element < &min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

jbrakmic

23 days ago

3.87ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Tengz Mao

MaoX-Yu

23 days ago

5.51ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = *numbers
        .first()
        .ok_or("Vector is empty".to_string())?;
    if first_element >= min_value {
        Ok(first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Tommytto

24 days ago

3.86ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().cloned().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if first_element < min_value {
        Err("First element is below the minimum allowed value".to_string())
    } else {
        Ok(first_element)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Erik Hollembeak

futureperfect

24 days ago

4.12ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?;
    if *first_element >= min_value {
        Ok(*first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Erik Hollembeak

futureperfect

24 days ago

3.80ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string());
    match first_element {
        Ok(num) => {
            if *num < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(*num)
            }
        },
        Err(msg) => Err(msg),
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Joerg Schad

joerg84

25 days ago

4.44ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string());
    match first_element {
        Ok(first_element) => {
            if *first_element >= min_value {
            return Ok(*first_element);
             } else {
                  return Err("First element is below the minimum allowed value".to_string())
             }
        },
        Err(err) => return Err(err)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Joerg Schad

joerg84

a month ago

4.53ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string());
    match first_element {
        Ok(first_element) => {
            if *first_element >= min_value {
            return Ok(*first_element);
             } else {
                  return Err("First element is below the minimum allowed value".to_string())
             }
        },
        Err(err) => return Err(err)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

sjmellor

a month ago

5.27ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if *first_element >= min_value {
        Ok(*first_element)
    }
    else
    {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

RASHMOR

RASHMOR1

a month ago

3.34ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
   let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
   if *first_element < min_value {
    Err("First element is below the minimum allowed value".to_string())
   }else{
    Ok(*first_element)
   }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Zeno

djeanql

a month ago

3.98ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32>
    match first_element {
        Some(num) =>
            if *num < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(*num)
            }
        ,
        None => first_element.copied().ok_or("Vector is empty".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Holger Knauer

hknauer

a month ago

3.98ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32
    if first_element.is_none() {
        return first_element.copied().ok_or("Vector is empty".to_string());
    }
    let v = first_element.copied().unwrap();
    if v < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(v)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

adamegao

a month ago

3.28ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    numbers
        .first()
        .map(|n| n.to_owned())
        .ok_or("Vector is empty".to_string())
        .and_then(|num| {
            if num >= min_value {
                Ok(num)
            } else {
                Err("First element is below the minimum allowed value".to_string())
            }
        })
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

adamegao

a month ago

3.66ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers.first(); 
    first_element
        .map(|n| n.to_owned())
        .ok_or("Vector is empty".to_string())
        .and_then(|num| {
            if num >= min_value {
                Ok(num)
            } else {
                Err("First element is below the minimum allowed value".to_string())
            }
        })
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

adamegao

a month ago

4.18ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32>
    let result = first_element
        .map(|n| n.to_owned())
        .ok_or("Vector is empty".to_string());
    match result {
        Ok(n) => {
            if n < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(n)
            }
        }
        Err(e) => Err(e),
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

ggnne

a month ago

4.18ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty")?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        Err("First element is below the minimum allowed value".to_string())
    } else {
        Ok(*first_element)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

zirkzee77

a month ago

3.56ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or(String::from("Vector is empty"))?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        Err(String::from("First element is below the minimum allowed value"))
    } else {
        Ok(*first_element)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Neel Knight

NeelKnight

a month ago

5.94ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if *first_element >= min_value {
        Ok(*first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Kanak Shilledar

kanakshilledar

a month ago

5.77ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    match first_element {
        Err(message) => Err(message),
        Ok(number) => {
            if number < &min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(*number)
            }
        }
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Seth Wood

seth-wood

a month ago

3.54ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    match first_element {
        Ok(n) => {
            if n < &min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(*n)
            }
        }
        Err(m) => Err(m),
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Kanak Shilledar

kanakshilledar

a month ago

4.94ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    match first_element {
        Err(message) => Err(message),
        Ok(number) => {
            if number < &min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(*number)
            }
        }
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

zazapalm3012

a month ago

3.97ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    match first_element {
        Err(message) => Err(message),
        Ok(number) => {
            if number < &min_value{
                Err("First element is below the minimum allowed value".to_string())
            }
            else{
                Ok(*number)
            }
        }
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Nicolai

Posmac

a month ago

4.80ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?;
    
    if *first_element < min_value {
        return Err(String::from("First element is below the minimum allowed value"));
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Felix Kiprotich

penscola

2 months ago

4.24ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
        numbers
        .first()
        .ok_or("Vector is empty".to_string())
        .and_then(|&num|
            if num>=min_value {
                Ok(num)
            }else{
                Err("First element is below the minimum allowed value".to_string())
            }
        )
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Health-Care-Movie

2 months ago

6.00ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()).copied()?;
    if first_element < min_value {
        Err("First element is below the minimum allowed value".to_string())
    } else {
        Ok(first_element)
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Elizabeth Doughty

Thymelizabeth

2 months ago

5.10ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    match numbers.first().copied() {
        Some(n) if n >= min_value => Ok(n),
        Some(_) => Err("First element is below the minimum allowed value".to_string()),
        None => Err("Vector is empty".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Splatrac

splatrac

2 months ago

3.97ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    let result = first_element.copied().and_then(|num| {
        if num >= min_value {
            Ok(num)
        } else {
            Err("First element is below the minimum allowed value".to_string())
        }
    });
    result
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Trịnh Chấn Duy

Duyyy123

2 months ago

3.77ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32>
    first_element
        .ok_or("Vector is empty".to_string())
        .and_then(|&value| {
            if value < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(value)
            }
        })
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Liyqq

2 months ago

4.36ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?.clone();
    if first_element >= min_value {
        Ok(first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

agamaontherock

2 months ago

3.81ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32>
    match first_element {
        None => {
            return first_element.ok_or("Vector is empty".to_string()).copied();
        },
        Some(&val) => {
            if val < min_value {
                return Err("First element is below the minimum allowed value".to_string());
            } else {
                return Ok(val);
            }
        }
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Maintain

duonghb53

2 months ago

3.32ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    match first_element {
        Err(msg) => Err(msg),
        Ok(number) => {
            if *number >= min_value {
                return Ok(*number);
            } else {
                return Err("First element is below the minimum allowed value".to_string());
            }
        }
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Nathan GAUD

Natchica

2 months ago

4.10ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers.first();
    match first_element {
        Some(num) => if *num >= min_value {
            Ok(*num)
        } else {
            Err("First element is below the minimum allowed value".to_string())
        }
        None => first_element.ok_or("Vector is empty".to_string()).copied()
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Nguyen Vo Hoang Son

sonmessia

2 months ago

4.10ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first(); // <- Returns an Option<&i32>
    let result = first_element.ok_or("Vector is empty".to_string()).copied()?;
    if first_element.ok_or("Vector is empty".to_string()).copied()? < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(result)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Paolo Cancedda

Pac72

2 months ago

3.32ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = *numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if first_element >= min_value {
        Ok(first_element)
    } else {
        Err("First element is below the minimum allowed value".to_string())
    }
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

mishbah

2 months ago

4.04ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers.first();
    let result = first_element
        .ok_or("Vector is empty".to_string())
        .copied()?;
    if result < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(result)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

mishbah

2 months ago

3.71ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers.first();
    let result = first_element
        .ok_or("Vector is empty".to_string())
        .copied()?;
    if first_element
        .ok_or("Vector is empty".to_string())
        .copied()?
        < min_value
    {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(result)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

asdfman

2 months ago

4.26ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string())
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Nhat Vu

NhatTinyVu

2 months ago

3.43ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    let first_element = numbers.first().ok_or("Vector is empty".to_string())?; // <- Returns an Option<&i32>
    if *first_element < min_value {
        return Err("First element is below the minimum allowed value".to_string());
    }
    Ok(*first_element)
}
// Example usage
pub fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    match get_first_element(numbers.clone(), 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
    let empty_numbers: Vec<i32> = vec![];
    match get_first_element(empty_numbers, 15) {
        Ok(value) => println!("First valid value: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}