code_games/project_euler/palindrome/src/main.rs

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