Collatz[1] = 1;

Collatz[n_] := If[EvenQ[n], n/2, 3 n + 1];

DoCollatz[n_] := (Print[Length[#] - 1, ” steps: “, #, “\n”]) &@ FixedPointList[Collatz, n]

(* so typing in DoCollatz[27] spits out the sequence starting at 27; DoCollatz /@ Range[1,200] spits out results for 1 through 200 *)

(* You can hash the results, using

Collatz[n_] := Collatz[n] = If[EvenQ[n], n/2, 3 n + 1];

*)

#!/usr/bin/perl
#
#
my $num = 27;
my $count = 0;
my $test3 = 0;

until( $test3 == 1 )
{
print “$count number is: $num\n”;

if($num eq 1)
{
$test3 = 1;
}
#get last digit if even divide by 2
if(!($num % 2))
{
$num = $num / 2;
}
#if not multiply by 3 and add 1
else
{
$num = (($num * 3) + 1)
}
$count++;
}

Will We Run Out Of Social Security?

I’m less surprised we rank highly for

Will We Run Out Of Social Security Numbers

Glad we’re contributing to this important discourse!! But while you’re here, please look around…

————-
#!/usr/bin/env python

def collatz(start):
    '''
    Run through the collatz series for a given number and return the number of
    iterations and the largest number found.
    '''
    current = start
    iter = 0
    max = start
    while current != 1:
        iter += 1
        if current % 2: # odd
            current = current * 3 + 1
        else: # even
            current = current / 2
        if current > max:
            max = current
    return (iter, max)

if __name__ == "__main__":
    target = 1000
    max_tuple = (0, 0, 0)
    iter_tuple = (0, 0, 0)
    for start in xrange(1, target + 1):
        (iter, max) = collatz(start)
        if max > max_tuple[2]:
            max_tuple = (start, iter, max)
        if iter > iter_tuple[1]:
            iter_tuple = (start, iter, max)
    print 'Largest integer hit:', max_tuple
    print 'Longest series hit:', iter_tuple
————-

I planned to create more graphical representations that may help “discover” a patter or at least look pretty :)

Anyway…
You can pick it up from
http://www.softwareriver.com/download/orderlychaos.zip

You only need to have .NET 2.x on your computer and it should run. Select the number of cards, players and select start.
You will then see a graphical representation of each tag as a line for each player.
The player with no cards will have an empty line - the player with all cards will have the full line for that tag (row).
Starting player is colored blue.

If the “graph” cannot fit in your window a red line will show up indicating that there is more so try to resize your window.

Have fun!

There are 53 ways to divide the cards between two people. Only 7 of those ways are on the good loop. You don’t want to end up in the other 46.

(It is only 7 and not 14, right? because it matters who is dealing…)

It looks like the demand for numbers on the internet (for auctions, for indexing photos, etc) is running very high.

And some folks are really hogging up numbers, listing all the primes and other wasteful practices.

This will just get worse as time goes by!!

I’d love to see a systematic search done. For the moment, this is what I came up with. I’ll use something like Ken’s trick above to keep google at bay.

Two3001293Eight

Two0331125Six

Common differences for k cards after k-1 players for 2->15 cards

1, 2, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 16, 16

The non technical reason I presume is that once there are k-1 players, the cards have enouh room to go around without overlapping. Then, adding more players just increases the number of times one card has to travel around the table. Since the common differences all seem to be powers of two this might say something about how many times the cards travel all the way around the table (adding one more player increases the number of turns by one each time we go around the table, so increasing my some power of two indicates a number of times around)

The main conclusion is that the cycle length is chaotic only for k cards and p<k-1 players.