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

muemart

3 hours 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())?; // <- 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),
    }
}

Christophe Mohimont

mohic

2 days ago

3.55ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    let first_element = numbers
        .first()
        .cloned()
        .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)
}

amdfxlucas

6 days ago

3.77ms

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>
    let val = first_element.ok_or("Vector is empty")?;
    if *val >= min_value
    {
        return Ok(*val)
    } 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),
    }
}

ashishkr2912

6 days ago

4.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(); // <- Returns an Option<&i32>
    let f = first_element.ok_or(String::from("Vector is empty"));
    match f {
        Ok(&value) if value >= min_value => Ok(value),
        Ok(_) => Err(String::from("First element is below the minimum allowed value")),
        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),
    }
}

Arpan Shingala

arpan-vs

6 days ago

3.10ms

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

StevenCanDrink

7 days ago

3.47ms

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

Chih Ying Yen

xavierforge

9 days ago

3.74ms

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(|&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),
    }
}

StevenCanDrink

11 days ago

4.30ms

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

StevenCanDrink

11 days ago

3.45ms

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

Thomas Michiels

mithom

12 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("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),
    }
}

johnson

ssebide

12 days ago

3.42ms

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(|&x| {
            if x < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(x)
            }
        })
}
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),
    }
}

undefeated_

boyboi86

12 days ago

3.25ms

87.41kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function, for vectors always rmb to destruct
    // better readability, simple and effective
    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());
    } else {
        Ok(*first_element)
    }
    /*
    // better scalability for more condition
    let first_element = numbers
    .first()
    .ok_or("Vector is empty".to_string()); // <- Returns an Option<&i32>
    // using match to handle the error instead of propogating with ?
    match first_element {
        Ok(first_element) => {
            if *first_element < min_value {
                return Err("First element is below the minimum allowed value".to_string());
            }
            Ok(*first_element)
        },
        Err(e) => Err(e)
        //Err("First element is below the minimum allowed value") => 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),
    }
}

GunGraveCpp

14 days ago

3.13ms

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.clone())
}
// 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),
    }
}

Lvfalue

16 days ago

3.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())?; // <- 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),
    }
}

Artem Nistuley

artemnistuley

18 days ago

4.06ms

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(first_element) => {
            if *first_element < min_value {
                return Err("First element is below the minimum allowed value".to_string());
            }
            Ok(*first_element)
        },
        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),
    }
}

David Rasch

dcrasch

19 days ago

3.73ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    numbers.first()
        .ok_or("Vector is empty".to_string())
        .and_then(|&num|if num < min_value 
            { Err("First element is below the minimum allowed value".to_string())} 
            else {Ok(num)})
}
// 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),
    }
}

Jean-baptiste JOFFRE

Indy79

19 days ago

29.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>
    match first_element {
        Ok(first_element) => {
            if min_value > *first_element {
                return Err("First element is below the minimum allowed value".to_string());
            }
            Ok(*first_element)
        },
        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),
    }
}

visanr

21 days ago

4.37ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    numbers
        .first()
        .ok_or("Vector is empty".to_string())
        .and_then(|num: &i32| {
            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),
    }
}

visanr

21 days ago

3.82ms

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 {
        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),
    }
}

toto

21 days ago

4.80ms

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

bzdula

21 days ago

3.40ms

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

Luka Bračun

lbracun

23 days ago

3.77ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    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),
    }
}

Ranjith Thangavel

RanjithECE24

24 days ago

4.03ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    match numbers.first() {
        Some(value) => {
            if *value >= min_value {
                Ok(*value)
            } else {
                Err(String::from("First element is below the minimum allowed value"))
            }
        },
        None => Err(String::from("Vector is empty")),
    }
}
// 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),
    }
}

Jai

jsat97

24 days ago

3.49ms

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 {
        Err("First element is below the minimum allowed value".to_string()) 
    } else {
        Ok(*first_element)
    }
    
    /*
    match first_element {
        Some(i) => if i < &min_value {
            return Err("First element is below the minimum allowed value".to_string());
        } else {
           return Ok(*i); 
        },
        None => return 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),
    }
}

Tommy

verse215

24 days ago

4.67ms

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 let Some(n) = first_element {
        if *n < min_value {
            return Err("First element is below the minimum allowed value".to_string());
        }
        Ok(n.clone())
    } else {
        return first_element.cloned().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),
    }
}

Christopher Deutsch

chrisdeutsch

25 days ago

3.30ms

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 {
        Err("First element is below the minimum allowed value".to_string())
    } else {
        Ok(first_element.clone())
    }
}
// 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),
    }
}

Wouter

WouterMartens

a month ago

3.77ms

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(|&x| {
            if x < min_value {
                Err("First element is below the minimum allowed value".to_string())
            } else {
                Ok(x)
            }
        })
}
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),
    }
}

shahab-tplus

a month ago

3.35ms

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

shahab-tplus

a month ago

3.28ms

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(|v| {
        if *v < min_value {
            Err("First element is below the minimum allowed value".to_string())
        } else {
            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),
    }
}

shahab-tplus

a month ago

4.60ms

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

whhc

a month 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(); // <- Returns an Option<&i32>
    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())
            }
        })
    // 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),
    }
}

Gurneet singh

GS-Jatt

a month ago

3.98ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
   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),
    }
}

Andy Randrianirina

andyslash

a month ago

4.22ms

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

Daniel Mestas

miel-codeai

a month ago

3.47ms

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

aghia98

a month ago

3.45ms

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

baschdik

a month ago

3.49ms

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>
                        .ok_or("Vector is empty")?;
    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),
    }
}

Evgenii Uglanov

winchest3r

a month ago

3.15ms

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 {
        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),
    }
}

aey4

a month ago

3.45ms

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 { 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),
    }
}

aey4

a month ago

4.13ms

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 { 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),
    }
}

manu3618

a month ago

3.04ms

87.44kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    // Finish the function
    if let Some(&first_element) = numbers.first(){
       if first_element >= min_value {
            Ok(first_element)
        } else {
            Err("First element is below the minimum allowed value".into())
        }
    } else {
        Err("Vector is empty".into())
    }
}
// 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),
    }
}

Marco Coccato

Ocrambana

a month ago

3.24ms

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

Fatih

0fatih

a month ago

3.16ms

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

Mark

schmark88

a month ago

4.17ms

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

Rose Emmons

roseemmons

a month ago

4.27ms

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(val) => if *val >= min_value { 
            Ok(*val) 
        } else {
            Err("First element is below the minimum allowed value".to_string())
        },
        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),
    }
}

slaws

a month ago

3.67ms

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

slaws

a month ago

3.34ms

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

Christopher Kolbe

chkolbe

a month ago

3.98ms

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 {
        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),
    }
}

Evrins Hu

evrins

a month ago

3.34ms

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.clone())
    }
}
// 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),
    }
}

johndoe30bc

a month ago

3.32ms

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

tdoan

a month ago

3.08ms

87.38kb

pub fn get_first_element(numbers: Vec<i32>, min_value: i32) -> Result<i32, String> {
    numbers
        .first()
        .copied()
        .ok_or(String::from("Vector is empty"))
        .and_then(|x| {
            if x < min_value {
                Err(String::from(
                    "First element is below the minimum allowed value",
                ))
            } else {
                Ok(x)
            }
        })
}
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}"),
    }
}