The following iterative sequence is defined for the set of positive
integers:

n -> n/2 (n is even)
n -> 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following
sequence:

13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1

It can be seen that this sequence (starting at 13 and
finishing at 1) contains 10 terms. Although it has not been
proved yet (Collatz Problem), it is thought that all starting
numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one
million.

Gauche Scheme

(use gauche.collection) ;; find-max

(define (cltz n) (if (odd? n) (+ 1 (* n 3)) (/ n 2)))

(define (d c n)
(if (= n 1) c (d (+ 1 c) (cltz n))))

(find-max (lrange 1 1000000) :key (pa$ d 1))

===>
837799

On 5/28/2024 4:39 AM, B. Pym wrote:
> The following iterative sequence is defined for the set of positive
> integers:
>
> n -> n/2 (n is even)
> n -> 3n + 1 (n is odd)
>
> Using the rule above and starting with 13, we generate the following
> sequence:
>
> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
>
> It can be seen that this sequence (starting at 13 and
> finishing at 1) contains 10 terms. Although it has not been
> proved yet (Collatz Problem), it is thought that all starting
> numbers finish at 1.
>
> Which starting number, under one million, produces the longest chain?
>
> NOTE: Once the chain starts the terms are allowed to go above one
> million.
>
>
> Gauche Scheme
>
> (use gauche.collection) ;; find-max
>
>
> (define (cltz n) (if (odd? n) (+ 1 (* n 3)) (/ n 2)))
>
> (define (d c n)
> (if (= n 1) c (d (+ 1 c) (cltz n))))
>
> (find-max (lrange 1 1000000) :key (pa$ d 1)) ===> 837799

is this fast?

what does the SUBJ line mean? ( Euler 14.)

HenHanna <HenHanna@devnull.tb> writes:
> is this fast?

No it is slow, it needs memoization

> what does the SUBJ line mean? ( Euler 14.)

It is problem 14 of projecteuler.net .

Paul Rubin <no.email@nospam.invalid> writes:
> It is problem 14 of projecteuler.net .

Here is my solution, maybe not idiomatic CL since I don't write much of
that these days. It takes about 0.17 sec of user time on my laptop
using sbcl --script, or 1.1 sec with compiled clisp. It doesn't work
with interpreted clisp because the clisp interpreter has no TRO and so
the tail recursion overflows the stack. I could rewrite it iteratively
but nah. A similar C++ version with gcc -O3 takes about 0.03 sec. I
haven't experimented with changing the size of the memo table or
anything like that.
================================================================

(defun collatz (n)
(cond ((oddp n) (1+ (* 3 n)))
(t (floor n 2))))

(defvar memo (make-array 1000000 :initial-element nil))

(defun clen (n)
(cond ((= n 1) 1)
((<= n 0) 'crash)
((and (< n (length memo)) (aref memo n)) (aref memo n))
(t (let ((a (1+ (clen (collatz n)))))
(if (< n (length memo))
(setf (aref memo n) a))
a))))

(defun run (&optional (n 1) (mi 0) (ma 0))
(if (> n 1000000)
(list mi ma)
(let ((a (clen n))
(nn (1+ n)))
(if (> a ma)
(run nn n a)
(run nn mi ma)))))
(print (run))
(terpri)

On Tue, 23 Jul 2024 20:40:10 +0000, Paul Rubin wrote:

> HenHanna <HenHanna@devnull.tb> writes:
>> is this fast?
>
> No it is slow, it needs memoization
>
>> what does the SUBJ line mean? ( Euler 14.)
>
> It is problem 14 of projecteuler.net .

THanks... it seems like a set of simple programming exercises

On 7/23/2024 1:40 PM, Paul Rubin wrote:
> HenHanna <HenHanna@devnull.tb> writes:
>> is this fast?
>
> No it is slow, it needs memoization
>
>> what does the SUBJ line mean? ( Euler 14.)
>
> It is problem 14 of projecteuler.net .

thanks...

i just discovered this:

In 2003 We Discovered a New Way to Generate Primes
YouTube · Eric Rowland
396.1K+ views · 1 year ago

22:17 ... number theory (2011) (46 pages).
https://arxiv.org/abs/1101.4274 Eric Rowland, A natural prime-generating
recurrence, Journal of Integer ...

B. Pym wrote:

> The following iterative sequence is defined for the set of positive
> integers:
>
> n -> n/2 (n is even)
> n -> 3n + 1 (n is odd)
>
> Using the rule above and starting with 13, we generate the following
> sequence:
>
> 13 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1
>
> It can be seen that this sequence (starting at 13 and
> finishing at 1) contains 10 terms. Although it has not been
> proved yet (Collatz Problem), it is thought that all starting
> numbers finish at 1.
>
> Which starting number, under one million, produces the longest chain?
>
> NOTE: Once the chain starts the terms are allowed to go above one
> million.
>
>
> Gauche Scheme
>
> (use gauche.collection) ;; find-max
>
>
> (define (cltz n) (if (odd? n) (+ 1 (* n 3)) (/ n 2)))
>
> (define (d c n)
> (if (= n 1) c (d (+ 1 c) (cltz n))))
>
> (find-max (lrange 1 1000000) :key (pa$ d 1))
>
> ===>
> 837799

newLISP

(define (cltz n) (if (odd? n) (+ 1 (* n 3)) (/ n 2)))

(define (d c n) (if (= n 1) c (d (+ 1 c) (cltz n))))

(local (best-n best-cnt cnt)
(for (n 1 999999)
(setq cnt (d 1 n))
(if (> cnt best-cnt) (setq best-n n best-cnt cnt)))
(list best-n best-cnt))

(837799 525)