Hailstone sequence: Difference between revisions

{{trans|Python}}

V seq = [n]

L n > 1

V m = max((1..99999).map(i -> (hailstone(i).len, i)))

{{out}}

=={{header|360 Assembly}}==

HAILSTON CSECT

USING HAILSTON,R12

XDEC DS CL12

YREGS

{{out}}

<pre>

=={{header|ABAP}}==

CLASS lcl_hailstone DEFINITION.

PUBLIC SECTION.

cl_demo_output=>write( lcl_hailstone=>get_longest_sequence_upto( 100000 ) ).

cl_demo_output=>display( ).

{{out}}

<pre>

=={{header|ACL2}}==

(loop for x = len

then (if (evenp x)

(if (> new-mx mx)

(max-hailstone-start (1- limit) new-mx limit)

{{out}}

=={{header|Ada}}==

Similar to [[#C|C method]]:

procedure hailstone is

type int_arr is array(Positive range <>) of Integer;

end loop;

put_line(Integer'Image(nmax)&" max @ n= "&Integer'Image(stonemax));

{{out}}

<pre>

hailstones.ads:

type Integer_Sequence is array(Positive range <>) of Integer;

function Create_Sequence (N : Positive) return Integer_Sequence;

hailstones.adb:

function Create_Sequence (N : Positive) return Integer_Sequence is

begin

end if;

end Create_Sequence;

example main.adb:

with Hailstones;

Ada.Text_IO.Put_Line ("with N =" & Integer'Image (Longest_N));

end;

{{out}}

<pre>Length of 27: 112

=={{header|Aime}}==

print_hailstone(integer h)

{

return 0;

{{out}}

<pre>hailstone sequence for 27 is 27 82 41 124 .. 8 4 2 1, it is 112 long

=={{header|ALGOL 60}}==

{{works with|A60}}

comment Hailstone sequence - Algol 60;

integer array collatz[1:400]; integer icollatz;

outstring(1,", with"); outinteger(1,nel); outstring(1,"elements.");

outstring(1,"\n")

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - using the ''print'' routine rather than ''printf''}}

PROC hailstone = (INT in n, REF[]LINT array)INT:

print(("Max",hmax," at j=",jatmax, new line))

#

{{out}}

<pre>

=={{header|ALGOL-M}}==

The limitations of ALGOL-M's 15-bit integer data type will not allow the required search up to 100000 for the longest sequence, so we stick with what is possible.

BEGIN

WRITE("MAXIMUM SEQUENCE LENGTH =", LONGEST, " FOR N =", NLONG);

{{out}}

<pre>

=={{header|ALGOL W}}==

% show some Hailstone Sequence related information %

% calculates the length of the sequence generated by n, %

end

end

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

⍝ recursive dfn:

dfnHailstone←{

∇

{{out}}

5 16 8 4 2 1

5↑hailstone 27

112

1↑{⍵[⍒↑(⍴∘hailstone)¨⍵]}⍳100000

=={{header|AppleScript}}==

script o

property sequence : {n}

tell hailstoneSequence(n)

return {n:n, |length of sequence|:(its length), |first 4 numbers|:items 1 thru 4, |last 4 numbers|:items -4 thru -1}

{{output}}

<pre>{|length of sequence|:112, |first 4 numbers|:{27, 82, 41, 124}, |last 4 numbers|:{8, 4, 2, 1}}</pre>

set nums to {}

set longestLength to 1

set end of nums to n

end if

{{output}}

===Hailstone Sequence of N equal to 27 ===

b ProgramStart

;;;;;;;;;;; EVERYTHING PAST THIS POINT IS JUST I/O ROUTINES FOR PRINTING NUMBERS AND WORDS TO THE GAME BOY ADVANCE'S SCREEN

;;;;;;;;;;; I ASSURE YOU THAT ALL OF IT WORKS BUT CHANCES ARE YOU DIDN'T COME HERE TO SEE THAT.

{{out}}

To keep this short, I'm only including the part that changed, and the output. This goes after the call to <code>ResetTextCursors</code> but before the infinite loop:

bl Hailstone

mov r6,r3

mov r0,r6

bl ShowHex32

{{out}}

=={{header|Arturo}}==

ret: @[n]

while [n>1][

print ["max hailstone sequence found (<100000): of length" maxHailstoneLength "for" maxHailstone]

{{out}}

=={{header|AutoHotkey}}==

; [1] Generate the Hailstone Seq. for a number

}

ToolTip

=={{header|AutoIt}}==

$Hail = Hailstone(27)

ConsoleWrite("Sequence-Lenght: "&$Hail&@CRLF)

Return $Counter

EndFunc ;==>Hailstone

{{out}}

<pre>27,82,41,124,62,31,94,47,142,71,214,107,322,161,484,242,121,364,182,91,274,137,412,206,103,

=={{header|AWK}}==

#!/usr/bin/awk -f

function hailstone(v, verbose) {

printf("longest hailstone sequence is %i and has %i elements\n",ix,m);

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

100 N = 27

470 IF EVEN THEN N=N/2

480 IF NOT EVEN THEN N = (3 * N) + 1

==={{header|BBC BASIC}}===

PRINT '"Sequence length = "; seqlen%

maxlen% = 0

L% += 1

ENDWHILE

{{out}}

<pre>

==={{header|Commodore BASIC}}===

110 N=27 : SHOW=1

120 GOSUB 1000

1060 S = 3*S+1

1070 GOTO 1020

==={{header|FreeBASIC}}===

' compile with: fbc -s console

Print : Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>sequence for number 27

==={{header|GW-BASIC}}===

20 P = 1

30 GOSUB 130

160 IF N#/2 = INT(N#/2) THEN N# = N#/2 ELSE N# = 3*N# + 1

170 C = C + 1

==={{header|Liberty BASIC}}===

print ""

while hailstone < 1 or hailstone <> int(hailstone)

print ""

print "The number less than 100,000 with the longest 'Hailstone Sequence' is "; largesthailstone;". It's sequence length is "; max;"."

==={{header|OxygenBasic}}===

function Hailstone(sys *n)

'result 100000, 77031, 351

==={{header|PureBasic}}===

Procedure.i FillHailstones(n) ; Fills the list & returns the amount of elements in the list

Print(#CRLF$+#CRLF$+"Press ENTER to exit."): Input()

CloseConsole()

{{out}}

==={{header|Run BASIC}}===

print ""

end if

wend

==={{header|Tiny BASIC}}===

Tiny BASIC is limited to signed integers from -32768 to 32767. This code combines two integers into one: number = 32766A + B, to emulate integers up to 1.07 billion. Dealing with integer truncation, carries, and avoiding overflows requires some finesse. Even so one number, namely 77671, causes an overflow because one of its steps exceeds 1.07 billion.

INPUT N REM unit column

LET M = 0 REM 32766 column

PRINT "at step number ",C

PRINT "trying to triple 32766x",M," + ",N

{{out}}

<pre>

''2. Show that the hailstone sequence for the number 27 has 112 elements... ''

<!--The third task is NOT included because task #3 will take several hours in processing...-->

setlocal enabledelayedexpansion

echo.

set /a num/=2

set seq=!seq! %num%

{{Out}}

<pre>Task #1: (Start:111)

The script above could only be used in '''smaller''' inputs. Thus, for the third task, a slightly different script will be used. However, this script is still '''slow'''. I tried this on a fast computer and it took about 40-45 minutes to complete.

setlocal enableDelayedExpansion

if "%~1"=="test" (

pause>nul

{{Out}}

<pre>Number less than 100000 with longest sequence: 77031

'''The pure hailstone sequence function''', returning the sequence for any number entered in the console:

>%"d3~@.PNp

'''Returning the sequence for the starting value <code>27</code>'''

>%"d3~@.PNq

d~2~qL~1Ff{<BF3_

Output of the sequence, followed by the length of the sequence:

27

82

1

'''Number below 100,000 with the longest hailstone sequence, and the length of that sequence:'''

>%"d3~@.Pqf#{g?` `{gpK@~BP9~5@P@q'M<

d~2~pL~1Ff< < >?d

>zAg?MM@1~y@~gLpz2~yg@~3~hAg?M d

Output:

=={{header|Befunge}}==

> :2%v >

v+1*3_2/

vg01g00 ,+49<

>"@"*+.@

{{out}}

<pre>

=={{header|BQN}}==

Works in: [[CBQN]]

𝕨𝕊1: 𝕨;

(𝕨⊸∾ 𝕊 ⊢) (2|𝕩)⊑⟨𝕩÷2⋄1+3×𝕩⟩

•Show Collatz1 5

=={{header|Bracmat}}==

( hailstone

= L len

)

)

=={{header|Brainf***}}==

{{incomplete}}

[

[Cell 16: ASCII code for " " (Space). ]

[Rest of the cells: Temp cells. ]

=={{header|Brat}}==

sequence = [num]

while { num != 1 }

}

{{out}}

<pre>Sequence for 27 is correct

=={{header|Burlesque}}==

blsq ) 27{^^^^2.%{3.*1.+}\/{2./}\/ie}{1!=}w!bx{\/+]}{\/isn!}w!L[

112

=={{header|C}}==

#include <stdlib.h>

return 0;

{{out}}

<pre>[ 27, 82, 41, 124, ...., 8, 4, 2, 1] len= 112

===With caching===

Much faster if you want to go over a million or so.

#define N 10000000

printf("max below %d: %d, length %d\n", N, mi, max);

return 0;

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

}

}

<pre>

112 Elements

===With caching===

As with the [[#C|C example]], much faster if you want to go over a million or so.

using System.Collections.Generic;

}

}

<pre>

max below 100000: 77031 (351 steps)

=={{header|C++}}==

#include <vector>

#include <utility>

return 0;

{{out}}

{{uses from|library|Qt}}

Templated solution works for all of Qt's sequential container classes (QLinkedList, QList, QVector).

#include <QDebug>

#include <QVector>

qInfo() << " starting element:" << max.first();

}

{{out}}

<pre>

=={{header|Ceylon}}==

{Integer*} hailstone(variable Integer n) {

}

print("the longest sequence under 100,000 starts with ``longest.first else "what?"`` and has length ``longest.size``");

=={{header|CLIPS}}==

(slot bound) ; upper bound for the range of values to check

(slot next (default 2)) ; next value that needs to be checked

(printout t "sequence is " ?start " with a length of " ?len "." crlf)

(printout t crlf)

{{out}}

=={{header|Clojure}}==

{:pre [(pos? n)]}

(lazy-seq

(for [i (range 1 100000)]

{:num i, :len (count (hailstone-seq i))}))]

=={{header|CLU}}==

hailstone = iter (n: int) yields (int)

while true do

|| " has the longest hailstone sequence < 100000: "

|| int$unparse(maxlen))

{{out}}

<pre>The hailstone sequence for 27 has 112 elements.

=={{header|COBOL}}==

Testing with GnuCOBOL

program-id. hailstones.

remarks. cobc -x hailstones.cob.

.

{{out}}

=={{header|CoffeeScript}}==

Recursive version:

if n is 1

[n]

maxnums = [i]

<pre>hailstone(27) = 27,82,41,124 ... 8,4,2,1 (length: 112)

Max length: 351; numbers generating sequences of this length: 77031</pre>

=={{header|Common Lisp}}==

(cond ((= n 1) '(1))

((evenp n) (cons n (hailstone (/ n 2))))

(let ((len (length (hailstone i))))

(when (> len l) (setq l len k i)))

Sample session:

<pre>ROSETTA> (length (hailstone 27))

=={{header|Cowgol}}==

# Generate the hailstone sequence for the given N and return the length.

print(" has the longest hailstone sequence < 100000: ");

print_i32(max_len);

{{out}}

=={{header|Crystal}}==

def hailstone(n)

seq = [n]

puts ([twenty_seven.size, twenty_seven.first(4), max.last(4)])

# => [112, [27, 82, 41, 124], [8, 4, 2, 1]]

=={{header|D}}==

===Basic Version===

auto hailstone(uint n) pure nothrow {

.reduce!max;

writeln("Longest sequence in [1,", N, "]= ",p[1]," with len ",p[0]);

{{out}}

<pre>hailstone(27)= [27, 82, 41, 124] ... [8, 4, 2, 1]

===Lazy Version===

Same output.

auto hailstone(uint m) pure nothrow @nogc {

.reduce!max;

writeln("Longest sequence in [1,", N, "]= ",p[1]," with len ",p[0]);

===Faster Lazy Version===

Same output.

uint n;

bool empty() const pure nothrow @nogc { return n == 0; }

.reduce!max;

writeln("Longest sequence in [1,", N, "]= ",p[1]," with len ",p[0]);

===Lazy Version With Caching===

Faster, same output.

struct Hailstone(size_t cacheSize = 500_000) {

.reduce!max;

writeln("Longest sequence in [1,", N, "]= ",p[1]," with len ",p[0]);

===Generator Range Version===

auto hailstone(size_t n) {

.reduce!max;

writeln("Longest sequence in [1,", N, "]= ",p[1]," with len ",p[0]);

=={{header|Dart}}==

if(n<=0) {

throw new IllegalArgumentException("start value must be >=1)");

}

print("up to 100000 the sequence h($seq) has the largest length ($max)");

{{out}}

<pre>h(1)=[1]

The e and o procedure is for even and odd number respectively.

The x procedure is for overall control.

[[--: ]nzpq]sq

[d 2/ p]se

[d 3*1+ p]so

{{out}}

<pre>

Register L for the length of the longest sequence and T for the corresponding number.

Also, procedure q is slightly modified for storing L and T if needed, and all printouts in procedure e and o are muted.

[dsLltsT]sM

[[zdlL<M q]sq

[lt1+dstlsxc lt100000>l]dslx

lTn[:]nlLp

{{out}} (Takes quite some time on a decent machine)

<pre>77031:351</pre>

=={{header|DCL}}==

$ i = 1

$ loop:

$ write sys$output "sequence has ", i, " elements starting with ", s1, ", ", s2, ", ", s3, ", ", s4, " and ending with ", s'preantepenultimate_i, ", ", s'antepenultimate_i, ", ", s'penultimate_i, ", ", s'i

$ endif

{{out}}

<pre>$ @hailstone 27

sequence has 112 elements starting with 27, 82, 41, 124 and ending with 8, 4, 2, 1</pre>

$ i = 1

$ max_so_far = 0

$ sequence_length == I

$ exit

{{out}}

<pre>$ @longest_hailstone 100000

=== Using List<Integer> ===

{$APPTYPE CONSOLE}

Readln;

{{out}}

<pre>27: 112 elements

{{libheader| Boost.Int}}[https://github.com/MaiconSoft/DelphiBoostLib]

{{libheader| System.Diagnostics}}

program ShowHailstoneSequence;

end.

{{out}}

=={{header|Déjà Vu}}==

swap [ over ]

while < 1 dup:

!print( "number: " to-str max ", length: " to-str maxlen )

else:

{{out}}

<pre>true

=={{header|EchoLisp}}==

(lib 'hash)

(lib 'sequences)

(writeln 'maxlength= hmaxlength 'for hmaxseed))

{{out}}

(define H27 (iterator/f hailstone 27))

(take H27 6)

maxlength= 525 for 837799

=={{header|EDSAC order code}}==

Even with the storage-related code cut out, Part 2 of the task executes 182 million EDSAC orders.

At 650 orders per second, the original EDSAC would have taken 78 hours.

[Hailstone (or Collatz) task for Rosetta Code.

EDSAC program, Initial Orders 2.]

E 41 Z [define entry point]

P F [acc = 0 on entry]

{{out}}

<pre>

=={{header|Egel}}==

import "prelude.eg"

def main = (task0, task1, task2)

=={{header|Eiffel}}==

class

APPLICATION

end

{{out}}

<pre>

=={{header|Elena}}==

ELENA 4.x :

import extensions;

console.printFormatted("max below {0}: {1} ({2} steps)", maxNumber, longestNumber, longestChain)

{{out}}

<pre>

=={{header|Elixir}}==

require Integer

end

{{out}}

=={{header|Erlang}}==

-import(io).

-export([main/0]).

io:format("finding maximum hailstone(N) length for 1 <= N <= 100000..."),

{Length, N} = max_length(1, 100000),

{{out}}

<pre>Eshell V5.8.4 (abort with ^G)

This version has one collatz function for just calculating totals (just for fun) and the second generating lists.

-module(collatz).

-export([main/0,collatz/1,coll/1,max_atz_under/1]).

io:format("Max: ~w~n", [max_atz_under(100000)]),

io:format("Total: ~w~n", [ length( Seq1000 ) ] ).

'''Output'''

<pre>

=={{header|ERRE}}==

In Italy it's known also as "Ulam conjecture".

PROGRAM ULAM

PRINT("Max. number is";NMAX;" with";MAX_COUNT;"elements")

END PROGRAM

{{out}}

<pre>

=={{header|Euler Math Toolbox}}==

>function hailstone (n) ...

$ v=[n];

351

77031

=={{header|Euphoria}}==

sequence s

s = {n}

printf(1,"The longest hailstone sequence under 100,000 is %d with %d elements.\n",

{{out}}

<pre>hailstone(27) =

Ezhil is a Tamil programming language, see [http://en.wikipedia.org/wiki/Ezhil_%28programming_language%29 | Wikipedia] entry.

நிரல்பாகம் hailstone ( எண் )

பதிப்பி "=> ",எண் #hailstone seq

பதிப்பி "**********************************************"

முடி

=={{header|F_Sharp|F#}}==

match n with

| 1 -> yield 1

let maxLen, maxI = Seq.max <| seq { for i in 1..99999 -> Seq.length (hailstone i), i}

{{out}}

<pre>Maximum length 351 was found for hailstone(77031)</pre>

=={{header|Factor}}==

USING: arrays io kernel math math.ranges prettyprint sequences vectors ;

IN: rosetta.hailstone

PRIVATE>

{{out}}

<pre>$ ./factor -run=rosetta.hailstone

=={{header|FALSE}}==

[[$." "$1>][n;!]#%]s:

[1\[$1>][\1+\n;!]#%]c:

0m:0f:

1[$100000\>][$c;!$m;>[m:$f:0]?%1+]#%

=={{header|Fermat}}==

Func Collatz(n, d) =

g[1]:=champ;

g[2]:=record;

=={{header|Forth}}==

dup 1 and if 3 * 1+ else 2/ then ;

: .hail ( n -- )

swap . ." has hailstone sequence length " . ;

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

end subroutine

{{out}}

<pre>

{{Works with|Frege|3.21.586-g026e8d7}}

import Data.List (maximumBy)

let t4 = show $ drop (length h27 - 4) h27

putStrLn ("hailstone 27: " ++ h4 ++ " ... " ++ t4)

{{out}}

=={{header|Frink}}==

hailstone[n] :=

{

println["$longestN has length $longestLen"]

=={{header|FunL}}==

hailstone( 1 ) = [1]

hailstone( n ) = n # hailstone( if 2|n then n/2 else n*3 + 1 )

val (n, len) = maxBy( snd, [(i, hailstone( i ).length()) | i <- 1:100000] )

{{out}}

=={{header|Futhark}}==

fun hailstone_step(x: int): int =

if (x % 2) == 0

(hailstone_seq x,

reduce max 0 (map hailstone_len (map (1+) (iota (n-1)))))

=={{header|FutureBasic}}==

local fn Hailstone( n as NSInteger ) as NSInteger

'~'1

HandleEvents

{{output}}

=={{header|GAP}}==

local v;

v := [ n ];

# [ 77031, 351 ]

CollatzMax(1, 1000000);

=={{header|Go}}==

import "fmt"

}

fmt.Printf("hs(%d): %d elements\n", maxN, maxLen)

{{out}}

<pre>

Output is the same as version above.

import "fmt"

}

fmt.Printf("hs(%d): %d elements\n", nMaxLen, computedLen[nMaxLen])

=={{header|Groovy}}==

def sequence = []

while (start != 1) {

}

sequence << start

Test Code

assert sequence.size() == 112

assert sequence[0..3] == [27, 82, 41, 124]

def results = (1..100000).collect { [n:it, size:hailstone(it).size()] }.max { it.size }

{{out}}

<pre>[n:77031, size:351]</pre>

=={{header|Haskell}}==

import Data.Ord (comparing)

"The sequence has length: "

<> (show . length . hailstone $ longestChain)

{{Out}}

<pre>Collatz sequence for 27:

The following is an older version, which some of the language examples on this page are translated from:

import Data.List (maximumBy, intercalate)

maximumBy (comparing fst) $

withResult (length . hailstone) <$> [1 .. 100000]

{{out}}

<pre>112

One approach to using '''unfoldr''' and then '''foldr''' might be:

, "length of this sequence:"

, show maxLen