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

bernardoLY19

9 hours ago

2.91ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(val) => Ok(val),
        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()));
}

Miguel Ángel Allende

maallende

2 days ago

2.92ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    input.parse::<u32>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num| {
            if num <= 100 {
                Ok(num as u8)
            } 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()));
}

Baron Curtin

baroncurtin2

2 days ago

3.06ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(val) => Ok(val),
        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()));
}

Artem Nistuley

artemnistuley

2 days ago

3.17ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let value = input.parse::<u8>();
    match value {
        Err(_) => Err("Invalid input".to_string()),
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(val) => Ok(val),
    }
}
// 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()));
}

medzernik

2 days ago

3.44ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse().map_err(|_|format!("Invalid input"))? {
        val @ 0..=100 => Ok(val),
        _ => 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()));
}

Cobran53

3 days ago

2.87ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let i = input.parse();
    match i {
        Err(_) => Err("Invalid input".to_string()),
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(i) => Ok(i)
    }
    
}
// 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()));
}

silaskoemen

5 days ago

2.88ms

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

alexsavio

6 days ago

3.14ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse() {
        Err(_) => Err("Invalid input".to_string()),
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(i) => Ok(i),
    }
}
// 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()));
}

coreyralph

7 days ago

2.84ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Err(_) => Err("Invalid input".to_string()),
        Ok(101..) => Err("Percentage out of range".to_string()),
        Ok(i) => Ok(i)
    }
}
// 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()));
}

Herman effendi

hrmneffdii

8 days ago

2.99ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let result = input.clone().parse::<u8>();
    match result {
        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()));
}

Smith Cruise

Smith-Cruise

8 days ago

3.17ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let result: Result<u8, _> = input.parse();
    match result {
        Err(_) => Err("Invalid input".to_string()),
        Ok(v) => {
            if v > 100 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(v)
            }
        }
    }
}
// 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()));
}

Ushakov Andrey

stdstring

9 days ago

3.27ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<i32>() {
        Err(_) => Err("Invalid input".to_string()),
        Ok(value) if ((value < 0) | (value > 100)) => Err("Percentage out of range".to_string()),
        Ok(value) => Ok(value 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()));
}

vanos001

9 days ago

3.20ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    return match input.parse::<u8>() {
        Ok(t) if t <= 100 => Ok(t),
        Ok(t) if t > 100 => Err(String::from("Percentage out of range")),
        _ => 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()));
}

AtlasVakyrie

10 days ago

3.49ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let percent = input.parse::<u8>();
    match percent {
        Ok(p) if p > 100 => Err("Percentage out of range".to_string()),
        Ok(p) => Ok(p),
        _ => 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()));
}

Philippe Massicotte

PMassicotte

10 days ago

3.14ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    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()));
}

Kr0wZ

10 days ago

3.81ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let res = input.parse();
    let output = match res {
        Ok(value) if value <= 100 => Ok(value),
        Ok(_) => Err(String::from("Percentage out of range")),
        Err(_) => Err(String::from("Invalid input")),
    };
    output
}
// 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()));
}

Tri Nguyen

nguyentri

10 days ago

2.74ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let p = input.parse::<u8>();
    match p {
         Ok(n) => {
            if n <= 100 {
                Ok(n)
            } else {
                Err("Percentage out of range".to_owned())
            }
        }
        Err(_e) => Err("Invalid input".to_owned())
    }
}
// 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()));
}

Enes

enesscevik

13 days ago

2.98ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let u : Result<u8, _> = input.parse();
    match u {
        Ok(n) => if n <= 100 && n >= 0 {
            Ok(n)
        } else {
            Err("Percentage out of range".to_owned())
        }
        Err(_) => Err("Invalid input".to_owned())
    }
}
// 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()));
}

Christopher Kolbe

chkolbe

14 days ago

3.63ms

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 {
                Err("Percentage out of range".to_string())
            } else {
                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()));
}

Luigi Terrone

LuigiTer

14 days ago

3.14ms

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 {
                Err("Percentage out of range".to_string())
            } else {
                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()));
}

Satya Sundar Sahu

satya200

14 days ago

3.63ms

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

Gomathi Shankar

gomathishankar37

14 days ago

3.26ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    // match input.parse::<u8>() {
    //     Ok(val) => {
    //         if val <=100 { 
    //             Ok(val) 
    //         } else {
    //             Err("Percentage out of range".to_string())
    //         }
    //     },
    //     Err(_) => Err("Invalid input".to_string()),
    // }
    match input.parse::<u8>() {
        Ok(val) if val <=100 => Ok(val),
        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()));
}

0x0f1

Paul4673

14 days ago

3.12ms

81.43kb

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

Heino Mortensen

hmortensen83

15 days ago

4.23ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        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()));
}

dattruongdev

16 days ago

3.54ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(x) => {
            if x > 100  {
                return Err("Percentage out of range".to_string());
            }
            return Ok(x);
        },
        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()));
}

esl

esl07

16 days ago

3.41ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    const MIN_PORCENTAGE: u8 = 0;
    const MAX_PORCENTAGE: u8 = 100;
    if let Ok(number) = input.parse::<u8>() {
        match number >= MIN_PORCENTAGE && number <= MAX_PORCENTAGE {
            true => Ok(number),
            false => 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()));
}

xxxxsk

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

Pierre Gordo

PierreGordo

19 days ago

2.76ms

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

hahu07

20 days ago

3.13ms

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

Lucop1911

21 days ago

3.74ms

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

ikatlinsky

24 days ago

3.56ms

81.43kb

use std::str::FromStr;
pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let parsed = u8::from_str(input);
    match parsed {
        Ok(n) if n >= 0 && n <= 100 => Ok(n),
        Ok(n) => 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()));
}

0x90

riccio8

25 days ago

3.83ms

81.43kb


pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    input
        .parse::<u8>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num|{
            if num > 100{
                Err("Percentage out of range".to_string())
            }else{
                Ok(num)
            }
        })
}
// 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()));
}

diucicd

a month ago

3.09ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    input
        .parse::<u8>()
        .map_err(|_| "Invalid input".to_string())
        .and_then(|num| {
            if num > 100 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(num)
            }
        })
}
// 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()));
}

Hendrik Dreesmann

DeemanOne

a month ago

2.85ms

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

ycgw

a month ago

3.12ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(number) if number <= 100 => Ok(number),
        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()));
}

jeroenvgestel

a month ago

3.25ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let number: u8 = match input.parse() {
        Ok(num) => num,
        Err(_) => {
            return Err(String::from("Invalid input"));
        }
    };
    if number > 100 {
        return Err(String::from("Percentage out of range"))
    }
    return 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()));
}

Sergey Matyash

matiaspub

a month ago

3.85ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(v) => {
            if v > 100 {
                Err("Percentage out of range".to_string())
            }  else {
                Ok(v)
            }
        }
        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()));
}

AQian

AQian0

a month ago

3.87ms

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 {
                return Ok(num)
            } else {
                return Err(format!("Percentage out of range"))
            }
        },
        Err(_) => Err(format!("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()));
}

annececiledunand

a month ago

3.29ms

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,
        Err(_) => { return Err("Invalid input".to_string()); },
    };
    match number > 100 || number < 0 {
        false => Ok(number),
        true => 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()));
}

GregGorin

a month ago

3.24ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>(){
        Ok(percentage) => {if percentage <=100 {Ok(percentage)} 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()));
}

Ajit Kumar

urwithajit9

a month ago

3.77ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>(){
        Ok(percentage) => {
                if percentage <=100{
        Ok(percentage)
    }
    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()));
}

Maicon Crespo

maiconcrespo

a month ago

3.03ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
  
   match input.parse::<u8>(){
    Ok(value) =>{
        if value <= 100 {
                Ok(value)
            } 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()));
}

AlphaN00mer1cal

a month ago

3.81ms

81.43kb


pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>(){
        Ok(percent) => if percent <= 100 { Ok(percent) } 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()));
}

LeonardoPinheiro23

a month ago

3.98ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse() {
        Err(_) => Err(String::from("Invalid input")),
        Ok(number) if number <= 100 => Ok(number),
        Ok(_) => 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()));
}

zapp42

a month ago

3.26ms

86.75kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    let s = input.to_string();
    match s.parse::<u8>() {
        Ok(num) => if num <= 100 { Ok(num) } else { 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()));
}

wry

Liudel

a month ago

2.97ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(n @ 0..=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()));
}

Kenas Zogara

kenaszogara

a month ago

3.09ms

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,
        Err(_e) => return Err("Invalid input".to_string())
    };
    if number > 100 {
        return Err("Percentage out of range".to_string());
    }
    return 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()));
}

jbrakmic

a month ago

4.58ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    let res: u8 = input.parse().map_err(|_| "Invalid input".to_string())?;
    if res > 100 {
        return Err("Percentage out of range".to_string());
    } 
    Ok(res)
}
// 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()));
}

Saksinkarn Petchkuljinda

dward2nd

a month ago

3.78ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match input.parse::<u8>() {
        Ok(val) => {
            if val > 100 {
                Err("Percentage out of range".to_string())
            } else {
                Ok(val)
            }
        },
        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()));
}

Travis

ttmgraham

a month ago

4.09ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    match input.parse::<u8>() {
        Ok(n) => {
            if n <= 100 {
                Ok(n)
            } 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()));
}