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

anhdoo

TuanAnhDoHoang

3 days ago

3.88ms

81.43kb

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

TestingPurpose14

5 days ago

4.19ms

81.43kb

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

Teimur Gasanov

teimurjan

5 days ago

4.28ms

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 || n < 0 {
                return Err("Percentage out of range".to_string());
            }
            Ok(n)
        },
        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()));
}

Seth Wood

seth-wood

6 days ago

3.63ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // Attempt to parse the input string as a u8
    let parsed = input.parse::<u8>();
    if parsed.is_err() {
        return Err("Invalid input".to_string());
    }
    let parsed_ok = parsed.unwrap();
    if parsed_ok > 100 {
        return Err("Percentage out of range".to_string());
    }
    Ok(parsed_ok)
}
// 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()));
}

adamegao

7 days ago

6.10ms

81.43kb

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

Ben Thorburn

0x220E

7 days ago

4.58ms

81.43kb

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

Kanak Shilledar

kanakshilledar

8 days ago

3.46ms

81.43kb

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

Nicolai

Posmac

9 days ago

5.15ms

81.43kb

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

zazapalm3012

9 days ago

3.50ms

81.43kb

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

Thomastienn

12 days ago

5.80ms

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

Health-Care-Movie

12 days ago

3.58ms

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

Health-Care-Movie

12 days ago

4.33ms

81.43kb

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

Health-Care-Movie

12 days ago

3.64ms

81.43kb

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

Elizabeth Doughty

Thymelizabeth

12 days ago

4.42ms

81.43kb

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

Splatrac

splatrac

13 days ago

4.84ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    if input.parse::<u8>().is_ok() {
        let num = input.parse::<u8>().unwrap();
        if num <= 100 {
            Ok(num)
        } 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()));
}

Trịnh Chấn Duy

Duyyy123

15 days ago

3.29ms

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

Léa Narzis

lean-apple

16 days ago

3.16ms

81.43kb

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

Liyqq

18 days ago

3.51ms

81.43kb

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

agamaontherock

19 days ago

3.06ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function heree
    let mut num = 0u32;
    // let mut chars = input.chars();
    // let chars: Vec<char> = input.chars().collect();
    // let slen = chars.len();
    
    // for i in (slen-1)..0 {
    for (i, ch) in input.chars().rev().enumerate() {
        // let ch = input.chars().nth(i).unwrap();
        if ch.is_digit(10) {
            let digit = ch.to_digit(10).unwrap();
            num += digit * 10u32.pow((i) as u32);
        } else {
            return Err("Invalid input".to_string());
        }
    }
    if num <= 100 {
        return Ok(num as u8);
    } else {
        return 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()));
}

agamaontherock

19 days ago

4.05ms

86.75kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function heree
    let mut num = 0u32;
    // let mut chars = input.chars();
    let chars: Vec<char> = input.chars().collect();
    // let slen = chars.len();
    
    // for i in (slen-1)..0 {
    for (i, ch) in chars.iter().rev().enumerate() {
        // let ch = input.chars().nth(i).unwrap();
        if ch.is_digit(10) {
            let digit = ch.to_digit(10).unwrap();
            num += digit * 10u32.pow((i) as u32);
        } else {
            return Err("Invalid input".to_string());
        }
    }
    if num <= 100 {
        return Ok(num as u8);
    } else {
        return 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()));
}

Vladimir

PavluninVladimir

20 days ago

3.92ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // Attempt to parse the input string as an integer
    match input.parse::<u8>() {
        Ok(value) => {
            // Check if the parsed value is within the valid range for percentages
            if value <= 100 {
                Ok(value)
            } else {
                Err("Percentage out of range".to_string())
            }
        }
        Err(_) => {
            // If parsing fails, return an "Invalid input" error
            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()));
}

Heatiche Mix

HeaticheTakachi

21 days ago

4.02ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // First, try to parse the input string to an i32
    let num = match input.parse::<i32>() {
        Ok(num) => num,
        Err(_) => return Err("Invalid input".to_string()),
    };
    
    // Then check if the number is within valid percentage range (0-100)
    if num > 100 || num < 0 {
        return Err("Percentage out of range".to_string());
    }
    
    // If valid, convert to u8 and return
    Ok(num 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()));
}

Felix Kiprotich

penscola

24 days ago

4.54ms

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

Neel Knight

NeelKnight

a month ago

3.44ms

81.43kb

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

Nathan GAUD

Natchica

a month ago

3.85ms

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

Paolo Cancedda

Pac72

a month ago

2.89ms

81.43kb

use std::str::FromStr;
pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    match u8::from_str(input) {
        Ok(value) => {
            if value <= 100 {
                Ok(value)
            } 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()));
}

mishbah

a month ago

3.83ms

81.43kb

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

Maintain

duonghb53

a month ago

3.76ms

81.43kb

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

torbenhardt

a month ago

4.52ms

81.43kb

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

asdfman

a month ago

12.61ms

81.43kb

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

RASHMOR

RASHMOR1

a month ago

5.43ms

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

Jakub Wiśniewski

wisniewskij

a month ago

4.52ms

81.43kb

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

Nguyen Vo Hoang Son

sonmessia

a month ago

4.12ms

81.43kb

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

Jason

Jason-fy-wang

a month ago

3.54ms

81.43kb

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

Nhat Vu

NhatTinyVu

a month ago

3.53ms

81.43kb

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

vijayabhaskar badireddi

ptcte

a month ago

9.89ms

81.43kb

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

Haritarth Bhardwaj

Haritarth

a month ago

3.05ms

81.43kb

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

Levio-z

a month ago

14.60ms

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{
                Err("Percentage out of range".into())
            }else{
                Ok(n)
            }
        }  // 输出: 转换后的数字是: 123
        Err(_) => {
            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()));
}

shibu-t

a month ago

4.00ms

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

Marcel Schiffel

mschiffel

a month ago

3.57ms

81.43kb

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

Assylbek Razakhbergenov

asylbek27

a month ago

2.92ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    if let Ok(num) = input.parse::<i32>() {
        if num < 0 || num > 100 {
            return Err("Percentage out of range".to_owned());
        } else {
            return Ok(num as u8);
        }
    }
    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()));
}

Deaddy3

a month ago

3.25ms

81.43kb

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

Antenaina

antenaina0

a month ago

5.29ms

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

roboquaternion

a month ago

3.10ms

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())
            } else {
                return Ok(x)
            }
        }
        _ => 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()));
}

hosa200

a month ago

3.25ms

81.43kb

pub fn parse_percentage(input: &str) -> Result<u8, String> {
    // TODO: Implement the function here
    for n in input.chars() {
        if !n.is_numeric() {
            return Err("Invalid input".to_string());
        }
    }
    let num: i32 = input.parse().unwrap();
    if !(0..=100).contains(&num) {
        Err("Percentage out of range".to_string())
    } else {
        Ok(num 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()));
}

ON-MX

a month ago

4.20ms

81.43kb

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

Kondorok

a month ago

4.59ms

81.43kb

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

Jason

chenjie1219

2 months ago

9.23ms

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

Yixian Du

duyixian1234

2 months ago

8.71ms

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

Jason

chenjie1219

2 months ago

3.11ms

81.43kb

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