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>

</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>

27: length 112, first: [27 82 41 124] last: [8 4 2 1]

Maximum sequence length: 351 for: 77031

</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

Longest so far: 77031 @ 351 elements

Longest was starting from 77031 and was of length 351</pre>

 

=={{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}}==

}

seq.add(n);

seq.add(n);

}

}

 

main() {

}

 

 

 

}

}

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

{{out}}

length of sequence h(27): 112

up to 100000 the sequence h(77031) has the largest length (351)</pre>

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

true

number: 77031, length: 351</pre>

 

=={{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}}==

import extensions;

auto recursiveLengths := new Map<int,int>(4096,4096);

{

var chainLength := Hailstone(i, recursiveLengths);

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

{{out}}

<pre>

 

=={{header|Elixir}}==

require Integer

end

 

 

{{out}}

Hailstone(27) has 112 elements: [27, 82, 41, 124, ..., 8, 4, 2, 1]

Longest sequence starting under 100000 begins with 77031 and has 351 elements.

</pre>

 

=={{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|Fōrmulæ}}==

 

 

 

 

=={{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

{{Out}}

<pre>Sequence 27 length:

 

=={{header|HicEst}}==

 

H27 = hailstone(27)

ENDIF

ENDDO

H27=112; first4(1)=27; first4(2)=82; first4(3)=41; first4(4)=124; ...; last4(1)=8; last4(2)=4; last4(3)=2; last4(4)=1;

<br /> number=77031; longest_sequence=351;

=={{header|Icon}} and {{header|Unicon}}==

A simple solution that <i>generates</i> (in the Icon sense) the sequence is:

while n > 1 do {

suspend n

}

suspend 1

and a test program for this solution is:

n := integer(!args) | 27

every writes(" ",hailstone(n))

but this solution is computationally expensive when run repeatedly (task 3).

 

The following solution uses caching to improve performance on task 3 at the expense of space.

static cache

initial {

/cache[n] := [n] ||| hailstone(if n%2 = 0 then n/2 else 3*n+1)

return cache[n]

 

A test program is:

n := integer(!args) | 27

task2(n)

}

write(maxN," has a sequence of ",maxHS," values")

A sample run is:

<pre>

This solution uses a cache to speed up the length calculation for larger numbers.

{{works with|Glulx virtual machine}}

 

To decide which list of numbers is the hailstone sequence for (N - number):

let best number be N;

say "The number under 100,000 with the longest hailstone sequence is [best number] with [best length] element[s].";

 

{{out}}

=={{header|Io}}==

Here is a simple, brute-force approach:

makeItHail := method(n,

stones := list(n)

writeln("For numbers less than or equal to 100,000, ", nn,

" has the longest sequence of ", numOfElems, " elements.")

 

{{out}}

=={{header|Ioke}}==

{{needs-review|Ioke|Calculates the Hailstone sequence but might not complete everything from task description.}}

n println

unless(n <= 1,

if(n even?, collatz(n / 2), collatz(n * 3 + 1)))

 

=={{header|J}}==

'''Solution:'''

'''Usage:'''

112

4 _4 {."0 1 hailseq 27 NB. first & last 4 numbers in sequence

8 4 2 1

(>:@(i. >./) , >./) #@hailseq }.i. 1e5 NB. number < 100000 with max seq length & its seq length

See also the [[j:Essays/Collatz Conjecture|Collatz Conjecture essay on the J wiki]].

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.HashMap;

import java.util.List;

return;

}

{{out}}

<pre>Sequence for 27 has 112 elements: [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, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

===ES5===

====Imperative====

var seq = [n];

while (n > 1) {

}

}

{{out}}

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

(translating one of the Haskell solutions).

 

 

// Hailstone Sequence

};

 

 

{{out}}

 

107,322,161,484,242,121,364,182,91,274,137,412,206,103,310,155,466,233,700,350,

175,526, 263,790,395,1186,593,1780,890,445,1336,668,334,167,502,251,754,377,

2429,7288,3644,1822,911,2734,1367,4102,2051,6154,3077,9232,4616,2308,1154,577,

1732,866,433,1300,650,325,976,488,244,122,61,184,92,46,23,70,35,106,53,160,80,

 

Attempting to fold that recursive function over an array of 100,000 elements,

which reuses previously calculated paths.

 

 

function memoizedHailstone() {

return longestBelow(100000);

 

 

{{out}}

 

 

For better time (as well as space) we can continue to memoize while falling back to a function which returns the

for integers below one million, or ten million and beyond, without hitting the limits of system resources.

 

 

var dctMemo = {};

return [100000, 1000000, 10000000].map(longestBelow);

 

 

{{out}}

 

{"n":77031, "l":351}, // 100,000

{"n":837799, "l":525}, // 1,000,000

{"n":8400511, "l":686} // 10,000,000

 

 

===ES6===

 

// hailstones :: Int -> [Int]

`The length of that sequence is ${maxLen}.`

]);

{{Out}}

(Run in the Atom editor, through the Script package)

=={{header|jq}}==

{{works with|jq|1.4}}

def hailstone:

recurse( if . > 1 then

([0,0];

($i | count(hailstone)) as $l

'''Examples''':

| "[27|hailstone]|length is \($h|length)",

"The first four numbers: \($h[0:4])",

"",

max_hailstone(100000) as $m

{{out}}

[27|hailstone]|length is 112

The first four numbers: [27,82,41,124]

The last four numbers: [8,4,2,1]

 

 

=={{header|Julia}}==

 

===Dynamic solution===

len = 1

while n > 1

 

@show hailstonelength(27); nothing

 

{{out}}

====Julia 1.0====

{{works with|Julia|1.0+}}

count::T

end

Base.isless(h::HailstoneSeq, s::HailstoneSeq) = length(h) < length(s)

 

{{out}}

{{works with|Julia|0.6}}

 

start::T

end

 

Base.isless(h::HailstoneSeq, s::HailstoneSeq) = length(h) < length(s)

 

{{out}}

 

=={{header|K}}==

seqn: hail 27

 

 

{m,x@s?m:|/s:{#hail x}'x}{x@&x!2}!:1e5

 

=={{header|Kotlin}}==

 

fun hailstone(n: Int): ArrayDeque<Int> {

println("${longestHail.first} is the number less than 100000 with " +

"the longest sequence, having length ${longestHail.size}.")

 

{{out}}

 

=={{header|Lasso}}==

define_tag("hailstone", -required="n", -type="integer", -copy);

local("sequence") = array(#n);

"<br/>";

"Number with the longest sequence under 100,000: " #longest_index + ", with " + #longest_sequence + " elements.";

 

=={{header|Limbo}}==

 

 

include "sys.m"; sys: Sys;

return i :: hailstone((big 3 * i) + big 1);

}

 

{{out}}

 

=={{header|Lingo}}==

len = 1

repeat while n<>1

if listP(sequenceList) then sequenceList.add(n)

return len

Usage:

hailstone(27, sequenceList)

put sequenceList

end repeat

put n, maxLen

 

=={{header|Logo}}==

output ifelse equal? 0 modulo :n 2 [:n/2] [3*:n + 1]

end

end

 

 

=={{header|Logtalk}}==

 

:- public(generate_sequence/2).

).

 

Testing:

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 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1

true

| ?- hailstone::longest_sequence(1, 100000, N, Length).

N = 77031, Length = 351

 

=={{header|LOLCODE}}==

There is presently no way to query a <tt>BUKKIT</tt> for the existence of a given key, thus making memoization infeasible. This solution takes advantage of prior knowledge to run in reasonable time.

 

HOW IZ I hailin YR stone

VISIBLE "len(hail(" max ")) = " len

 

{{out}}

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

 

=={{header|Lua}}==

local n_iter = 1

 

end

 

 

=={{header|M2000 Interpreter}}==

 

Also we use current stack as FIFO to get the last 4 numbers

Module hailstone.Task {

hailstone=lambda (n as long)->{

}

hailstone.Task

{{out}}

<pre>

=={{header|Maple}}==

Define the procedure:

hailstone := proc( N )

local n := N, HS := Array([n]);

HS;

end proc;

Run the command and show the appropriate portion of the result;

> r := hailstone(27):

[ 1..112 1-D Array ]

> r(1..4) ... r(-4..);

[27, 82, 41, 124] .. [8, 4, 2, 1]

Compute the first 100000 sequences:

longest := 0; n := 0;

for i from 1 to 100000 do

od:

printf("The longest Hailstone sequence in the first 100k is n=%d, with %d terms\n",n,longest);

{{out}}

<pre>

 

=== Nested function call formulation ===

 

This is probably the most readable and shortest implementation.

 

=== Fixed-Point formulation ===

 

=== Recursive formulation ===

HailstoneR[n_?OddQ] := Prepend[HailstoneR[3 n + 1], n]

 

=== Procedural implementation ===

 

=== Validation ===

 

I use this version to do the validation:

NestWhileList[If[Mod[#, 2] == 0, #/2, ( 3*# + 1) ] &, n, # != 1 &];

 

{i, 100000}

]

{{out}}

<pre>

 

==== Sequence 27 ====

{{out}}

<pre>{112, {27, 82, 41, 124}, {8, 4, 2, 1}}</pre>

 

Alternatively,

 

{{out}}

 

==== Longest sequence length ====

{{out}}

<pre>{{77031, 351}}</pre>

=={{header|MATLAB}} / {{header|Octave}}==

===Hailstone Sequence For N===

x = n;

while n > 1

end

x(end + 1) = n; %#ok

Show sequence of hailstone(27) and number of elements:

{{out}}

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

Show the number less than 100,000 which has the longest hailstone sequence together with that sequence's length:

====Basic Version (use the above routine)====

maxLen = 0;

for k = 1:N

n = k;

end

{{out}}

<pre>n = 77031

maxLen = 351</pre>

====Faster Version====

maxLen = 0;

for k = 1:N

n = k;

end

{{out}}

n = 77031

====Much Faster Version With Caching====

lenList(N) = 0;

lenList(1) = 1;

n = k;

end

{{out}}

n = 77031

 

=={{header|Maxima}}==

(n: if evenp(n) then n/2 else 3*n + 1, L: endcons(n, L)), L)$

 

length(%); /* 112 */

collatz_length(27); /* 112 */

 

=={{header|Mercury}}==

The actual calculation (including module ceremony)

providing both a function and a predicate implementation:

 

:- interface.

; hailstone(3 * N + 1, S) ).

 

 

The mainline test driver (making use of [http://en.wikipedia.org/wiki/Unification_(computer_science) unification] for more succinct tests):

 

:- interface.

; io.write_string("At least one test failed.\n", !IO) ).

 

 

{{out}} of running this program is:

For those unused to logic programming languages it seems that nothing has been proved in terms of confirming anything, but if you look at the predicate declaration for <code>longest/3</code> …

 

 

… you see that the second and third parameters are '''output''' parameters.

Thus we know that the correct sequences and values were generated

without bothering to print them out.

 

=={{header|ML}}==

==={{header|MLite}}===

| (x rem 2 = 0) = x :: hail (x div 2)

| x = x :: hail (x * 3 + 1)

print ` ref (biggest, 0);

print " and is of length ";

{{out}}

<pre>hailstone sequence for the number 27 has 112 elements starting with [27, 82, 41, 124] and ending with [8, 4, 2, 1].

 

=={{header|Modula-2}}==

 

IMPORT InOut;

FindMax (100000);

InOut.WriteString ("Done."); InOut.WriteLn

Producing:

<pre>jan@Beryllium:~/modula/rosetta$ hailst

 

=={{header|MUMPS}}==

If n=1 Quit n

If n#2 Quit n_" "_$$hailstone(3*n+1)

Quit n_" "_$$hailstone(n\2)

Set x=$$hailstone(27) Write !,$Length(x," ")," terms in ",x,!

 

=={{header|Nanoquery}}==

seq = list()

end

print "\nThe number less than 100,000 with the longest sequence is "

{{out}}

<pre>hailstone(27)

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

hs = hs' 'hn

 

{{out}}

<pre>

 

=={{header|Nim}}==

result = @[n]

var n = n

m = n

mi = i

{{out}}

<pre>Hailstone sequence for number 27 has 112 elements.

 

=={{header|Oberon-2}}==

 

IMPORT Out;

Out.String ("Done.");

Out.Ln

Producing

<pre>

 

=={{header|OCaml}}==

open Num;;

 

"1732"; "866"; "433"; "1300"; "650"; "325"; "976"; "488"; "244"; "122";

"61"; "184"; "92"; "46"; "23"; "70"; "35"; "106"; "53"; "160"; "80"; "40";

 

=={{header|Oforth}}==

 

| l |

ListBuffer new ->l

 

hailstone(27) dup size println dup left(4) println right(4) println

 

{{out}}

[351, 77031]

</pre>

 

=={{header|ooRexx}}==

sequence = hailstone(27)

say "Hailstone sequence for 27 has" sequence~items "elements and is ["sequence~toString('l', ", ")"]"

end

return sequence

{{out}}

<pre>

=={{header|Order}}==

To display the length, and first and last elements, of the hailstone sequence for 27, we could do this:

 

#define ORDER_PP_DEF_8hailstone ORDER_PP_FN( \

8(starts with:) 8seq_take(4, 8H) 8comma 8space

8(ends with:) 8seq_drop(8minus(8S, 4), 8H))

{{out}}

 

Unfortunately, the C preprocessor not really being designed with large amounts of garbage collection in mind, trying to compute the hailstone sequences up to 100000 is almost guaranteed to run out of memory (and take a very, very long time). If we wanted to try, we could add this to the program, which in most languages would use relatively little memory:

8fn(8M, 8P, \

8if(8is_0(8M), \

8let((8P, 8h_longest(8nat(1,0,0,0,0,0), 8pair(0, 0))),

8pair(8to_lit(8tuple_at_0(8P)), 8to_lit(8tuple_at_1(8P))))

 

...or even this "more elegant" version, which will run out of memory very quickly indeed (but in practice seems to work better for smaller ranges):

8let((8P,

8seq_head(

8pair(8N, 8seq_size(8hailstone(8N)))),

8seq_iota(1, 8nat(1,0,0,0,0,0)))))),

 

Notice that large numbers (>100) must be entered as digit sequences with <code>8nat</code>. <code>8to_lit</code> converts a digit sequence back to a readable number.

 

=={{header|Oz}}==

fun {HailstoneSeq N}

N > 0 = true %% assert

MaxI#MaxLen = {List.foldL Pairs MaxBy2nd 0#0}

{System.showInfo

{{out}}

<pre>

 

===Version #1.===

my(t=1);

while(n>1,

 

show(27)

{{out}}

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

[http://oeis.org/A070165 A070165]

 

\\ Get vector with Collatz sequence for the specified starting number.

\\ Limit vector to the lim length, or less, if 1 (one) term is reached (when lim=0).

Collatzmax(1,100000);

}

 

{{Output}}

See [[Hailstone_sequence#Delphi | Delphi]]

or try this transformed Delphi version without generics.Use of a static array.

{$IFDEF FPC}

{$MODE delphi} //or objfpc

limit := limit*10;

until Limit > maxN;

{{out}}

<pre>sequence of 27 has 112 elements

=={{header|Perl}}==

=== Straightforward ===

 

use warnings;

 

return @sequence;

 

{{out}}

=== Compact ===

A more compact version:

use strict;

 

@h = ();

for (1 .. 99_999) { @h = ($_, $h[2]) if ($h[2] = hailstone($_)) > $h[1] }

 

 

=={{header|Phix}}==

Copy of [[Hailstone_sequence#Euphoria|Euphoria]]

{{out}}

<pre>

</pre>

 

=={{header|PHP}}==

$sequence = $seq;

$sequence[] = $n;

foreach($maxResult as $key => $val){

echo 'Number < 100000 with longest Hailstone seq.: ' . $key . ' with length of ' . $val;

<pre>

112 Elements.

Number < 100000 with longest Hailstone seq.: 77031 with length of 351

</pre>

 

=={{header|PicoLisp}}==

(make

(until (= 1 (link N))

 

(let N (maxi '((N) (length (hailstone N))) (range 1 100000))

{{out}}

<pre>27 112 (27 82 41 124) - (8 4 2 1)

 

=={{header|Pike}}==

 

int next(int n)

}

write("longest sequence starting at %d has %d elements\n", longest->start, longest->length);

 

{{out}}

 

=={{header|PL/I}}==

declare (longest, n) fixed (15);

declare flag bit (1);

end hailstones;

 

{{out}}

<pre style="height:30ex;overflow:scroll">

 

==={{header|PL/I-80}}===

%replace

true by '1'b,

 

end hailstone_demo;

{{out}}

<pre>Display hailstone sequence for what number? 27

=={{header|plainTeX}}==

The following code works with any TeX engine.

\newcount\itercount

\newcount\currentnum

\repeat

Seed max = \seed, length = \lenmax

 

pdf or dvi output:

 

=={{header|Pointless}}==

println(format(fmt,

[seqLength, initSeq, tailSeq] ++ toList(longestPair)

step(n) =

 

{{out}}

=={{header|PowerShell}}==

{{works with|PowerShell|3.0+}}

 

function Get-HailStone {

}

}

 

{{out}}

=={{header|Prolog}}==

1. Create a routine to generate the hailstone sequence for a number.

hailstone(N,[N|S]) :- 0 is N mod 2, N1 is N / 2, hailstone(N1,S).

 

2. Use the routine to show that the hailstone sequence for the number 27 has 112 elements starting with 27, 82, 41, 124 and ending with 8, 4, 2, 1.

 

The following query performs the test.

length(X,112),

append([27, 82, 41, 124], _, X),

 

3. Show the number less than 100,000 which has the longest hailstone sequence together with that sequences length.

longesthailstone(1, Cn, Cl, Mn, Ml):- Mn = Cn,

Ml = Cl.

longesthailstone(N1, N, L, Mn, Ml).

longesthailstone(N, Cn, Cl, Mn, Ml) :- N1 is N-1,

run this query.

to get the following result

<pre>

Works with SWI-Prolog and module '''chr''' written by '''Tom Schrijvers''' and '''Jan Wielemaker''' <br>

 

:- chr_option(debug, off).

:- chr_option(optimize, full).

% Hailstone loop

hailstone(1) ==> true.

 

Code for task one :

hailstone(27),

findall(X, find_chr_constraint(hailstone(X)), L),

clean,

% check the requirements

{{out}}

<pre> ?- task1.

true.</pre>

Code for task two :

seq(2, 100000, 1-[1], Len-V),

format('For ~w sequence has ~w len ! ~n', [V, Len]).

findall(hailstone(X), find_chr_constraint(hailstone(X)), L),

length(L, Len),

{{out}}

<pre> ?- longest_sequence.

 

=={{header|Pure}}==

type odd x::int = x mod 2;

type even x::int = ~odd x;

(foldr (\ (a,b) (c,d) -> if (b > d) then (a,b) else (c,d))

(0,0)

{{out}}

<pre>

=={{header|Python}}==

===Procedural===

seq = [n]

seq.append(n)

return seq

 

if __name__ == '__main__':

h = hailstone(27)

 

{{out}}

<pre>Maximum length 351 was found for hailstone(77031) for numbers <100,000</pre>

 

===Composition of pure functions===

{{Works with|Python|3.7}}

 

from itertools import (islice, takewhile)

 

if __name__ == '__main__':

{{Out}}

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

 

=={{header|Quackery}}==

[ []

longest take echo

say " has the longest sequence of any number less than 100000."

 

'''Output:'''

It starts with 27 82 41 124 and ends with 8 4 2 1.

 

77031 has the longest sequence of any number less than 100000.

It is 351 elements long.

 

=={{header|R}}==

===Iterative solution===

makeHailstone <- function(n){

hseq <- n

cat("Between ", lower.bound, " and ", upper.bound, ", the input of ",

max.index, " gives the longest hailstone sequence, which has length ",

 

{{out}}

===Vectorization solution===

The previous solution is entirely satisfactory and may be more efficient than the following solution. However, problems like these are a great chance to show off the strength of R's vectorization. Also, this lets us show off how the <- syntax can do multiple variable assignments in one line. Observe how short the following code is:

collatz <- function(n)

{

cat("The longest sequence before the 100000th is found at n =", longest, "and it has length", seqLenghts[longest], "\n")

#Equivalently, line 1 could have been: seqLenghts <- sapply(Vectorize(collatz)(1:99999), length).

{{out}}

<pre>The first four elements are: 27 82 41 124 and the last four are: 8 4 2 1

 

=={{header|Racket}}==

#lang racket

 

(printf "for x<=~s, ~s has the longest sequence with ~s items\n"

N (car longest) (cdr longest))

 

{{out}}

(formerly Perl 6)

 

 

my @h = hailstone(27);

 

my $m = max ( (1..99_999).race.map: { +hailstone($_) => $_ } );

 

{{out}}

 

=={{header|REBOL}}==

hail: func [

"Returns the hailstone sequence for n"

"the number less than 100000 with the longest hail sequence is"

maxN "with length" maxLen

 

{{out}}

<pre>the hail sequence of 27 has length 112 and has the form 27 82 41 ... 4 2 1

the number less than 100000 with the longest hail sequence is 77031 with length 351</pre>

 

=={{header|REXX}}==

===non-optimized===

numeric digits 20 /*be able to handle gihugeic numbers. */

parse arg x y . /*get optional arguments from the C.L. */

s= s n /* [↑] % is REXX integer division. */

end /*#hs*/ /* [↑] append N to the sequence list*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

::::* &nbsp; previously calculated Collatz sequences (memoization)

::::* &nbsp; a faster method of determining if an integer is even

!.=0; !.0=1; !.2=1; !.4=1; !.6=1; !.8=1 /*assign even numerals to be "true". */

numeric digits 20; @.= 0 /*handle big numbers; initialize array.*/

if _>hm then iterate /*Is number out of range? Ignore it.*/

@._= r /*assign subsequence number to array. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

size = 27

aList = []

see "" + aList[i] + " "

next

 

=={{header|Ruby}}==

This program uses new methods (Integer#even? and Enumerable#max_by) from Ruby 1.8.7.

{{works with|Ruby|1.8.7}}

seq = [n]

until n == 1

n = (1 ... 100_000).max_by{|n| hailstone(n).length}

puts "#{n} has a hailstone sequence length of #{hailstone(n).length}"

{{out}}

<pre>

This avoids recomputing the end of the sequence.

{{works with|Ruby|1.8.7}}

ListNode = Struct.new(:value, :size, :succ) do

def each

n = (1 ... 100_000).max_by{|n| Hailstone.sequence(n).size}

puts "#{n} has a hailstone sequence length of #{Hailstone.sequence(n).size}"

output is the same as the above.

 

=={{header|Rust}}==

let mut res = Vec::new();

let mut next = start;

}

println!("Longest sequence is {} element long for seed {}", max_len, max_seed);

{{out}}

<pre>For 27 number of elements is 112

 

=={{header|S-lang}}==

define hailstone(n, lst)

{

}

}

{{out}}

<pre>Hailstone(27) has 112 elements starting with:

 

=={{header|SAS}}==

* Create a routine to generate the hailstone sequence for one number;

%macro gen_seq(n);

%mend;

%longest_hailstone(1,99999);

 

{{out}}

 

=={{header|S-BASIC}}==

Compute and display "hailstone" (i.e., Collatz) sequence

for a given number and find the longest sequence in the

 

end

{{out}}

<pre>Display hailstone sequence for what number? 27

{{libheader|Scala}}

{{works with|Scala|2.10.2}}

def hailstone(n: Int): Stream[Int] =

n #:: (if (n == 1) Stream.empty else hailstone(if (n % 2 == 0) n / 2 else n * 3 + 1))

val (n, len) = (1 until 100000).map(n => (n, hailstone(n).length)).maxBy(_._2)

println(s"Longest hailstone sequence length= $len occurring with number $n.")

{{Out}}

<pre>Use the routine to show that the hailstone sequence for the number: 27.

 

=={{header|Scheme}}==

(if (= n 1) '(1)

(cons n (collatz (if (even? n) (/ n 2) (+ 1 (* 3 n)))))))

 

(collatz-max 1 100000)

 

=={{header|Scilab}}==

{{trans|MATLAB}}

// iterative definition

// usage: global verbose; verbose=%T; hailstone(27)

M(k)=hailstone(k);

end;

{{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 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1

 

=={{header|Seed7}}==

 

const func array integer: hailstone (in var integer: n) is func

writeln(" length=" <& length(h27));

writeln("Maximum length " <& maxLength <& " at number=" <& numberOfMaxLength);

 

{{out}}

Maximum length 351 at number=77031

</pre>

 

=={{header|Sidef}}==

var sequence = [n]

while (n > 1) {

}

 

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

Sequences class >> hailstone: n [

|seq|

ifFalse: [ ^ Sequences hailstoneCount: ( (3*n) + 1) num: (m + 1) ].

]

 

r := Sequences hailstone: 27. "hailstone 'from' 27"

(r size) displayNl. "its length"

 

('Sequence generator %1, sequence length %2' % { (longest at: 1) . (longest at: 2) })

 

=={{header|SNUSP}}==

 

=={{header|Swift}}==

func hailstone(var n:Int) -> [Int] {

 

}

 

{{out}}

<pre>

=={{header|Tcl}}==

The core looping structure is an example of an [[Loops/N plus one half|n-plus-one-half loop]], except the loop is officially infinite here.

while 1 {

lappend seq $n

if {$l>$maxlen} {set maxlen $l;set max $i}

}

 

{{out}}

=={{header|TI-83 BASIC}}==

===Task 1===

N→M: 0→X: 1→L

While L=1

End

End

{{out}}

<pre> 10

===Task 2===

As the calculator is quite slow, so the output is for N=200

0→A:0→B

for(I,1,N)

Disp {I,X}

End

{{out}}

<pre>{171,125}</pre>

 

=={{header|TXR}}==

(cons n

(gen (not (eq n 1))

(set max len)

(set maxi i))))

 

<pre>$ txr -l hailstone.txr

=={{header|uBasic/4tH}}==

{{Trans|FreeBASIC}}

 

m = 0

Loop

 

uBasic is an interpreted language. Doing a sequence up to 100,000 would take over an hour, so we did up to 10,000 here.

{{out}}<pre>sequence for number 27

The best way is to use a shell with built-in arrays and arithmetic, such as Bash.

{{works with|Bash}}

# seq is the array genereated by hailstone

# index is used for seq

done

 

 

{{out}}

 

{{works with|Bourne Shell}}

# Clobbers $n.

hailstone() {

i=`expr $i + 1`

done

 

==={{header|C Shell}}===

This script is '''slow''', but it can reach 100000, and a fast computer might run it in less than 15 minutes.

 

# Clobbers $n.

alias hailstone eval \''@ n = \!:1:q \\

@ i += 1

end

 

{{out}}

===Implementation===

<b>hailstone.u</b>

 

def hailstone (int n)

append n seq

return seq

 

===Usage===

 

=={{header|Ursala}}==

#import nat

 

<

^T(@ixX take/$4; %nLP~~lrxPX; ^|TL/~& :/'...',' has length '--@h+ %nP+ length) hail 27,

The <code>hail</code> function computes the sequence as follows.

* Given a number as an argument, <code>@iNC</code> makes a list containing only that number before passing it to the rest of the function. The <code>i</code> in the expression stands for the identity function, <code>N</code> for the constant null function, and <code>C</code> for the cons operator.

 

=={{header|VBA}}==

Dim s As New Collection

s.Add CStr(n), CStr(n)

Next i

Debug.Print "The longest hailstone sequence under 100,000 is"; imax; "with"; hmax; "elements."

length = 112

The longest hailstone sequence under 100,000 is 77031 with 351 elements.</pre>

 

=={{header|VBScript}}==

'function arguments: "num" is the number to sequence and "return" is the value to return - "s" for the sequence or

'"e" for the number elements.

WScript.StdOut.WriteLine "Number less than 100k with the longest sequence: "

WScript.StdOut.WriteLine n_longest

 

{{Out}}

{{trans|PL/I}}

{{works with|Visual Basic|VB6 Standard}}

Dim flag As Boolean ' true to print values

Sub main()

End If

hailstones = p

{{Out}}

<pre>The sequence for 27 is: 27 82 41 124 ... 8 4 2 1

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2005+}}

Sub Main()

' Checking sequence of 27.

End Function

 

 

{{out}}

Max elements in sequence for number below 100k: 77031 with 351 elements.

</pre>

 

=={{header|Wren}}==

if (n < 1) Fiber.abort("Parameter must be a positive integer.")

var h = [n]

}

System.print(" Longest = %(longest)")

 

{{out}}

 

=={{header|XPL0}}==

int Seq(1000); \more than enough for longest sequence

 

];

IntOut(0, SN); Text(0, "'s Hailstone length = "); IntOut(0, MaxLen);

 

{{out}}

===Show The Sequence with n=27===

Output is in hexadecimal but is otherwise correct.

read "\SrcCPC\winape_macros.asm"

read "\SrcCPC\MemoryMap.asm"

 

HailstoneBuffer:

 

{{out}}

 

=={{header|zkl}}==

This uses tail recursion and thus is stack efficient.

{{out}}

</pre>

Rather than write a function that calculates the length, just roll through all 100,000 sequences and save the largest (length,sequence start) pair. Creating all those Collatz lists isn't quick. This works by using a [mutable] list to hold state as the pump does the basic looping.

collatz, // generate Collatz sequence(n)

fcn(c,n){ // if new longest sequence, save length/C, return longest

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC_BASIC}}

20 GO SUB 1000

30 PRINT '"Sequence length = ";seqlen

1060 LET l=l+1

1070 GO TO 1020