Is writing a quine just too easy for you? Then try your hand at the following simple programming challenge.

Write a short program that takes at least one hour of computational time (this can be a parameter if you want) to produce some interesting output. Pre-canned output is not interesting, nor does it take one hour to generate.

On what hardware? Which languages are allowed? Define "interesting"? Otherwise, this Python program, complete with comments, will test the Collatz conjecture on every positive integer above and including the input, and print out the sequence obtained. If the conjecture is true, you'll never get into a cycle since the sequence function will always return. As Python has built-in arbitrary precision arithmetic, runtime is essentially infinite. I think the output is pretty damn interesting if you let it run long enough! Enjoy...

[source lang="python"]# Prints the Collatz sequence for p
def Collatz(p):
# Print the initial number
print(p)

# Terminate when 1 is reached
while p != 1:
# If p is even, p -> p / 2
# Otherwise, p -> 3p + 1
if (p % 2 == 0):
p = p // 2
else:
p = 3 * p + 1

# Print the new number
print(p)

def ShurcoolChallenge(p):
if (p < 1):
print("Nice try.")
return

while True:
print("### " + str(p) + " ###")
Collatz(p)
print("")
p += 1
[/source]

Sample output:

[spoiler]
### 181 ###
181
544
272
136
68
34
17
52
26
13
40
20
10
5
16
8
4
2
1
### 182 ###
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[/spoiler]

Test of randomness!


#include <ctime>
#include <cstdlib>
#include <iostream>
int main() {
time_t startSeconds = time(0);
time_t maxRunningTime = 3601;
int maxValue = 7;
int innerLoopCount = 1000000;

srand(startSeconds);

int lastRand = rand() % (maxValue + 1);
int currentSeq = 1;
int maxSeq = 1;
long long iterationCount = 0;
for(; time(0) < startSeconds + maxRunningTime; ) {
for(int i = 0; i < innerLoopCount; ++i) {
int nextRand = rand() % (maxValue + 1);
if(nextRand == lastRand)
++currentSeq;
else {
maxSeq = std::max(currentSeq, maxSeq);
lastRand = nextRand;
currentSeq = 1;
}
}
iterationCount += innerLoopCount;
}

std::cout << "Longest sequence of equals in " << iterationCount << " numbers in [0, " << maxValue << "]: " << maxSeq << std::endl;

return 0;
}


simple cellular automata generator

using "babaabab" as the argument gives a nice pseudorandom output and you'll see triangle forms of 'b's appear in the chaos
"abbaabba" will also produce right-triangles, but with 'a's
"abbabbab" will produce clustered triangle 'b's


using System;
using System.Threading;
namespace TimedComp
{
class MainClass
{
public static void Main (string[] args)
{
Foo foo = new Foo();

foo.run(args);
}
}

class Foo
{
private static bool RUN = true;

private string prev = "",cur = "";

private int colLim = 80;

private Timer timer;

public void run(string[] args)
{
timer = new Timer(this.OnTick,null,1000*3600,0);

prev = "aaaaaabaaaaaa";
while(RUN)
{
for(int i = 0; i < prev.Length; i++)
{
if(i+1 > prev.Length-1)
{
cur += prev[prev.Length-1];
break;
}

if(i > 0){

string str = "" + prev[i-1] + prev + prev[i+1];

if(str == "aaa")
cur = cur.Insert(i,""+args[0][0]);

if(str == "aab")
cur = cur.Insert(i,""+args[0][1]);

if(str == "aba")
cur = cur.Insert(i,""+args[0][2]);

if(str == "abb")
cur = cur.Insert(i,""+args[0][3]);

if(str == "baa")
cur = cur.Insert(i,""+args[0][4]);

if(str == "bab")
cur = cur.Insert(i,""+args[0][5]);

if(str == "bba")
cur = cur.Insert(i,""+args[0][6]);

if(str == "bbb")
cur = cur.Insert(i,""+args[0][7]);
}
else
{
string str = "" + prev + prev[i+1];

if(str == "aa")
cur = cur.Insert(i,""+args[0][0]);

if(str == "ab")
cur = cur.Insert(i,""+args[0][1]);

if(str == "ba")
cur = cur.Insert(i,""+args[0][2]);

if(str == "bb")
cur = cur.Insert(i,""+args[0][3]);
}
}
prev = cur.Substring(0, cur.Length > colLim ? colLim : cur.Length);
Console.WriteLine(prev);
}
}

private void OnTick(object obj)
{
RUN = false;
}

}
}



here is some sample output of abbabbab with one triangle highlighted:

bbbbabbbbbbbababbbbbbbabababababbbbbbbbbbbabbbbbbabababbbbbbbabbbbbbababbbabaaba
abbababbbbbabbbabbbbbabbbbbbbbbabbbbbbbbbababbbbabbbbbabbbbbababbbbabbbababbbbbb
baabbbabbbababababbbababbbbbbbababbbbbbbabbbabbababbbababbbabbbabbabababbbabbbba
bbbababababbbbbbbababbbabbbbbabbbabbbbbabababaabbbababbbababababaabbbbbabababbab
ababbbbbbbabbbbbabbbabababbbababababbbabbbbbbbbababbbababbbbbbbbbbabbbabbbbbaabb
bbbabbbbbababbbabababbbbbababbbbbbbabababbbbbbabbbababbbabbbbbbbbababababbbabbaa
abababbbabbbababbbbbabbbabbbabbbbbabbbbbabbbbabababbbabababbbbbbabbbbbbbababaabb
bbbbbababababbbabbbababababababbbababbbababbabbbbbababbbbbabbbbababbbbbabbbbbbaa
abbbabbbbbbbababababbbbbbbbbbbababbbababbbaababbbabbbabbbababbabbbabbbababbbbabb
babababbbbbabbbbbbbabbbbbbbbbabbbababbbababbbbababababababbbaabababababbbabbabaa
bbbbbbabbbababbbbbababbbbbbbabababbbababbbabbabbbbbbbbbbbababbbbbbbbbbababaabbbb
abbbbabababbbabbbabbbabbbbbabbbbbababbbababaababbbbbbbbbabbbabbbbbbbbabbbbbbabbb
babbabbbbbabababababababbbababbbabbbababbbbbbbbabbbbbbbababababbbbbbababbbbababa
bbaababbba[color=#ff0000]bbbbbbbbbbbbbababbbababababbbabbbbbbababbbbbabbbbbbbabbbbabbbabbabbbbb
aabbbbababa[color=#ff0000]bbbbbbbbbbbabbbababbbbbbbabababbbbabbbabbbababbbbbababbabababaababbbb
ababbabbbbba[color=#ff0000]bbbbbbbbbabababbbabbbbbabbbbbabbabababababbbabbbabbbaabbbbbbbbbbabba
bbbaababbbaba[color=#ff0000]bbbbbbbabbbbbabababbbababbbabaabbbbbbbbbababababababbabbbbbbbbabaaa
ababbbbababbba[color=#ff0000]bbbbbababbbabbbbbababbbababbbbabbbbbbbabbbbbbbbbbbaababbbbbbabbbab
bbbabbabbbababa[color=#ff0000]bbbabbbabababbbabbbababbbabbababbbbbababbbbbbbbbabbbbabbbbabababa
ababaabababbbbba[color=#ff0000]babababbbbbababababbbababaabbbabbbabbbabbbbbbbababbababbabbbbbbb
bbbbbbbbbbabbbabbbbbbbabbbabbbbbbbababbbbbbabababababababbbbbabbbaabbbaababbbbba
abbbbbbbbababababbbbbababababbbbbabbbabbbbabbbbbbbbbbbbbabbbabababbababbbbabbbab
babbbbbbabbbbbbbabbbabbbbbbbabbbababababbababbbbbbbbbbbabababbbbbaabbbabbabababa
bbabbbbababbbbbababababbbbbabababbbbbbbaabbbabbbbbbbbbabbbbbabbbabbababaabbbbbbb
aababbabbbabbbabbbbbbbabbbabbbbbabbbbbabbabababbbbbbbababbbabababaabbbbbbabbbbbb
abbbaababababababbbbbababababbbababbbabaabbbbbabbbbbabbbababbbbbbbbabbbbababbbba
bababbbbbbbbbbbbabbbabbbbbbbababbbababbbbabbbababbbabababbbabbbbbbababbabbbabbaa
bbbbabbbbbbbbbbababababbbbbabbbababbbabbabababbbababbbbbabababbbbabbbaabababaabb
abbababbbbbbbbabbbbbbbabbbabababbbababaabbbbbababbbabbbabbbbbabbabababbbbbbbbbab
baabbbabbbbbbababbbbbabababbbbbababbbbbbabbbabbbabababababbbabaabbbbbabbbbbbbaba
bbbabababbbbabbbabbbabbbbbabbbabbbabbbbabababababbbbbbbbbababbbbabbbababbbbbabbb
ababbbbbabbababababababbbababababababbabbbbbbbbbabbbbbbbabbbabbabababbbabbbababb
bbbabbbabaabbbbbbbbbbbababbbbbbbbbbbaababbbbbbbababbbbbabababaabbbbbababababbbaa
ababababbbbabbbbbbbbbabbbabbbbbbbbbabbbbabbbbbabbbabbbabbbbbbbbabbbabbbbbbbababb
bbbbbbbabbababbbbbbbababababbbbbbbababbababbbababababababbbbbbababababbbbbabbbaa
abbbbbabaabbbabbbbbabbbbbbbabbbbbabbbaabbbababbbbbbbbbbbabbbbabbbbbbbabbbabababb
babbbabbbbabababbbababbbbbababbbabababbababbbabbbbbbbbbababbababbbbbabababbbbbaa
bbabababbabbbbbababbbabbbabbbababbbbbaabbbabababbbbbbbabbbaabbbabbbabbbbbabbbabb
aabbbbbaababbbabbbababababababbbabbbabbababbbbbabbbbbabababbabababababbbabababab

sample output of abbaabba with one triangle highlighted:

bbabaaabbbbbbaaabbaabbababaaabaabaaabbbbbaabbaabbabbababbbababaaabababbbbbabbbab
abbbaabaaaaabaababababbbbbaabbabbaabaaaabababababbabbbbaabbbbbaabbbbbaaaabbaabbb
baababbaaaabbabbbbbbbaaaabababbababbaaabbbbbbbbbabbaaababaaaababaaaabaaabababaaa
babbbabaaababbaaaaaabaaabbbbbabbbbabaabaaaaaaaabbabaabbbbaaabbbbaaabbaabbbbbbaab
bbaabbbaabbbabaaaaabbaabaaaabbaaabbbabbaaaaaaababbbabaaabaabaaabaabababaaaaababb
ababaababaabbbaaaabababbaaababaabaabbabaaaaaabbbaabbbaabbabbaabbabbbbbbaaaabbbab
bbbbabbbbabaabaaabbbbbabaabbbbabbababbbaaaaabaababaabababbabababbaaaaabaaabaabba
aaabbaaabbbabbaabaaaabbbabaaabbabbbbaabaaaabbabbbbabbbbbabbbbbbabaaaabbaabbababb
aababaabaabbababbaaabaabbbaababbaaababbaaababbaaabbaaaabbaaaaabbbaaababababbbbaa
abbbbabbababbbbabaabbabaababbbabaabbbabaabbbabaababaaababaaaabaabaabbbbbbbaaabaa
baaabbabbbbaaabbbababbbabbbaabbbabaabbbabaabbbabbbbaabbbbaaabbabbabaaaaaabaabbaa
baababbaaabaabaabbbbaabbaababaabbbabaabbbabaabbaaababaaabaababbabbbaaaaabbababab
babbbabaabbabbabaaababababbbbabaabbbabaabbbababaabbbbaabbabbbabbaabaaaababbbbbbb
bbaabbbababbabbbaabbbbbbbaaabbbabaabbbabaabbbbbabaaabababbaabbababbaaabbbaaaaaab
ababaabbbbabbaababaaaaaabaabaabbbabaabbbabaaaabbbaabbbbbabababbbbabaabaabaaaaabb
bbbbabaaabbababbbbaaaaabbabbabaabbbabaabbbaaabaababaaaabbbbbbaaabbbabbabbaaaabaa
aaabbbaababbbbaaabaaaababbabbbabaabbbabaabaabbabbbbaaabaaaaabaabaabbabbabaaabbab
aabaababbbaaabaabbaaabbbabbaabbbabaabbbabbababbaaabaabbaaaabbabbababbabbbaababba
abbabbbaabaabbababaabaabbababaabbbabaabbabbbbabaabbababaaababbabbbbabbaababbbaba
babbaababbababbbbbabbababbbbbabaabbbababbaaabbbababbbbbaabbbabbaaabbababbbaabbba
bbababbbabbbbaaaabbabbbbaaaabbbabaabbbbabaabaabbbbaaaababaabbabaababbbbaababaabb
abbbbaabbaaabaaababbaaabaaabaabbbabaaabbbabbabaaabaaabbbbababbbabbbaaababbbbabab
baaabababaabbaabbbabaabbaabbabaabbbaabaabbabbbaabbaabaaabbbbaabbaabaabbbaaabbbba
baabbbbbbabababaabbbababababbbabaababbababbaababababbaabaaababababbabaabaabaaabb
babaaaaabbbbbbbabaabbbbbbbbaabbbabbbabbbbababbbbbbbababbaabbbbbbbabbbabbabbaabab
bbbaaaabaaaaaabbbabaaaaaaababaabbaabbaaabbbbaaaaaabbbbababaaaaaabbaabbabbababbbb
aabaaabbaaaaabaabbbaaaaaabbbbababababaabaaabaaaaabaaabbbbbaaaaababababbabbbbaaab
abbaababaaaabbabaabaaaaabaaabbbbbbbbbabbaabbaaaabbaabaaaabaaaabbbbbbbabbaaabaaba
bababbbbaaababbbabbaaaabbaab[color=#ff0000]aaaaaaaabbabababaaabababbaaabbaaabaaaaaabbabaabbabba
bbbbaaabaabbbaabbabaaabababb[color=#ff0000]aaaaaaababbbbbbbaabbbbbabaababaabbaaaaababbbababbabb
aaabaabbabaabababbbaabbbbbab[color=#ff0000]aaaaaabbbaaaaaababaaaabbbabbbbababaaaabbbaabbbbabbab
aabbababbbabbbbbaababaaaabbb[color=#ff0000]aaaaabaabaaaaabbbbaaabaabbaaabbbbbaaabaababaaabbabba
ababbbbaabbaaaababbbbaaabaab[color=#ff0000]aaaabbabbaaaabaaabaabbababaabaaaabaabbabbbbaababbaba
bbbaaabababaaabbbaaabaabbabb[color=#ff0000]aaababbabaaabbaabbababbbbbabbaaabbababbaaababbbabbba
aabaabbbbbbaabaabaabbababbab[color=#ff0000]aabbbabbbaababababbbbaaaabbabaababbbbabaabbbaabbaabb
abbabaaaaababbabbababbbbabbb[color=#ff0000]abaabbaababbbbbbbaaabaaababbbabbbaaabbbabaababababaa
babbbaaaabbbabbabbbbaaabbaabbbabababbbaaaaaabaabbaabbbaabbaabaabaabbbabbbbbbbbaa
bbaabaaabaabbabbaaabaabababaabbbbbbaabaaaaabbabababaababababbabbabaabbaaaaaaabab
ababbaabbababbabaabbabbbbbbabaaaaababbaaaababbbbbbbabbbbbbbabbabbbababaaaaaabbbb

Im not sure if mine meets the initial criteria 100% though, as my sample will start producing this output almost instantly, however the pseudorandomness of some of the rules you can give it will make the output fairly unique during each calculated row, so to get the output at the hour mark takes running it for an hour (assuming same number of rows were created).

On what hardware? Which languages are allowed? Define "interesting"?

A typical current Core i7 laptop.
Any language you like.
Interesting is something that, after the hour passes, you are excited to see the results.

It would help to post some sample output of your programs, if possible.

I'm still trying to come up my own entry to this challenge... But great stuff so far.

Test of randomness!

I ran your program for an hour, and got this output:

Longest sequence of equals in 17736331274 numbers in [0, 1000000]: 2

I ran it again for 3 minutes, and got this ouput:

Longest sequence of equals in 862139850 numbers in [0, 1000000]: 2

My bad, way too high a number for the max value.
I edited it to 7 and added an inner loop to make it count faster.

The idea is to see how many times you get the same result in a row if you roll a dice an insane number of times.
So if you have 1/8 chance of rolling a 1, then you should have a 1/64 to roll two 1s in a row etc.

Running the new version for 30 sec, I get 1.4 billion numbers in 30 sec, and a longest sequence of equals of 6, which is the exact same result I get for the only 11 million numbers my computer counts in 1 second.

In other words, rand() % 8 is not all too good at actually being random for long sequences, as it seems the algorithm can never(?) get past a sequence of 6 equal rolls.

My bad, way too high a number for the max value.
I edited it to 7 and added an inner loop to make it count faster.

The idea is to see how many times you get the same result in a row if you roll a dice an insane number of times.
So if you have 1/8 chance of rolling a 1, then you should have a 1/64 to roll two 1s in a row etc.

Running the new version for 30 sec, I get 1.4 billion numbers in 30 sec, and a longest sequence of equals of 6, which is the exact same result I get for the only 11 million numbers my computer counts in 1 second.

In other words, rand() % 8 is not all too good at actually being random for long sequences, as it seems the algorithm can never(?) get past a sequence of 6 equal rolls.

you should try some other random systems, and even if possible, use intel's hardware RNG for near true randomness, it'd be interesting to compare the results between diffrent pseudo random number generator algo's, and hardware based random number generators.

you should try some other random systems, and even if possible, use intel's hardware RNG for near true randomness, it'd be interesting to compare the results between diffrent pseudo random number generator algo's, and hardware based random number generators.

Good idea! I tried it with Intel's RdRand, and got a longest sequence of 10 in 1 billion numbers in [0, 7]. It was also 10 after 6 billion numbers.. which shouldn't be all too unlikely for true randomness.. I'll try another time to run it through many more numbers. I'm not sure if cryptographically secure means truly random though.. the docs says it has true random seeds, but can yield up to 500 values or so in between seeds. For true randomness only using the seeds might be better.

I don't know enough statistics to say whether this test is fair or exactly what it means though..

One interesting test is to set a max value of 1, and just get random bits, a coin toss instead of a dice roll.
32 coin tosses can be done either by 32 rands and picking the last single bit from each, or by taking the 32 bits from one 32-bit random number. If it's actually 100% true randomness I guess they should yield the same probabilities.. and a 2 in 4 billion chance to hit the same value 32 times in a row..

I tested it for rand. Using only the last bit, I get a max sequence of 15 no matter how long I run it.
For me RAND_MAX is 32767, so 15 random bits per number. Using all the bits as 15 different numbers I get a total max sequence of 34 of the same bits when running it for 140 million numbers.. which obviously seems way unlikely.

Another thought.. rand() probably loops when it goes past some number of calls.. perhaps 2^32?

I'm not sure if cryptographically secure means truly random though

It's about as close as it gets.

Another thought.. rand() probably loops when it goes past some number of calls.. perhaps 2^32?[/quote]
I think 2^48 or 2^64 now... 2^32 would be far too small (but it doesn't matter, successive outputs are still strongly correlated since it's most likely an LCG).