Graceful error handling

One of the most loved features of Rust is the way it lets you handle errors. The Result type is a powerful tool that allows you to handle errors in a way that is both safe and expressive. In this challenge, you will be working with the Result<T, E> type to handle errors in a graceful way.

The Result<T, E> itself is an enum that has two variants: Ok(T) and Err(E). The Ok variant is used to represent a successful computation that returns a value of type T. The Err variant is used to represent an error that returns a value of type E.

When you have a function that can fail, you can use the Result type to return the result of the computation. If the computation is successful, you can return the success variant of Result with the value of the computation. If the computation fails, you can return the error variant of Result with an error message that explains what went wrong.

Your task

In this challenge, you're given a function, parse_percentage that takes a string as input and returns a Result type. The function should parse the input string as a percentage and return the percentage as a u8 if the input is valid. If the input is invalid, the function should return an error message as a String.

Parsing from a string to a number can fail for many reasons. For example, the input string may not be a valid number, or it may be a valid number but not a valid percentage. Your task is to handle these errors gracefully and return an error message that explains what went wrong.

Complete the function, if the parsing was successful return a success variant of the Result, if there was an error in parsing, return an error variant of the Result with an error message.

Requirements

If the parse was successful, the function should return the success variant of Result with the percentage as a Ok(u8).
If the number was out of range (not between 0 and 100), the function should return the error with String Err("Percentage out of range").
If the string was not a valid number, the function should return the error with String Err("Invalid input").

Editor not available on Mobile!

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

Solutions

Özgür

AyikOzgur

a day ago

2.87ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let value = input.parse();
    match value {
        Ok(v) => {
            if v >= 0 && v <= 100 {
                return Ok(v);
            } else {
                return Err("Percentage out of range".to_string());
            }
        }
        Err(_e) => {
            return Err("Invalid input".to_string());
        }
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

emiludenz

a day ago

2.92ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let n = input.parse::<u8>();
    if n.is_ok() {
        let num = n.unwrap();
        if num <= 100 {
            Ok(num)
        } else {
            Err("Percentage out of range".to_string())
        }
    } else {
        Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Anthony Young

A-Young-Git

2 days ago

3.51ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}
// if successful, return Ok(u8)
// if num out of range !(0 - 100), return custom String
// if string not valid number, return custom string

azmahflameheart

3 days ago

2.80ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    
    match input.trim().parse::<i32>() {
        Err(_) => Err("Invalid input".to_string()),
        Ok(n) if n > 100 || n < 0 => Err("Percentage out of range".to_string()),
        Ok(n) => Ok(n as u8),
    }   
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Egu0

egu0

3 days ago

3.14ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let mut target: u8 = 0;
    for &b in input.as_bytes() {
        if (48..=57).contains(&b) {
            target *= 10;
            target += b - 48;
        } else {
            return Err(String::from("Invalid input"));
        }
    }
    if target > 100 {
        return Err(String::from("Percentage out of range"));
    }
    Ok(target)
}

Marouan Boulahtouf

MBoulahtouf

4 days ago

3.39ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<i32>() {
        Ok(num) => {
            if num >= 0 && num <= 100 {
                Ok(num as u8)
            } else {
                Err("Percentage out of range".to_string())
            }
        }
        Err(_) => {
            Err("Invalid input".to_string())
        }
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

LawisChen

6 days ago

2.99ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(parsed) = i32::from_str_radix(input, 10) {
        return match parsed {
            0..=100 => Ok(parsed as u8),
            _ => Err("Percentage out of range".to_string()),
        };
    }
    return Err("Invalid input".to_string());
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

batblerone

6 days ago

3.01ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(i) => if i <= 100 { Ok(i) } else { Err("Percentage out of range".to_string())},
        Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

ffrie

6 days ago

2.95ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(a) => if a <= 100 { Ok(a) } else { Err("Percentage out of range".to_string())},
        Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Sheren Yogesh Narayanan

Nsy97

7 days ago

3.24ms

86.75kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let string:String = input.to_string();
    match string.trim().parse() {
        Ok(n) => if n > 100 {
            Err("Percentage out of range".to_string())
        }
        else {
            Ok(n)
        },
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Ramon Silva

rsilva1

7 days ago

3.36ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percentage = input.parse::<u8>().map_err(|_| String::from("Invalid input"))?;
    if percentage <= 100 {
        Ok(percentage)
    } else {
        Err(String::from("Percentage out of range"))
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

vqk-2003

7 days ago

3.01ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if let Ok(value) = input.parse::<u8>() {
        if value <= 100 {
            Ok(value)
        } else {
            Err(String::from("Percentage out of range"))
        }
    } else {
        Err(String::from("Invalid input"))
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Snoweuph

snoweuph

10 days ago

4.02ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(value) => {
            if value > 100 {
                return Err("Percentage out of range".into());
            }
            Ok(value)
        }
        Err(_) => Err("Invalid input".into()),
    }
}

Reda

RedaHamouche

10 days ago

3.04ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
   
    match input.parse::<u8>() {
        Ok(value) => {
            if value <= 100 {
                Ok(value)
            } else {
                Err("Percentage out of range".to_string())
            }
        }
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Amit Patel

amitpatel-wstf

11 days ago

2.99ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Ok(num) => {
            if num > 100 {
                Err("Percentage out of range".to_string())
            }else{
                Ok(num)
            }
        },
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

makinpaper

11 days ago

2.77ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Ok(n) => {
            if n > 100 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(n)
            }
        }
        Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

fasolyee

fasolyeedev

11 days ago

4.38ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if let Ok(parsed_num) = input.parse::<u8>(){
        if parsed_num <= 100 && parsed_num >= 0{
            Ok(parsed_num)
        }
        else{
            Err("Percentage out of range".to_string())
        }
    }
    else{
        Err("Invalid input".to_string())
    }
    
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Dan Wayne

danwayne-me

11 days ago

3.74ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let Ok(n): Result<i32, _> = input.parse() else {
        return Err("Invalid input".to_string());
    };
    if n < 0 || n > 100 {
        return Err("Percentage out of range".to_string());
    }
    Ok(n as u8)
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

gtakacse

15 days ago

3.03ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) if n > 100 => Err(String::from("Percentage out of range")),
        Ok(n) => Ok(n),
        Err(_) => Err(String::from("Invalid input")),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Tim Boex

tboex

16 days ago

3.11ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(num) => {
            if num >= 0 && num <= 100 {
                return Ok(num);
            }
        }
        _ => {
            return Err(String::from("Invalid input"));
        }
    }
    Err(String::from("Percentage out of range"))
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

SpontaneousOverthrow

16 days ago

3.20ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let number = match input.parse::<u8>() {
        Ok(number)  => number,
        _ => return Err("Invalid input".to_string()),
    };
    if number > 100 || number < 0 {
        return Err("Percentage out of range".to_string())
    }
    Ok(number)
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Alan Castro

acsoliz

17 days ago

3.18ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
  let response = input.trim().parse::<u8>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num| {
            if num <= 100 {
                Ok(num)
            } else {
                Err("Percentage out of range".to_string())
            }
        });
        match response {
            Ok(num) => Ok(num),
            Err(e) => Err(e),
        }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

MöNir

Monir-Ruet

18 days ago

3.27ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    input
        .parse::<u8>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|value| {
            if value <= 100 {
                Ok(value)
            } else {
                Err("Percentage out of range".to_string())
            }
        })
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Omar Saber Talaat Abdelrahman

omar-s-ta

18 days ago

3.19ms

81.43kb

pub fn _parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(number) = input.parse::<u8>() {
        if (0..=100).contains(&number) {
            Ok(number)
        } else {
            Err("Percentage out of range".to_string())
        }
    } else {
        Err("Invalid input".to_string())
    }
}
pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Omar Saber Talaat Abdelrahman

omar-s-ta

18 days ago

9.41ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(number) = input.parse::<u8>() {
        if (0..=100).contains(&number) {
            Ok(number)
        } else {
            Err("Percentage out of range".to_string())
        }
    } else {
        Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Lambda

L4bda

18 days ago

3.05ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) => if n > 100 {
             return Err("Percentage out of range".to_string())
        }
        else {
            return Ok(n)
        },
        Err(_) => return Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Lambda

L4bda

18 days ago

7.04ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) => if n > 100 {
             return Err("Percentage out of range".to_string())
        }
        else {
            return Ok(n)
        },
        Err(_) => return Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

<YoungAncient/>

youngancient

20 days ago

3.07ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let m = input.parse::<u8>();
    match m{
        Ok(val) => {
            if (0..=100).contains(&val) {
                return Ok(val)
                }
            else{
                return Err("Percentage out of range".to_string());
            }
        },
        Err(_) => return Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Karshik Madavi

c0d3c

21 days ago

3.72ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.trim().parse() {
        Ok(num) =>{
            if num > 100 {
                Err(String::from("Percentage out of range"))
            }
            else {
                Ok(num)
            }
        },
        Err(_) => Err(String::from("Invalid input")),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Karshik Madavi

c0d3c

21 days ago

4.14ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let num:i32 = input.trim().parse().unwrap_or_else(|x| {
        -1
    });
    if num >= 0 && num <= 100 {
        Ok(num as u8)
    }
    else if num == -1 {
        Err("Invalid input".to_string())
    }
    else{
        Err("Percentage out of range".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Dharm Singh

dharmvr1

22 days ago

3.11ms

81.43kb


pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let num: Result<u8, String> = input.parse::<u8>().map_err(|_| "Invalid input".to_string());
    match num {
        Ok(x)=>{
            if x>=0 && x<=100{
                Ok(x)
            }
            else{
                Err("Percentage out of range".to_string())
            }
        }
        Err(_)=> Err("Invalid input".to_string())
    }    
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

noname

random1106

22 days ago

4.51ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n) if n <= 100 => Ok(n),
        Ok(_) => Err("Percentage out of range".to_string()),
        Err(_) => Err("Invalid input".to_string()),
    }
    
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Gerasimos

glomvardos

23 days ago

2.86ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Some(num) = input.parse::<u8>().ok() {
        if num <= 100 {
            return Ok(num);
        };
      return Err("Percentage out of range".to_string());
    }
    Err("Invalid input".to_string())
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Mykhailo Huzhvii

Ymkavi

24 days ago

4.22ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(value) => {
            if value > 100 {
                return Err("Percentage out of range".to_string());
            }
            return Ok(value);
        },
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Mykhailo Huzhvii

Ymkavi

24 days ago

4.07ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(value) => {
            if value > 100 {
                return Err("Percentage out of range".to_string());
            }
            return Ok(value);
        },
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

kasaxpong

25 days ago

2.90ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(number) => {
            if number <= 100 {
                return Ok(number);
            } else {
                return Err("Percentage out of range".to_string());
            }
        }
        Err(_) => {
            return Err("Invalid input".to_string());
        }
    }
} 
   
   
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

yrd241

a month ago

3.07ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(number) => {
            if number <= 100 {
                return Ok(number);
            } else {
                return Err("Percentage out of range".to_string());
            }
        } 
        Err(_) => {
            return Err("Invalid input".to_string());
        }
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

matthew-snyder

a month ago

3.75ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
        let result = input.parse::<u8>();
        match result {
            Ok(x) => {
                if x >= 0 && x <= 100 { Ok(x)}
                else {Err("Percentage out of range".to_string())}
            }
            Err(_) => Err("Invalid input".to_string())
        }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

银雀Sparrxw

Sparr0www820

a month ago

3.01ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(_) => Err("Percentage out of range".into()),
        _ => Err("Invalid input".into()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

cmdrtomalak

a month ago

3.13ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) if n <= 100 => {
            return Ok(n);
        },
        Ok(n) if n > 100 => {
            return Err("Percentage out of range".to_string());
        }
        _ => {
            return Err("Invalid input".to_string());
        }
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

hidethere

a month ago

3.29ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(i) if i < 101 => Ok(i),
        Ok(i) if i > 100 => Err("Percentage out of range".to_string()),
        Ok(_) | Err(_) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

ychanghe

a month ago

3.20ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if input.is_empty() {
        return Err("Invalid input".to_string()); 
    }
    else{
        let mut sum:u8 = 0; 
        for c in input.chars() {
            if let Some(number) = c.to_digit(10) {
                sum = 10*sum + (number as u8) ; 
                if sum > 100 {
                    return Err("Percentage out of range".to_string()); 
                }
            }
            else {
                return Err("Invalid input".to_string()); 
            }
        }
        return Ok(sum);
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Bastien VINH

bastienvinh

a month ago

5.90ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let result = input.parse();
    if let Err(..) = result {
        Err(String::from("Invalid input"))
    } else {
        let parsed_number = result.unwrap();
        if parsed_number > 100 {
            Err(String::from("Percentage out of range"))
        } else {
            Ok(parsed_number)
        }
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

/sam

samging

a month ago

3.19ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err(String::from("Percentage out of range")),
        Err(_) => Err(String::from("Invalid input")),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Ari Karim

arikarim

a month ago

3.92ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Ok(num) => {
            if num < 101 {
                Ok(num)
            } else {
                Err("Percentage out of range".to_string())
            }
        }
        Err(_e) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Dr. Frederik Lauber

FrederikLauber

a month ago

27.71ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let number = input.parse::<u8>().map_err(|_| "Invalid input".to_string())?;
    if number > 100 {
        return Err("Percentage out of range".to_string());
    }
    Ok(number)
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Kishan

wdcs-kishansudani

a month ago

3.26ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(num) if num > 100 => Err(String::from("Percentage out of range")),
        Ok(num) => Ok(num),
        Err(_) => Err(String::from("Invalid input")),
    }
    
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

gibransomerville

a month ago

3.79ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) if num <= 100 => Ok(num),
        Ok(num) => Err("Percentage out of range".to_string()),
        Err(e) => Err("Invalid input".to_string()),
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Yummy-Yums

a month ago

3.65ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let res  = input.parse();
    
    match res {
        Ok(number) => if number > 100 {
            Err(String::from("Percentage out of range"))
        } else { Ok(number) },
        Err(_) => Err("Invalid input".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}

Asrul Firdaus

AsrulF

a month ago

5.85ms

81.43kb

use std::num::IntErrorKind;
pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(num) if num > 100 => Err("Percentage out of range".to_string()),
        Ok(num) => Ok(num),
        Err(e) if *e.kind() == IntErrorKind::InvalidDigit => Err("Invalid input".to_string()),
        Err(_) => Err("Program error".to_string())
    }
}
// Example usage
pub fn main() {
    let result = parse_percentage("50");
    assert_eq!(result, Ok(50));
    let result = parse_percentage("101");
    assert_eq!(result, Err("Percentage out of range".to_string()));
    let result = parse_percentage("abc");
    assert_eq!(result, Err("Invalid input".to_string()));
}