I decided to write a program which would output the HailStone sequence defined by the previous exercise, using BF. Well, almost. I actually used Procedural BF (pBrain for short) which slightly extends the instruction sets to add capability to define and call functions in 3 additional instructions. You can read more about pBrain at http://www.parkscomputing.com/code/pbrain/. To simplify my work, I made a couple of assumptions. The user input of the starting number must be between 01 and 99, always entered as two characters with a leading zero. The output will always be displayed as a 3 digit number with leading zeros. This touring machine has an 8-bit memory, so no single number within the sequence must exceed 255.

Without further ado, here is my Touring Machine (with procedural enhancements) implementation of a HailStone sequence. There are plenty of comments in the code. Frankly, I needed them to keep myself sane. Of course, the nice side effect of the comments is that everyone should be able to understand what is going on. As an example, when run with an input like 07, the output is 007 022 011 034 017 052 026 013 040 020 010 005 016 008 004 002 001

/**************************************/
/* HAILSTONE SEQUENCE PROGRAM */
/* in pBrain */
/**************************************/

// Memory map
// 0: ASCII_MSB
// 1: ASCII_LSB
// 2: User_Input
// 3: R1
// 4: R2
// 5: R3
// 6: R4
// 7: R5
// 8: R6
// 9: R7
// A: R8
// B: R9
// C: R10
// D: R11
// E: R12
// F: R13
// 10: R14
// 11: R15
// 12: R16

/**************************************/
/* Function 1 - Convert ASCII(n) to integer N by subtracting 6*8=ASCII(0) */
/* Input: @(-1) - the ASCII value of n */
/* Output: @(-1) - the integer value N */
/* Local: @(+1) and @(+2) */
+(
// loop 6*8 times, decrementing @(-1)
>++++++++[
>++++++[
<<<-
>>>-
]<-
]

// Exit with calling register set back to zero
<-
)

/*************************************/
/* Function 2 - Divide A/B */
/* Input: @(-2) - Divident A */
/* Input: @(-1) - Divisor B */
/* Local: @(+1) - Copy of dividend */
/* Local: @(+2) - Copy of dividend */
/* Local: @(+3) - Remainder */
/* Local: @(+4) - Copy of divisor */
/* Local: @(+5) - Quotient */
/* Local: @(+6) - Zero */
/* Local: @(+7) - Zero */
/* Output: @(+5) - Quotient */
/* Output: @(+3) - Remainder */
+(
// make sure the local variables are zero'd out
>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<
// copy dividend to @(+1) and @(+2) destroying @(-2)
<<[>>>+>+<<<<-]
// copy divisor to @(+4) destroying @(-1)
>[>>>>>+<<<<<-]

// point to first copy of dividend and start division
>>
[
>+>+>-[>>>]
<[[>+<-]>>+>]
<<<<<-
]

// Exit with calling register set back to zero
<--
)

/**************************************/
/* Function 3 - display integer 0-255 as ASCII */
/* Input: @(-1) - the ASCII value of n */
/* Local: @(+1), @(+2), @(+3) - ASCII result */
/* Local: @(+4) through @(+13) - used in division */
+(
// Make sure that we start with a clean slate for internal output registers
[-]>[-]>[-]>[-]

// Figure out the 100's digit.
// Copy number to divident
<<<<[>+>>>>+<<<<<-]>[<+>-]
// Set divisor to 10*10=100
>>>>>>++++++++++[>++++++++++[<<+>>-]<-]<
// Call division function
>++:
// Process results of division
>>>>>
[
// Copy quotient into MSB
<<<<<<<<+
// subtract quotient*100 from number
>++++++++++ [>++++++++++ [<<<<<<->>>>>>-]<- ]
>>>>>>>-
]
// Convert to ascii by adding 6*8=48
<<<<<<[-]<[-]++++++ [ >++++++++ [<<+>>-]<- ]

// Figure out the 10's digit
>>>[-]<[-]<[-]
// Copy number to divident
<<<<<<[>+>>>>+<<<<<-]>[<+>-]
// Set divisor to 2*5=10
>>>>>>++[>+++++[<<+>>-]<-]<
// Call division function
>++:
// Process results of division
>>>>>
[
// Copy quotient into Middle digit
<<<<<<<<<+
// subtract quotient*10 from number
>>++ [ >+++++ [<<<<<<->>>>>>-]<- ]
>>>>>>>-
]
// Convert to ascii by adding 6*8=48
<<<<<<[-]<[-]++++++ [ >++++++++ [<<<+>>>-]<- ]

// Copy the remainder (1's digit) into LSB
>>>>>[<<<<<<<<+>>>>>>>>-]
// Convert to ascii by adding 6*8=48
<<<<[-]<[-]++++++ [ >++++++++ [<<<<+>>>>-]<- ]

// Display the number with a space after it
<.<.<.[-]>[-]>[-]< ++++ [ >++++++++ [<<+>>-]<- ] <.

// exit with calling register set to zero
<[-]
)

/**************************************/
/**************** MAIN ****************/
// Get user input for MSB and LSB stored in @ASCII_MSB and @ASCII_LSB
,>,

// Move @ASCII_MSB to R1
<[>>>+<<<-]
// Call Func1 from R2, using R1 as arg1, R3 and R4 as local vars
>>>>+:

// Move @ASCII_LSB to R2
<<<[>>>+<<<-]
// Call Func1 from R3, using R2 as arg1, R4 and R5 as local vars
>>>>+:

// @User_Input = R1*10 + R2, destroying R1, R2 contents
<<[<++++++++++>-]
>[<<+>>-]

// Copy @User_input to R1 using R2
// Display R1 by calling Func3 from R2, using R3-R16 as local vars
<< [>+>+<<-] >>[<<+>>-] +++:

// While @User_Input != 1
<<-
[
// Copy @User_Input to R1, using R2, set R2 to two
+>[-]<[>+>+<<-]>>[<<+>>-]++
// Call Func2 from R3, using R1 and R2 as arg1 and arg2, and R4-R10 as local vars
>[-]++:

// Test R6 (remainder) to see if it's Zero, use R7 for starting else clause
>>>>[-]+<
[
// Remainder is not Zero, must have been an odd number
// @user_Input = 3*@User_input + 1
<<<<<[-]<[>+++<-]>+[<+>-]
// Set remainder and R7 to zero to skip else clause
>>>>>>-<-
]
>
[
// Remainder is Zero, must have been an even number
// Copy R8 (quotient) to @User_input
<<<<<<<[-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<[-]
]

// Copy @User_input to R1 using R2
// Display R1 by calling Func3 from R2, using R3-R16 as local vars
<<<<<<< [>+>+<<-] >>[<<+>>-] +++:

// Test if @User_Input == 1
<<-
]

def find(M, key):
    cols = len(M[0])
    def f(i, j):
        if i < 0 or j >= cols:
            return False
        if key < M[i][j]:
            return f(i - 1, j)
        if key > M[i][j]:
            return f(i, j + 1)
        return True
    return f(len(M) - 1, 0)

m = [[1, 5, 7, 9], [4, 6, 10, 15], [8, 11, 12, 19], [14, 16, 18, 21]]

# Tests:
solve(m, 9)        # True
solve(m, 12)      # True
solev(m, 21)      # True
solve(m, 1000)  # False
solve(m, 17)      # False

#!/usr/bin/apple1basic
1 REM February 21, 2012 11:25 PM
100 PRINT “ENTER THE NUMBER”
200 INPUT N
300 PRINT N
310 IF N = 1 THEN END
410 IF (N/2)*2 = N THEN GOTO 600
500 REM EVEN NUMBER
510 N = 3 * N +1
530 GOTO 300
600 REM ODD NUMBER
610 N = N /2
630 GOTO 300
900 END

new-host-4:Apple BASIC shankara_c$ apple1basic hailstone.bas
ENTER THE NUMBER
?13
13
40
20
10
5
16
8
4
2
1

#!/usr/bin/apple1basic
100 PRINT “ENTER THE NUMBER”
200 INPUT N
300 REM * HOLDS SUM OF DIVISORS
310 LET S = 0
400 REM * HOLDS NUMBER OF DIVISORS
410 LET D = 0
505 FOR I = 1 TO N
510 REM IF NOT EXACT DIVISIBLE NEXT NUMBER
600 IF (N/I)*I N THEN NEXT I
610 PRINT I
620 S = S + I: D = D + 1
700 NEXT I
800 PRINT “SUM = “;S,”NUMBER OF DIVISORS = “;D
900 END

static private int Hail(int x, IDictionary stones)
{
int result = 0;
var trail = new Stack();
while(x > 0)
{
if (stones.ContainsKey(x))
{
result = stones[x];
break;
}
else if (x > 1)
{
trail.Push(x);
x = (x%2) == 0 ? x >> 1 : x*3 + 1;
}
else // x = 1
{
result = stones[x] = 1;
break;
}
}

while(trail.Count > 0)
{
var key = trail.Pop();
stones[key] = ++result;
}

return result;

}

static private int RecursiveHail(int x, IDictionary stones)
{
if (x == 1)
{
stones[x] = 1;
}
else if (!stones.ContainsKey(x))
{
stones[x] = (x % 2 == 0) ?
1 + Hail(x >> 1, stones) :
1 + Hail(x * 3 + 1, stones);
}
return stones[x];
}

The problem seemed to scream “recursion”, and so it can be solved… up to a point, depending on your resources: this code runs in roughly 400ms on a particularly beefy 64-bit desktop with 16GB RAM and quad core, .Net 4.0
I’m going to see about being a bit less recursive but still performant:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace Hailstone
{
class Program
{
static void Main(string[] args)
{
var maxValue = 100000;
IDictionary stones = new SortedDictionary();
var stopwatch = new Stopwatch();
stopwatch.Start();
//Enumerable.Range(1, maxValue).AsParallel().ForAll(i =>
// {
// _stones[i] = Hail(i);
// });

foreach (var i in Enumerable.Range(1, maxValue))
{
if (!stones.ContainsKey(i))
{
stones[i] = Hail(i, stones);
}
}

var byValue = stones.OrderBy(kv => kv.Value).ToDictionary(kv => kv.Key, kv=>kv.Value);
stopwatch.Stop();
Console.WriteLine(stopwatch.Elapsed);
}

static private int Hail(int x, IDictionary stones)
{
if (x == 1)
{
stones[x] = x;
}
else if (!stones.ContainsKey(x))
{
stones[x] = (x % 2 == 0) ?
1 + Hail(x >> 1, stones) :
1 + Hail(x*3 + 1, stones);
}
return stones[x];
}
}
}