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

Anthony Cabrera-Lara

anthonycabreralara

36 minutes ago

3.22ms

87.98kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end {
        let temp = start;
        start = end;
        end = temp;
    }
    for i in start..=end {
        if is_palindrome(i) {
            return Some(i); // Wrap the result in Some
        }
    }
    None // Return None if no palindrome is found
}
pub fn is_palindrome(num: i32) -> bool {
    let string_num = num.to_string(); // Declare variable with let
    let reversed_string_num: String = string_num.chars().rev().collect(); // Collect into a String
    string_num == reversed_string_num // Compare strings
}

Markus Bergkvist

mbergkvist

10 hours ago

3.09ms

81.58kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    (start.min(end)..=start.max(end))
        .filter_map(|number| (number == reverse_num(number)).then_some(number))
        .next()
}
fn reverse_num(mut number: i32) -> i32 {
    let mut reversed = 0;
    while number > 0 {
        reversed *= 10;
        reversed += number % 10;
        number /= 10;
    }
    reversed
}

Markus Bergkvist

mbergkvist

10 hours ago

4.43ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    (start.min(end)..=start.max(end))
        .filter_map(|number| {
            let s = number.to_string();
            let s_rev: String = s.chars().rev().collect();
            if s == s_rev {
                Some(number)
            } else {
                None
            }
        })
        .next()
}

Jim Lawton

jimlawton

18 hours ago

2.99ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let range = if start > end {
        end..start+1
    } else {
        start..end+1
    };
    for i in range {
        let num_str: String = format!("{i}");
        let rev_str: String = num_str.chars().rev().collect();
        if num_str == rev_str {
            return Some(i);
        }
    }
    None
}

mehdihmr

19 hours ago

3.22ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let mut s = start;
    let mut e = end;
    if start > end{
        s = end;
        e = start;
    }
    for i in s..=e{
        let s_vec = i.to_string().chars().collect::<Vec<char>>();
        let mut is_pal = true;
        for j in 0..s_vec.len() / 2 {
            if s_vec[j] != s_vec[s_vec.len() - 1 - j] {
                is_pal = false;
            }
        }
        if is_pal {
            return Some(i);
        }
    }
    None
}

Gautham.K

gauthamk28

a day ago

3.16ms

81.58kb

use std::cmp::{min, max};
pub fn find_first_palindrome(start: u32, end: u32) -> Option<u32> {
    // TODO: Implement the function here
    let (start, end) = (min(start, end), max(start, end));
    'numbers_iter: for n in start..=end {
        let digits = ((n as f64).log10() + 1.0).floor() as u32;
        for i in 1..(digits / 2) + 1 {
            if digit(n, i) != digit(n, digits + 1 - i) {
                continue 'numbers_iter;
            }
        }
        return Some(n);
    }
    None
}
fn digit(number: u32, digit: u32) -> u8 {
    ((number / 10_u32.pow(digit - 1)) % 10) as u8
}

Ando “Thor” Nando

DivineGod

2 days ago

3.00ms

81.58kb

use std::cmp::{min, max};
pub fn find_first_palindrome(start: u32, end: u32) -> Option<u32> {
    // TODO: Implement the function here
    let (start, end) = (min(start, end), max(start, end));
    'numbers_iter: for n in start..=end {
        let digits = ((n as f64).log10() + 1.0).floor() as u32;
        for i in 1..(digits / 2) + 1 {
            if digit(n, i) != digit(n, digits + 1 - i) {
                continue 'numbers_iter;
            }
        }
        return Some(n);
    }
    None
}
fn digit(number: u32, digit: u32) -> u8 {
    ((number / 10_u32.pow(digit - 1)) % 10) as u8
}

Stefan Roas

sroas

2 days ago

3.15ms

87.40kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (s, e) = if start < end {
        (start, end)
    } else {
        (end, start)
    };
    (s..=e).find(|n| {
        let nstr = n.to_string();
        nstr.chars().collect::<Vec<_>>() == nstr.chars().rev().collect::<Vec<_>>()
    })
}

Diego Maia

diegocmsantos

3 days ago

3.55ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (s, e);
    if start > end {
        (s, e) = (end, start);
    } else {
        (s, e) = (start, end);
    }
    (s..=e).find(|&i| is_palindrome(i))
}
fn is_palindrome(n: i32) -> bool {
    let s = n.to_string();
    s.chars().eq(s.chars().rev())
}

qiyuan711

3 days ago

4.22ms

87.37kb

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

Masayuki Sunahara

tamanishi

4 days ago

3.35ms

87.37kb

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

Elizabeth Doughty

Thymelizabeth

5 days ago

8.36ms

87.37kb

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

0xsmarter

6 days ago

3.01ms

81.58kb

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

Babuuu

aynugek

6 days ago

3.13ms

81.58kb

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

Andrea Ciprietti

cip999

7 days ago

4.36ms

87.38kb

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

madeinheaven91

7 days ago

3.31ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (s, e): (i32, i32) =
    if start > end {
        (end, start)
    }else{
        (start, end)
    };
    'outer: for i in s..=e{
        let string = i.to_string();
        let max_index = string.len() - 1;
        let bytes = string.as_bytes();
        let mut j = 0;
        for b in bytes{
            if *b != bytes[max_index - j]{
                continue 'outer;
            }
            j += 1;
        }
        return Some(i)
    }
    None
}

madeinheaven91

7 days ago

3.06ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (s, e): (i32, i32) =
    if start > end {
        (end, start)
    }else{
        (start, end)
    };
    'outer: for i in s..=e{
        let num = if i < 0 { -i } else { i };
        let string = num.to_string();
        let max_index = string.len() - 1;
        let bytes = string.as_bytes();
        let mut j = 0;
        for b in bytes{
            if *b != bytes[max_index - j]{
                continue 'outer;
            }
            j += 1;
        }
        return Some(i)
    }
    None
}

harrien22

7 days ago

3.89ms

87.37kb

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

tsuchiya-d

tsucchinoko

7 days ago

3.29ms

87.38kb

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)
    };
    for x in start..=end {
        if x.to_string() == x.to_string().chars().rev().collect::<String>() {
            return Some(x);
        }
    }
    None
}

Ankeet Parikh

ankeetparikh

7 days ago

3.54ms

81.58kb

use std::cmp;
fn is_palindrome(num: i32) -> bool {
    let mut p = num;
    let mut rev = 0;
    while p > 0 {
        rev = rev * 10 + (p % 10);
        p /= 10;
    }
    return num == rev
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let st = cmp::min(start, end);
    let en = cmp::max(start, end);
    for num in st..=en {
        if is_palindrome(num) {
            return Some(num)
        }
    }
    None
}

Rolando1994

8 days ago

4.08ms

87.38kb

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)
    };
    for x in start..=end {
        if x.to_string() == x.to_string().chars().rev().collect::<String>() {
            return Some(x);
        }
    }
    None
}

Rocky.C

cloki0610

8 days ago

4.01ms

87.38kb

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)
    };
    for i in start..=end {
        if i.to_string().chars().rev().collect::<String>() == i.to_string() {
            return Some(i)
        }
    }
    None
}

Bubbet

8 days ago

3.66ms

87.37kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    // TODO: Implement the function here
    if start > end {
        let old_end = end;
        end = start;
        start = old_end;
    }
    for i in start..=end {
        let s: String = format!("{}", i);
        let chars = s.chars();
        let len = chars.size_hint().0;
        // i have no idea how this isnt shitting the bed in numbers that are odd in length
        let first = chars.take(len/2 + 1);
        let second = s.chars().rev();
        if first.zip(second).all(|(first, second)| first == second) {
            return Some(i)
        }
    }
    None
}

Sabin Howard

whitwulf

8 days ago

3.42ms

87.38kb

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)
    };
    for num in start..=end {
        if num.to_string() == num.to_string().chars().rev().collect::<String>() {
            return Some(num);
        }
    }
    None
}

maxvi

8 days ago

4.09ms

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 number in start..=end {
        let s = number.to_string();
        if s == s.chars().rev().collect::<String>() {
            return Some(number);
        }
    }
    None
}

senft

8 days ago

3.07ms

87.37kb

use std::cmp::{max, min};
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    for i in min(start, end)..=max(start, end) {
        let s = i.to_string();
        if is_palindrome(&s) {
            return Some(i);
        }
    }
    None
}
fn is_palindrome(s: &str) -> bool {
    let len = s.len();
    if len == 1 {
        return true;
    }
    for i in 0..len / 2 {
        let idx1 = i;
        let idx2 = len - i - 1;
        if s.chars().nth(idx1) != s.chars().nth(idx2) {
            return false;
        }
    }
    true
}

senft

8 days ago

6.40ms

88.21kb

use std::cmp::{max, min};
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    for i in min(start, end)..=max(start, end) {
        let s = i.to_string();
        println!("{}", s);
        if is_palindrome(&s) {
            return Some(i);
        }
    }
    None
}
fn is_palindrome(s: &str) -> bool {
    let len = s.len();
    if len == 1 {
        return true;
    }
    println!("len {}", len);
    for i in 0..len / 2 {
        let idx1 = i;
        let idx2 = len - i - 1;
        println!("idx1 {}", idx1);
        println!("idx2 {}", idx2);
        println!("c1 {}", s.chars().nth(idx1).unwrap());
        println!("c2 {}", s.chars().nth(idx2).unwrap());
        if s.chars().nth(idx1) != s.chars().nth(idx2) {
            return false;
        }
    }
    true
}

Sh!n0bu

shinobu52

10 days ago

3.25ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = (std::cmp::min(start, end), std::cmp::max(start, end));
    for num in start..=end {
        let num_str = num.to_string();
        let num_chars: Vec<char> = num_str.chars().collect();
        let mut flag = true;
        for i in 0..(num_str.len() / 2) {
            if num_chars[i] != num_chars[num_chars.len() - 1 - i] {
                flag = false;
                break;
            }
        }
        if flag {
            return Some(num);
        }
    }
    None
}

Anak Mirasing

igroomgrim

11 days ago

3.64ms

87.37kb

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

majesticalcreature

11 days ago

3.92ms

81.58kb

use std::cmp::{min, max};
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let (start, end) = (min(start, end), max(start, end));
    'numbers_iter: for n in start..=end {
        let digits = ((n as f64).log10() + 1.0).floor() as i32;
        for i in 1..(digits / 2) + 1 {
            if digit(n, i) != digit(n, digits + 1 - i) {
                continue 'numbers_iter;
            }
        }
        return Some(n);
    }
    None
}
fn digit(number: i32, digit: i32) -> u8 {
    ((number / pow10(digit - 1)) % 10) as u8
}
fn pow10(x: i32) -> i32 {
    let mut result = 1;
    for _ in 0..x {
        result *= 10
    }
    result
}

Andreas

StimhackSoftware

12 days ago

3.35ms

87.38kb

fn check_palindrome(inp : i32) -> bool {
    let check1 = inp.to_string();
    let check2 : String = inp.to_string().chars().into_iter().rev().collect();
    check1 == check2
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    if start > end {
        return find_first_palindrome(end, start)
    }
    for e in start..=end {
        if check_palindrome(e) {
            return Some(e)
        }
    }
    None
}

Artem Medeu

armed

12 days ago

3.48ms

81.58kb

use std::cmp::{min, max};
pub fn is_palindrome_number(mut number: i32) -> bool {
    if number < 0 {
        return false;
    }
    let original = number;
    let mut reversed = 0;
    while number > 0 {
        let digit = number % 10;
        reversed = reversed * 10 + digit;
        number /= 10;
    }
    original == reversed
}
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let r = min(start, end)..=max(start,end);
    for x in r {
        if is_palindrome_number(x) {
            return Some(x);
        }
    }
    None
}

Suraj Vijayan

its-me-sv

13 days ago

3.72ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    (start.min(end)..=end.max(start)).find(|i| {
        let no = i.to_string();
        let rev_no = no.chars().rev().collect::<String>();
        no == rev_no
    })
}

Suraj Vijayan

its-me-sv

13 days ago

4.46ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    (start.min(end)..=end.max(start)).find(|i| {
        let no = i.to_string();
        let rev_no = no.chars().rev().collect::<String>();
        no == rev_no
    })
}

Suraj Vijayan

its-me-sv

13 days ago

3.25ms

87.37kb

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

Andrey Yusipov

andrey-yu

14 days ago

4.08ms

87.84kb

pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    // TODO: Implement the function here
    println!("s: {} e: {}", start.to_string(), end.to_string());
    if start > end {
        let end_t = start;
        start = end;
        end = end_t;
    }
    for n in start..=end {
        let mut s = Vec::<char>::new();
        let mut nn = n;
        while nn > 0 {
            let d = ('0' as i32 + nn - nn / 10 * 10) as u8;
            s.push(d as char);
            nn = nn/10;
        }
        let len = s.len();
        println!("s: {:?}", &s);
        for index in 0..=len / 2 {
            if index >= len / 2 {
                return Some(n);
            } else if s[index] != s[len - 1 - index] {
                break;
            }
        }
    }
    None
}

Raphael Neider

raneid

14 days ago

4.45ms

87.37kb

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

Elena Sukmanova

sukman

14 days ago

3.34ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let mut palindrome_range = match start <= end {
        true => start..=end,
        false => end..=start
    };
    palindrome_range.find(|o| {
        o.to_string().chars().eq(o.to_string().chars().rev())
    })
}

René Ribaud

uggla

14 days ago

3.48ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    let t = if start > end {
        (end, start)
    }else {
        (start, end)
    };
    (t.0..=t.1).find(|o| {
        o.to_string().chars().eq(o.to_string().chars().rev())
    })
    
}

ludovicknecht

14 days ago

5.28ms

87.38kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let palindrome_range = match start <= end {
        true => start..=end,
        false => end..=start
    };
    
    'outer: for number in palindrome_range {
        if number < 0 {continue;}
        let char_rep: Vec<char> = number.to_string()
            .chars()
            .collect();
        
        for index in 0..char_rep.len()/2 {
            if char_rep[index] != char_rep[char_rep.len()-1-index] {
                continue 'outer;
            }
        }
        return Some(number);
    }    
    None
}

mrsalo

14 days ago

3.47ms

87.37kb

use std::cmp::Ordering;
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = match start.cmp(&end) {
        Ordering::Equal => (start, end),
        Ordering::Less => (start, end),
        Ordering::Greater => (end, start),
    };
    for i in start..=end {
        let s = i.to_string();
        let s_r = s.chars().rev().collect::<String>();
        if s == s_r {
            return Some(i);
        }
    }
    None
}

mrsalo

14 days ago

16.95ms

87.37kb

use std::cmp::Ordering;
pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (start, end) = match start.cmp(&end) {
        Ordering::Equal => (start, end),
        Ordering::Less => (start, end),
        Ordering::Greater => (end, start),
    };
    for i in start..end + 1 {
        let s = i.to_string();
        let s_r = s.chars().rev().collect::<String>();
        if s == s_r {
            return Some(i);
        }
    }
    None
}

Zhongjin Lu

XiaoPengYouCode

15 days ago

3.52ms

87.75kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    fn check_palindrome(number: i32) -> bool {
        let number_string = number.to_string();
        let number_rev = number.to_string().chars().rev().collect::<String>();
        println!("number_rev = {}", number_rev);
        number_string == number_rev
    }
    let range = start.min(end)..=start.max(end);
    range
        .filter(|&num| num >= 0)
        .find(|&num| check_palindrome(num))
}

Zhongjin Lu

XiaoPengYouCode

15 days ago

3.64ms

87.97kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    // TODO: Implement the function here
    fn check_palindrome(number: i32) -> Option<i32> {
        let number_string = number.to_string();
        let number_rev = number.to_string().chars().rev().collect::<String>();
        println!("number_rev = {}", number_rev);
        if number_string == number_rev {
            Some(number)
        } else {
            None
        }
    }
    let range = if start < end {
        start..=end
    } else {
        end..=start
    };
    for number in range {
        println!("number = {}", number);
        match check_palindrome(number) {
            Some(number) => {
                return Some(number)
            },
            None => continue
        }
    }
    None
}

Saulius Kaminskas

saukmn

15 days ago

4.15ms

87.37kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let range = if start < end { start..=end } else { end..=start };
    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
}

Wade Johnson

wadjoh

16 days ago

3.63ms

87.39kb

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

Kalley Powell

kalley

16 days ago

3.78ms

87.38kb

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

mcgrizzz

16 days ago

3.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) };
    for n in start..=end {
        let num_string = n.to_string();
        let rev_string = num_string.chars().rev().collect::<String>();
        if num_string.eq(&rev_string) {
            return Some(n);
        }
    }
    None
}

daves003

16 days ago

3.46ms

87.37kb

fn is_palindrome(n: i32) -> bool {
    let s = n.to_string();
    for (a, b) in s.chars().zip(s.chars().rev()) {
        if a != b { return false; }
    }
    true
}
pub fn find_first_palindrome(mut start: i32, mut end: i32) -> Option<i32> {
    if start > end { std::mem::swap(&mut start, &mut end); }
    for n in start..=end {
        if is_palindrome(n) { return Some(n); }
    }
    None
}

querywatson

16 days ago

3.51ms

81.58kb

pub fn find_first_palindrome(start: i32, end: i32) -> Option<i32> {
    let (a, b) = (start.min(end), start.max(end));
    (a..=b)
        .filter(|&num| num >= 0)
        .find(|&num| is_palindrome(num))
}
fn is_palindrome(mut num: i32) -> bool {
    let original = num;
    let mut reversed = 0;
    while num > 0 {
        reversed = reversed * 10 + (num % 10);
        num /= 10;
    }
    original == reversed
}