158 lines
3.1 KiB
Rust
Executable File
158 lines
3.1 KiB
Rust
Executable File
use std::iter::Peekable;
|
|
|
|
const ERR_TXT: &str = "unexpected item in bagging area";
|
|
|
|
fn main() {
|
|
// let mut something: Option<(usize,usize)> = None;
|
|
// for x in (100..999).rev() {
|
|
// for y in (100..999).rev() {
|
|
// if reverse( x * y ) == x * y {
|
|
// something = Some(( x, y ));
|
|
// break
|
|
// }
|
|
// else {
|
|
// something = None
|
|
// }
|
|
// }
|
|
// if !something.is_none() {
|
|
// break
|
|
// }
|
|
// }
|
|
// println!("{} * {} = {}", something.expect("").0, something.expect("").1, something.expect("").0 * something.expect("").1)
|
|
|
|
// let palindrome = (0..999*999).rev()
|
|
// .filter( |x| *x == reverse(*x))
|
|
// .find( |x| palin_valid(*x) )
|
|
// .expect(ERR_TXT);
|
|
// println!("{}", palindrome);
|
|
|
|
let palindrome = (0..999*999).rev()
|
|
.filter( |x| *x == reverse(*x))
|
|
.filter( |x| palin_valid(*x, false))
|
|
.take(100);
|
|
for x in palindrome {
|
|
println!("{}, {}", x, palin_valid(x, true));
|
|
}
|
|
|
|
// println!("{}", palin_valid(906609, true))
|
|
}
|
|
|
|
fn palin_valid(palin: usize, debug: bool) -> bool {
|
|
let mut x: usize = 1;
|
|
let mut y: usize = 1;
|
|
let mut x_check = true;
|
|
let factors = PrimeFactItr::factors(palin).collect::<Vec<_>>().into_iter().rev();
|
|
for factor in factors {
|
|
if debug { println!("x : {}, y : {}, factor : {}", x, y, factor); }
|
|
if x_check {
|
|
if x * factor <= 999 {
|
|
x *= factor;
|
|
}
|
|
else if y * factor <= 999 {
|
|
y *= factor;
|
|
}
|
|
else {
|
|
if debug { println!("x* : {}, y* : {}, factor : {}", x*factor, y*factor, factor); }
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if y * factor <= 999 {
|
|
y *= factor;
|
|
}
|
|
else if x * factor <= 999 {
|
|
x *= factor;
|
|
}
|
|
else {
|
|
if debug { println!("x* : {}, y* : {}, factor : {}", x * factor, y * factor, factor); }
|
|
return false;
|
|
}
|
|
}
|
|
x_check = !x_check;
|
|
}
|
|
if debug { println!("x : {}, y : {}", x, y); }
|
|
return true;
|
|
}
|
|
|
|
fn reverse(mut n:usize) -> usize {
|
|
let radix = 10;
|
|
let mut reversed = 0;
|
|
while n != 0 {
|
|
reversed = reversed * radix + n % radix;
|
|
n /= radix;
|
|
}
|
|
reversed
|
|
}
|
|
|
|
//prime iterator
|
|
|
|
struct PrimeItr {
|
|
record: Vec<usize>,
|
|
index: usize
|
|
}
|
|
|
|
impl Iterator for PrimeItr {
|
|
type Item = usize;
|
|
fn next ( &mut self ) -> Option<usize> {
|
|
let is_prime = !self.record.iter()
|
|
.take_while( |x| **x * **x < self.index )
|
|
.any( |x| self.index % *x == 0 );
|
|
let result = self.index;
|
|
self.index += if self.index == 2 { 1 } else { 2 };
|
|
if is_prime {
|
|
self.record.push(result);
|
|
Some(result)
|
|
}
|
|
else {
|
|
self.next()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for PrimeItr {
|
|
fn default() -> Self {
|
|
PrimeItr {
|
|
record: vec![],
|
|
index: 2
|
|
}
|
|
}
|
|
}
|
|
|
|
// prime factorization iterator
|
|
|
|
struct PrimeFactItr {
|
|
record: Vec<usize>,
|
|
chuck: usize,
|
|
prime: Peekable<PrimeItr>
|
|
}
|
|
|
|
impl Iterator for PrimeFactItr {
|
|
type Item = usize;
|
|
fn next ( &mut self ) -> Option<usize> {
|
|
let x = *self.prime.peek().expect(ERR_TXT);
|
|
let is_factor = self.chuck % x == 0;
|
|
if is_factor {
|
|
self.record.push(x);
|
|
self.chuck /= x;
|
|
Some(x)
|
|
}
|
|
else if x > self.chuck {
|
|
None
|
|
}
|
|
else {
|
|
self.prime.next();
|
|
self.next()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PrimeFactItr {
|
|
fn factors(x: usize) -> Self {
|
|
PrimeFactItr {
|
|
record: vec![],
|
|
chuck: x,
|
|
prime: PrimeItr::default().peekable()
|
|
}
|
|
}
|
|
}
|