/* 

  Juggler sequence in Picat.

  http://en.wikipedia.org/wiki/Juggler_sequence
  """
  In recreational mathematics a juggler sequence is an integer sequence 
  that starts with a positive integer a0, with each subsequent term 
  in the sequence defined by the recurrence relation:

               
              floor(a[k]**(1/2)    if a[k] is even
    a[k+1] = 
              floor(a[k]**(3/2)    if a[k] is odd

  """

  This Picat model was created by Hakan Kjellerstrand, hakank@gmail.com
  See also my Picat page: http://www.hakank.org/picat/

*/


import util.

main => go.


go =>
  
  % writeln(seq(5)),
  A = 5,
  L = [A],
  while (A > 1) 
    writeln(A),
    A := seq(A),
    L := L ++ [A]
  end,
  println(L),
  nl.

go2 => 
  Lens = [],
  foreach(A in 2..1000) 
     S = sequence(A),
     Len = S.length-1, % note: we don't count the last 1
     println([A,S,Len]),
     Lens := Lens ++ [Len]
  end,
  println(lens=Lens),
  nl.

% longest sequence
go3 => 
  Lens = [],
  Seqs = [],
  foreach(A in 1..10000) 
     S = sequence(A),
     Len = S.length-1, % note: we don't count the last 1
     Seqs := Seqs ++ [S],
     % println([S,Len]),
     Lens := Lens ++ [Len]
  end,
  % println(lens=Lens),
  ArgMax = argmax(Lens),
  println(argMax=ArgMax),
  println(maxLens=[Lens[I] : I in ArgMax]),
  println(maxSeq=join([Seqs[I] : I in ArgMax],'\n')),
  nl.

argmax(L) = MaxIx =>
  Max = max(L),
  MaxIx = [I : I in 1..L.length, L[I] == Max].

sequence(A) = Seq =>
  Seq = [A],
  while (A > 1) 
    A := seq(A),
    Seq := Seq ++ [A]
  end.

seq(A) = floor(A**(1/2)), A mod 2 == 0 => true.
seq(A) = floor(A**(3/2)), A mod 2 == 1 => true.