# Re: [Jprogramming] Goodstein Sequences and Hereditary base-n notation

```Very nice solution. This style of solution what I wanted to write.

Just to compare:
timespacex 'genSeq 2 4 20'
0.000741 13184
timespacex ' gs^:(0~:{:)^:20 ] 4x'
0.000892 49024```
```
As an FYI, there is also a Haskell solutiuon here:
https://oeis.org/A211378/a211378.hs.txt
In that file there are the ids of various Sloane Number sequences for Goodstein
Sequences, just
in case you wanted to verify your solution.
e.g.
A056193
A222117
A059933
A211378

Thanks,
Jon
--------------------------------------------
On Thu, 4/12/18, Louis de Forcrand <ol...@bluewin.ch> wrote:

Subject: Re: [Jprogramming] Goodstein Sequences and Hereditary base-n  notation
To: programm...@jsoftware.com
Date: Thursday, April 12, 2018, 12:01 AM

Hi,

This is my tacit version. Not claiming speed
(or anything in the way of code legibility for that matter).
The important verb is hbi, hereditary base-x incrementation
of y used in creating the Goodstein sequence.
My gs verb uses a starting base of 2, and gss
starts with base x:

hbi=:
([ (] +/ . * >:@[ ^ [ \$: i.@-@#@]) #.^:_1)`]@.(0 =
])"0
gs=: , >:@# <:@hbi {:
gss=: ] , (+ <:@#) <:@hbi {:@]

gs^:(0~:{:)^:10 ] 3x
3 3 3 2 1 0
gs^:(0~:{:)^:10
] 4x
4 26 41 60 83 109 139 173 211 253
299
gs^:(0~:{:)^:3 ] 19x
19 7625597484990

13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084099
191101259794547752035640455...

3 gss^:(0~:{:@])^:10 ] 3x
3
3 2 1 0

Sorry if I didn’t explain my code, kind of
short on time. I’m pretty sure it works though!

Cheers,
Louis

> On
11 Apr 2018, at 15:15, 'Jon Hough' via Programming
<programm...@jsoftware.com>
wrote:
>
> My first
answer was actually comletely wrong, and only works for the
simplest cases. This is a more robust and correct
solution
>
>
goodstein=: 4 : 0"0 0
> if. y = x
do.
>  x+1 return.
>
elseif. y = 0 do.
>  0 return.
> end.
> s=. I. x
(|.@:((>:@:>.@:^. # [) #: ])) y
>
d=. (x+1) ^ (x:x) goodstein x: s
> +/d
> )
>
> G=: <:@:goodstein
>

> NB. generates sequence
> genSeq=: 3 : 0"1
>
'base val its'=. y
> c=. 0
> vals=. val
> whilst.
its > c=. c+1 do.
>  val=. base G
val
>  vals=. vals,val
>  base=. base+1
>
end.
> vals
> )
>
> genSeq 2 4 10
> 4 26 41 60 83 109 139 173 211 253 299
>
> genSeq 2 19 3
> 19 7625597484990

13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084099

19110125979454775203564045597039645991980810489900943371395127892465205302426158030...
>
>
>
--------------------------------------------
> On Wed, 4/11/18, 'Jon Hough' via
Programming <programm...@jsoftware.com>
wrote:
>
> Subject:
[Jprogramming] Goodstein Sequences and Hereditary base-n
notation
> To: "Programming
Forum" <programm...@jsoftware.com>
> Date: Wednesday, April 11, 2018, 5:14
PM
>
>
Goodstein's theorem: https://en.wikipedia.org/wiki/Goodstein%27s_theorem
> This states  that every Goodstein
> sequence eventually terminates at 0.
> The wikipedia page defines Goodstein
> sequences in terms of Hereditary base-n
notation
> one such sequence is
4,26,41,60...
>
>
Copying verbatim from wikipedia:
>
==============
> The Goodstein sequence
G(m) of a number
> m is a sequence of
natural numbers. The first element in the
> sequence G(m) is m itself. To get the
second, G(m)(2), write
> m in hereditary
base-2 notation, change all the 2s to 3s,
> and then subtract 1 from the result. In
general, the
> (n + 1)-st term
G(m)(n + 1) of the Goodstein
>
sequence of m is as follows:
>
> Take the hereditary base-n + 1
> representation of G(m)(n).
> Replace each occurrence of the
> base-n + 1 with n + 2.
> Subtract one. (Note that the next term
> depends both on the previous term and on
the index n.)
> Continue until the result
is zero, at
> which point the sequence
terminates.
> ===============
>
> The sequences take
an impossibly long
> time to terminate
for most inputs, so there is no use
>
writing a verb that iterates until convergance. This is
my
> verb that will calculate the first N
elements of the
> sequence,
> starting with a given base and val. the
> base should start at 2, to conform to the
above definition.
>
>

> goodstein=: 3 : 0
>
'base val its'=. y
> vals=.
''
> c=: 0
>
whilst.its> c=: c+1 do.
>   if. val =
0 do. vals return.
>   else.
>     t=: ((1+
>>
.base^.val)#base) #: val
>     if. base
< # t do.
>       if. 0 < base
{
> |.t do.
>
tr=: 0
> (base}) |.t
>         if.
>
(base+1) < # tr do.
>
ts=:
> (1+(base+1){tr) ((x+1)}) tr
>           ts=:
>
|.ts
>         else.
>           ts=:
>
tr,1
>           ts=:
> |.ts
>
end.
>       else. ts=: t end.
>     else.
>
ts=: t
>     end.
>     val=. <:(base+1) #.
> ts
>     vals=.
vals,val
>     base=. base+1
>   end.
> end.
> vals
> )
>
>
>
> NB. example
> goodstein 2 4 9
> 26 41
60 83 109 139 173 211 253
> NB.
continues to very large numbers.
>
>  goodstein 2 3 5
> 3 3
2 1 0   NB. terminates after 6
>
iterations
>
> Is was
hoping the goodstein verb could
> be
defined tacitly, but my verb is clearly a bit of a mess.
> Just for fun, any elegant solutions?
>
> Thanks,
> Jon
>
----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm```