Find the First Palindrome

In this challenge, you will demonstrate your understanding of control flow in Rust. The task involves finding the first palindrome number in a given range.

What's a palindrome?

A palindrome is a number that reads the same backward as forward. This exercise will require you to iterate through the range, check each number to see if it is a palindrome, and return the first palindrome found. You can use any control flow construct to solve this problem.

Palindromes are fascinating numbers, and finding them within a range will require efficient control flow logic to ensure you identify the first one accurately.

Your task

You need to write a function, find_first_palindrome(start: i32, end: i32) -> Option<i32>, that takes two integer arguments start and end. The function should return the first palindrome number within the range (inclusive). If there are no palindromes in the range, it should return None.

Requirements

The function should iterate through the numbers from start to end.
It should check each number to determine if it is a palindrome.
The function should return the first palindrome found, or None if no palindromes exist in the range.
You must handle cases where start may be greater than end.

Example

let result = find_first_palindrome(10, 30);
assert_eq!(result, Some(11)); // 11 is the first palindrome in the range
 
let result = find_first_palindrome(100, 105);
assert_eq!(result, Some(101)); // 101 is the first palindrome in the range
 
let result = find_first_palindrome(123, 130);
assert_eq!(result, None); // No palindromes in this range

Did you know?

Did you know that palindromes are not just limited to numbers? They are found in words, phrases, and even DNA sequences! For example, the word "racecar" is a palindrome, as it reads the same backward and forward. Palindromes are fascinating in various fields, including mathematics, literature, and biology, where they often have unique properties and significance.

Hints

To check if a number is a palindrome, convert it to a string and compare it with its reverse.
You can get the reverse by using the rev() method on a char.
You can get the chars in a string by using the chars() method on a String
Use a loop, iterator, or any other control flow construct to check each number in the range until a palindrome is found or the range is exhausted.
Remember to handle the case where start is greater than end by swapping the values if necessary.

Editor not available on Mobile!

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

Solutions

Thomas Bui

ad0x99

5 hours ago

2.50ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    if start > end {
        return None;
    }
    for num in start..=end {
        let num_str = num.to_string();
        let reversed_str = num_str.chars().rev().collect::<String>();
        if num_str == reversed_str {
            return Some(num);
        }
    }
    None
}

sander-b-postnl

9 hours ago

2.38ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for num in start..=end {
        if is_palindrome(num) {
            return Some(num);
        }
    }
    None
}
fn is_palindrome(num: i32) -> bool {
    let num_str = num.to_string();
    let reversed: String = num_str.chars().rev().collect();
    num_str == reversed
}

José Bernardo

jose-bernardo

18 hours ago

2.49ms

87.38kb

pub fn is_palindrome(n: i32) -> bool {
    let mut m = n;
    let mut rev_n = 0;
    while m > 0 {
        rev_n = rev_n * 10 + m % 10;
        m /= 10;
    }
    rev_n == n
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for x in start..=end {
        if is_palindrome(x) {
            println!("{}", x);
            return Some(x)
        }
    }
    None
}

Mikhail

mk-comm

a day ago

2.42ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // Ensure the range is valid by swapping if necessary
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for num in start..=end {
        if is_palindrome(num) {
            return Some(num);
        }
    }
    None
}
fn is_palindrome(num: i32) -> bool {
    let num_str = num.to_string();
    let reversed: String = num_str.chars().rev().collect();
    num_str == reversed
}

pickx

a day ago

2.31ms

81.58kb

fn is_palindrome(n: i32) -> bool {
    let mut n = n.abs();
    let nearest_pow_of_10 = 10_u32.pow(n.ilog10());
    let mut nearest_pow_of_10 = i32::try_from(nearest_pow_of_10).unwrap();
    while n >= 10 {
        let msb = n / nearest_pow_of_10;
        let lsb = n % 10;
        if msb != lsb { return false }
        n %= nearest_pow_of_10; // remove msb
        n /= 10; // remove lsb
        nearest_pow_of_10 /= 100;
    }
    true
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // weird requirement
    let mut range = if start <= end { start..=end } else { end..=start };
    range.find(|&n| is_palindrome(n))
}

Carlos Arias

carlos-quantexai

a day ago

2.40ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // Ensure the range is valid
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for number in start..=end {
        if is_palindrome(number) {
            return Some(number); // Return the first palindrome found
        }
    }
    None // Return None if no palindromes are found
}
fn is_palindrome(num: i32) -> bool {
    let str_num = num.to_string(); // Convert the number to a string
    str_num == str_num.chars().rev().collect::<String>() // Check if it reads the same forwards and backwards
}

Delta Regeer

digitalresistor

a day ago

2.51ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let range = if start > end {
        end..=start
    } else {
        start..=end
    };
    for n in range {
        let mystr = n.to_string();
        if mystr.chars().rev().eq(mystr.chars()) {
            return Some(n);
        }
    }
    None
}

Delta Regeer

digitalresistor

a day ago

2.58ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let range = if start > end {
        end..=start
    } else {
        start..=end
    };
    for n in range {
        let mystr = format!("{n}");
        if mystr.chars().rev().eq(mystr.chars()) {
            return Some(n);
        }
    }
    None
}

Delta Regeer

digitalresistor

a day ago

2.46ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end {
        (end, start)
    } else {
        (start, end)
    };
    for n in start..=end {
        let mystr = format!("{n}");
        if mystr.chars().rev().eq(mystr.chars()) {
            return Some(n);
        }
    }
    None
}

Delta Regeer

digitalresistor

a day ago

2.54ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end {
        (end, start)
    } else {
        (start, end)
    };
    for n in start..=end {
        let mystr = format!("{n}");
        let mystr_rev = mystr.chars().rev();
        if mystr_rev.eq(mystr.chars()) {
            return Some(n);
        }
    }
    None
}

Maxence Potier

Mxn-ptr

a day ago

2.55ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let mut start = start;
    let mut end = end;
    if start > end {
        let tmp = start;
        start = end;
        end = tmp;
    }
    for i in start..=end {
        let s = i.to_string();
        if s == s.chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

Maxence Potier

Mxn-ptr

a day ago

2.41ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let mut start = start;
    let mut end = end;
    if start > end {
        let tmp = start;
        start = end;
        end = tmp;
    }
    for i in start..=end {
        let s = i.to_string();
        if s == s.chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

Hin Phansa

hinphansa

a day ago

2.33ms

81.58kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    match start > end {
        true => return find_first_palindrome(end, start),
        false => (),
    }
    for i in start..=end {
        if i == reverse_int(i) {
            return Some(i);
        }
    }
    None
}
fn reverse_int(n: i32) -> i32 {
    let mut n = n;
    let mut reversed = 0;
    while n != 0 {
        let digit = n % 10;
        reversed = reversed * 10 + digit;
        n /= 10;
    }
    reversed
}

Hin Phansa

hinphansa

a day ago

2.28ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    match start > end {
        true => return find_first_palindrome(end, start),
        false => (),
    }
    for i in start..=end {
        let n = i.to_string();
        let rev = n.chars().rev().collect::<String>();
        if n == rev {
            return Some(i);
        }
    }
    None
}

Nostalgia

lvyuemeng

a day ago

2.45ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    let start_str = start.to_string();
    let len = start_str.len();
    let first_half = &start_str[..(len + 1) / 2];
    let second_half = &start_str[..len / 2].chars().rev().collect::<String>();
    let palindrome_str = format!("{}{}", first_half, second_half);
    
    let palindrome = palindrome_str.parse::<i32>().unwrap();
    
    if palindrome >= start && palindrome <= end {
        return Some(palindrome);
    }
    
    None
}

Nostalgia

lvyuemeng

a day ago

2.36ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    let start_str = start.to_string();
    let len = start_str.len();
    
    // Create the palindrome by mirroring the first half of the string
    let first_half = &start_str[..(len + 1) / 2];
    let second_half = &start_str[..len / 2].chars().rev().collect::<String>();
    let palindrome_str = format!("{}{}", first_half, second_half);
    
    // Convert the palindrome string back to an integer
    let palindrome = palindrome_str.parse::<i32>().unwrap();
    
    // Check if the palindrome is within the bounds
    if palindrome >= start && palindrome <= end {
        return Some(palindrome);
    }
    
    None
}

funny_233

funny233-github

a day ago

2.35ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let mut sp = start;
    let mut ep = end;
    if sp > ep {
        let tmp = ep;
        ep = sp;
        sp = tmp;
    }
    for i in sp..=ep {
        let mut s = format!("");
        let mut tmp = i;
        while tmp > 0 {
            s += (tmp % 10).to_string().as_ref();
            tmp /= 10;
        }
        if s == s.chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

Dante Kelly

dantekelly

2 days ago

2.58ms

81.58kb

use std::mem;
pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end {
        mem::swap(&mut start, &mut end)
    }
    for n in start..=end {
        if reverse_int(n) == n {
            return Some(n);
        }
    }
    None
}
fn reverse_int(mut num: i32) -> i32 {
    let radix = 10;
    let mut n = 123;
    let mut reversed = 0;
    while num != 0 {
        reversed = reversed * radix + num % radix;
        num /= radix;
    }
    
    return reversed;
}

Dante Kelly

dantekelly

2 days ago

2.53ms

81.58kb

use std::mem;
pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end {
        mem::swap(&mut start, &mut end)
    }
    for n in start..=end {
        if check_palindrome(n).is_ok() {
            return Some(n);
        }
    }
    None
}
fn check_palindrome(num: i32) -> Result<bool, bool> {
    if reverse_int(num) == num {
        return Ok(true);
    }
    Err(false)
}
fn reverse_int(mut num: i32) -> i32 {
    let radix = 10;
    let mut n = 123;
    let mut reversed = 0;
    while num != 0 {
        reversed = reversed * radix + num % radix;
        num /= radix;
    }
    
    return reversed;
}

Dante Kelly

dantekelly

2 days ago

2.53ms

87.38kb

use std::mem;
pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end {
        mem::swap(&mut start, &mut end)
    }
    for n in start..=end {
        if check_palindrome(n).is_ok() {
            return Some(n);
        }
    }
    None
}
fn check_palindrome(num: i32) -> Result<bool, bool> {
    let reverse: String = num.to_string().chars().rev().collect();
    if reverse == num.to_string() {
        return Ok(true);
    }
    Err(false)
}

John Truong

jtruong04

2 days ago

2.59ms

87.46kb

fn is_palindrome(number: i32) -> bool {
    let reverse:i32 = number.to_string().chars().rev().collect::<String>().parse().unwrap();
    number == reverse
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    println!("start {}, end {}", start, end);
    if start < end {
        for i in start..end+1 {
            if is_palindrome(i) {
                return Some(i);
            }
        }
    } else {
        for i in end..start+1 {
            if is_palindrome(i) {
                return Some(i);
            }
        }    }
    None
}

Adi

Aditeya

2 days ago

2.44ms

87.37kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    // TODO: Implement the function here
    if start > end {
        std::mem::swap(&mut start, &mut end);
    }
    for i in start..=end {
        let is = i.to_string();
        if is == is.chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

今何求

jhq223

3 days ago

2.42ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    use std::mem;
    let mut start = start;
    let mut end = end;
    if start > end {
        mem::swap(&mut start, &mut end);
    }
    for i in start..=end {
        let ichars = i.to_string();
        if ichars.chars().eq(ichars.chars().rev()) {
            return Some(i);
        }
    }
    None
}

今何求

jhq223

3 days ago

2.79ms

87.39kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    use std::mem;
    let mut start = start;
    let mut end = end;
    if start > end {
        mem::swap(&mut start, &mut end);
    }
    for i in start..=end {
        let ichars = i.to_string();
        if ichars.chars().collect::<String>() == ichars.chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

Will Barnett

xbarnett

3 days ago

2.40ms

87.38kb

use std::cmp::{min, max};
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    for i in min(start, end)..=max(start, end) {
        if i.to_string() == i.to_string().chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None
}

Joel Vicente Filho

kyhou

3 days ago

2.41ms

87.39kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    if start < 10 && end < 10 {
        if start != end {
            return None;
        } else {
            return Some(start);
        }
    }
    let mut start = start;
    let mut end = end;
    if start > end {
        std::mem::swap(&mut end, &mut start);
    }
    (start..end).find(|x| x.to_string() == x.to_string().chars().rev().collect::<String>())
}

Stefano Cianciulli

CianciuStyles

3 days ago

2.45ms

87.37kb

use std::cmp::{max, min};
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (lo, hi) = (min(start, end), max(start, end));
    for i in lo..=hi {
        let s1: String = i.to_string();
        let s2: String = s1.chars().rev().collect();
        if s1 == s2 { return Some(i); }
    }
    None
}

masteryachty

3 days ago

2.53ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    if start > end {
        return find_first_palindrome(end, start);
    }
    for n in start..=end {
        let n_str = n.to_string();
        let is_palindrome = n_str
            .chars()
            .zip(n_str.chars().rev())
            .all(|(a, b)| a == b);
        if is_palindrome {
            return Some(n);
        }
    }
    None
}

TomBaston

4 days ago

2.43ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    if start > end {
        return find_first_palindrome(end, start);
    }
    for n in start..=end {
        let n_str = n.to_string();
        let is_palindrome = n_str
            .chars()
            .zip(n_str.chars().rev())
            .all(|(a, b)| a == b);
        if is_palindrome {
            return Some(n);
        }
    }
    None
}

Elhanan Buchsbaum

elhananby

4 days ago

2.38ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let mut range = start.min(end)..=start.max(end);
    range.find(|&num| {
        let num_string = num.to_string();
        num_string.chars().eq(num_string.chars().rev())
    })
}

Elhanan Buchsbaum

elhananby

4 days ago

2.28ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // No need for .into_iter() as Range implements IntoIterator
    let mut range = start.min(end)..=start.max(end);
    
    // Use iter.find() instead of for loop + return
    range.find(|&num| {
        let num_string = num.to_string();
        num_string.chars().eq(num_string.chars().rev())
    })
}

Elhanan Buchsbaum

elhananby

4 days ago

2.35ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let range = if start <= end {
            start..=end
        } else {
            end..=start
        }.into_iter();
        
    for num in range {
        let num_string = num.to_string();
        let reversed = num_string.chars().rev().collect::<String>();
        if num_string == reversed {
            return Some(num);
        }
    }
    None
}

Samuel

Sommos

5 days ago

2.39ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (start, end) = if start <= end { (start, end) } else { (end, start) };
    // Iterate through the range of numbers from start to end
    for n in start..=end {
        // Convert the number to a string
        let range_string = n.to_string();
        // Check if the number is a palindrome
        if range_string == range_string.chars().rev().collect::<String>() {
            return Some(n); // Return the first palindrome found
        }
    }
    None 
}

Burnus

5 days ago

2.33ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    (start.min(end)..=start.max(end))
        .find(|n| n.to_string() == n.to_string().chars().rev().collect::<String>())
}

swandyr

5 days ago

2.54ms

81.58kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    if start < end { start..=end } else { end..=start }
        .skip_while(|&n| n != rev_number(n)).next()
}
fn rev_number(mut num: i32) -> i32 {
    let mut rev = 0;
    let max = (0u32..).take_while(|&e| num / 10i32.pow(e) != 0).last().unwrap();
    for e in (0..=max).rev() {
        let a = num / 10i32.pow(e);
        rev += a * 10i32.pow(max - e);
        num -= a * 10i32.pow(e);
    }
    rev
}

Quentin Cabanes

qcabanes-hobby

6 days ago

2.30ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start < end { (start, end) } else { (end, start )};
    (start..=end).find(|n| n.to_string() == n.to_string().chars().rev().collect::<String>())
}

Zhai Can

bczhc

6 days ago

2.28ms

87.37kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end {
        std::mem::swap(&mut start, &mut end);
    }
    for i in start..=end {
        if is_palindrome(i.to_string().as_bytes()) {
            return Some(i);
        }
    }
    None
}
fn is_palindrome<T: Eq>(items: &[T]) -> bool {
    let mid = items.len() / 2;
    let (a, b) = items.split_at(mid);
    if items.len() % 2 == 0 {
        a.iter().zip(b.iter().rev()).all(|x| x.0 == x.1)
    } else {
        a.iter().zip(b.iter().skip(1).rev()).all(|x| x.0 == x.1)
    }
}

Nicolás Caracci

hilias

6 days ago

2.34ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (start, end) = if start < end { (start, end) } else { (end, start )};
    for num in start..=end {
        let original = num.to_string();
        let reverse = original.chars().rev().collect::<String>();
        if original == reverse {
            return Some(num);
        }
    }
    None
}

Vineel Kovvuri

vineelkovvuri

6 days ago

2.64ms

81.58kb

pub fn is_palindrome(n: i32) -> bool {
    let mut rev = 0;
    let mut num = n;
    while num != 0 {
        rev = rev * 10 + num % 10;
        num /= 10;
    }
    rev == n
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (from, to) = if start < end {
        (start, end)
    } else {
        (end, start)
    };
    for num in from..=to {
        if is_palindrome(num) {
            return Some(num);
        }
    }
    None
}

TaiPoole

6 days ago

2.36ms

87.41kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let range;
    if start >= end {
        range = end..=start;
    } else {
        range = start..=end;
    };
    for num in range {
        if num.to_string().chars().collect::<Vec<char>>() == num.to_string().chars().rev().collect::<Vec<char>>(){
            return Some(num)
        }
    }
    None
}

Saravut Nakglom

SRVng

6 days ago

2.49ms

87.37kb

pub fn find_first_palindrome(_start: i32, _end: i32) -> Option<i32> {
    let mut start = _start;
    let mut end = _end;
    if start.gt(&_end) {
        start = _end;
        end = _start;
    }
    for n in start..(end + 1) {
        let text = n.to_string();
        let rev: String = text.chars().rev().collect();
        if text.eq(&rev) {
            return Some(n);
        }
    }
    None
}

Brady Edwards

kavu16

6 days ago

2.42ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    fn is_palindrome(num: i32) -> bool {
        let num_string = num.to_string();
        let reversed: String = num_string.chars().rev().collect();
        num_string == reversed
    }
    if start < end {
        for n in start..=end {
            if is_palindrome(n) {
                return Some(n)
            }
        }
    } else {
        for n in end..=start {
            if is_palindrome(n) {
                return Some(n)
            }
        }
    }
    
    None
}

DMB TECH

dmbtechdev

6 days ago

2.40ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (min,max);
    if start > end {
        min = end;
        max = start;
    } else {
        min = start;
        max = end;
    }
    for num in min..=max {
        let num_str = num.to_string();
        let reversed_str = num_str.chars().rev().collect::<String>();
        if num_str == reversed_str {
            return Some(num);
        }
    }
    None
}

Romain Grimau

Herrgrim0

12 days ago

2.54ms

87.39kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    // TODO: Implement the function here
    if start > end {
        std::mem::swap(&mut start, &mut end);
    }
    for i in start..=end {
        let x = i.to_string();
        let y = x.chars().rev().collect::<String>();
        if x == y {
            return Some(i);
        }
    }
    None
}

Jenny

jenny07007

12 days ago

2.61ms

87.39kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for n in start..=end {
        let n_str = n.to_string();
        let reversed: String = n_str.chars().rev().collect();
        if n_str == reversed {
            return Some(n);
        }
    }
    None
}

Beens

Abinesh-Mathivanan

15 days ago

2.46ms

87.40kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    for i in start..=end {
        if i.to_string() == i.to_string().chars().rev().collect::<String>() {
            return Some(i);
        }
    }
    None 
}

Jun Huang

leemars

15 days ago

2.61ms

87.40kb

use std::cmp::min;
use std::cmp::max;
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    for i in min(start, end)..=max(start, end) {
        let origin = i.to_string();
        let reversed = i.to_string().chars().rev().collect::<String>();
        if origin == reversed {
            return Some(i);
        }
    }
    return None;
}

Jun Huang

leemars

15 days ago

2.39ms

87.40kb

use std::cmp::min;
use std::cmp::max;
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    for i in min(start, end)..=max(start, end) {
        let origin = i.to_string();
        let reversed = i.to_string().chars().rev().collect::<String>();
        if origin == reversed {
            return Some(i);
        }
    }
    return None;
}

Andrey

A-ndrey

15 days ago

2.42ms

81.60kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = if start > end {
        (end, start)
    } else {
        (start, end)
    };
    for p in start..=end {
        if p == rev(p) {
            return Some(p);
        }
    }
    None
}
fn rev(p: i32) -> i32 {
    let mut p = p;
    let mut r = 0;
    while p > 0 {
        r = r * 10 + p % 10;
        p /= 10;
    }
    r
}

Mr.Sirichai

suraboy

16 days ago

2.50ms

87.40kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (start, end) = if start > end { (end, start) } else { (start, end) };
    (start..=end).find(|&x| x.to_string() == x.to_string().chars().rev().collect::<String>())
}