From b9ae16be7ace632a78e9249eb1e7848b0f9c9d0e Mon Sep 17 00:00:00 2001 From: William Ball Date: Fri, 17 Jul 2020 22:03:58 -0700 Subject: [PATCH] minor tweaks --- cpp/append_digit_primes.cpp | 30 ++++---- python/append_digit_primes.py | 78 ++++++++++++++++++++ rust/append_digit_primes/src/main.rs | 16 ++-- scheme/{append_digit_primes.scm => tree.scm} | 12 +-- scheme/util.scm | 23 ++++++ 5 files changed, 129 insertions(+), 30 deletions(-) create mode 100644 python/append_digit_primes.py rename scheme/{append_digit_primes.scm => tree.scm} (80%) diff --git a/cpp/append_digit_primes.cpp b/cpp/append_digit_primes.cpp index ad11b38..b47e037 100644 --- a/cpp/append_digit_primes.cpp +++ b/cpp/append_digit_primes.cpp @@ -26,10 +26,10 @@ public: for (auto val : xs) { children.push_back(Tree(val, {})); } - return; - } - for (auto &child : children) { - child.step(); + } else { + for (auto &child : children) { + child.step(); + } } } @@ -53,7 +53,7 @@ public: }; auto next(ull x) -> std::vector { - std::vector new_xs(); + std::vector new_xs; ull temp = x * 10; for (int i = 0; i < 10; i++) { auto temp2 = temp + i; @@ -66,6 +66,10 @@ auto next(ull x) -> std::vector { auto is_prime(ull n) -> bool { static std::unordered_map primes; + if (n < 2) { + primes[n] = false; + return false; + } if (primes.count(n) > 0) { return primes[n]; } @@ -89,14 +93,14 @@ auto print_vec(std::vector vec) -> void { } auto main() -> int { - std::vector primes; - for (int i = 2; i < 10000000; i++) { - if (is_prime(i)) { - primes.push_back(i); - } - } - Tree tree(0, primes); - for (int i = 0; i < 200; i++) { + /* std::vector primes; */ + /* for (int i = 2; i < 10000000; i++) { */ + /* if (is_prime(i)) { */ + /* primes.push_back(i); */ + /* } */ + /* } */ + Tree tree(0, {}); + for (int i = 0; i < 9; i++) { tree.step(); print_vec(tree.longest_path()); } diff --git a/python/append_digit_primes.py b/python/append_digit_primes.py new file mode 100644 index 0000000..5add74d --- /dev/null +++ b/python/append_digit_primes.py @@ -0,0 +1,78 @@ +import math + +class Tree: + def __init__(self, value, children): + self.value = value + self.children = [] + for child in children: + self.children.append(Tree(child, [])) + + def step(self): + if len(self.children) == 0: + for val in step(self.value): + self.children.append(Tree(val, [])) + return + for child in self.children: + child.step() + + def __str__(self): + retval = '[' + str(self.value) + ': ' + for child in self.children: + retval += str(child) + retval += ']' + return retval + + def __repr__(self): + return str(self) + + def longest_path(self): + if len(self.children) == 0: + return [self.value] + max_path = [] + max_length = 0 + for child in self.children: + temp = child.longest_path() + if len(temp) > max_length: + max_path = temp + max_length = len(temp) + return [self.value] + max_path + +def is_square(x): + return int(math.sqrt(x)) == math.sqrt(x) + +primes = {} + +def is_prime(x): + try: + return primes[x] + except KeyError: + if x < 2: + primes[x] = False + return False + i = 2 + while i * i <= x: + if x % i == 0: + primes[x] = False + return False + i += 1 + primes[x] = True + return True + +def step(x): + new_xs = [] + for i in range(10): + if is_prime(10 * x + i): + new_xs.append(10 * x + i) + return new_xs + + +def main(): + tree = Tree(0, []) + for i in range(9): + print(tree.longest_path()) + tree.step() + print(tree.longest_path()) + + +if __name__ == '__main__': + main() diff --git a/rust/append_digit_primes/src/main.rs b/rust/append_digit_primes/src/main.rs index d645554..bcdf580 100644 --- a/rust/append_digit_primes/src/main.rs +++ b/rust/append_digit_primes/src/main.rs @@ -71,15 +71,15 @@ fn step(x: u64) -> Vec { fn main() { /* find all non-truncatable primes in (100,000,000; 1,000,000,000) */ - let primes: Vec = primal::Primes::all() - .skip_while(|x| *x < 100_000_000) - .take_while(|x| *x < 1_000_000_000) - .map(|x| x as u64) - .filter(|x| !(primal::is_prime(*x / 10))) - .collect(); + // let primes: Vec = primal::Primes::all() + // .skip_while(|x| *x < 100_000_000) + // .take_while(|x| *x < 1_000_000_000) + // .map(|x| x as u64) + // .filter(|x| !(primal::is_prime(*x / 10))) + // .collect(); - let mut tree = Tree::new(0, primes); - for _ in 0..20 { + let mut tree = Tree::new(0, Vec::new()); + for _ in 0..9 { tree.step(); println!("{:?}", tree.longest_path()); } diff --git a/scheme/append_digit_primes.scm b/scheme/tree.scm similarity index 80% rename from scheme/append_digit_primes.scm rename to scheme/tree.scm index 9180681..aa4ea44 100644 --- a/scheme/append_digit_primes.scm +++ b/scheme/tree.scm @@ -1,13 +1,5 @@ (load "util.scm") -(define (prime? n) - (if (< n 2) #f - (let loop ((i 2)) - (cond - ((> (* i i) n) #t) - ((zero? (remainder n i)) #f) - (else (loop (+ i 1))))))) - (define (val tree) (car tree)) (define (children tree) (cdr tree)) (define (new-tree val children) @@ -31,7 +23,9 @@ '() (map longest-path (children tree)))))))) +; --- change this function to control behavior of tree --- (define (next val) (filter prime? (map (lambda (d) (+ (* val 10) d)) (range 10)))) -; (define big-tree (tree 0 (filter prime? (range 1000000)))) +; (define (next val) +; (filter prime? (map (lambda (d) (+ (* d (expt 10 (digits val))) val)) (cdr (range 10))))) diff --git a/scheme/util.scm b/scheme/util.scm index b14d8be..c80974b 100644 --- a/scheme/util.scm +++ b/scheme/util.scm @@ -1,3 +1,23 @@ +(define (square? n) + (let ((s (sqrt n))) + (= s (floor s)))) + +(define (prime? n) + (if (< n 2) #f + (let loop ((i 2)) + (cond + ((> (* i i) n) #t) + ((zero? (remainder n i)) #f) + (else (loop (+ i 1))))))) + +(define (square-free? n) + (if (< n 1) #f + (let loop ((i 2)) + (cond + ((> (* i i) n) #t) + ((zero? (remainder n (* i i))) #f) + (else (loop (+ i 1))))))) + (define (fold f init seq) (if (null? seq) init @@ -18,3 +38,6 @@ (if (= i n) func (loop (+ i 1) (compose func f))))) + +(define (digits n) + (length (string->list (number->string n))))