Random with your hands tied [closed]

Question

Pretty simple fun golf here, most votes win, 1 week from initial post.

develop some code to generate a random number between X and Y (taken as input) without using ANY random generating seeds, pre-written randoms, or external source to generate the random. obviously its only possible to have a psuedo random, but come up with something as close as you possibly can get, explain why/how it works, and whoever gets the most upvotes for a new, innovative, out of the box, idea, wins.

pretty simple?

Answer 1

C

not sure if the volatile keyword is needed (or what other OS dependencies are assumed here)

simply takes the address of a variable, and maps it to [min, max]:

int rand(int min, int max)
{
  volatile int order = max - min + 1;
  return min + (int)&order % order;
}

Answer 2

Perl

First, here is a solution that was golfed, coming in at 30 characters:

$a=<>;$b=<>;print$$%($b-$a)+$a

This solution uses the process number of the program as the random seed, similar to using the location of the variables as a seed. It works the best when the min and max are small compared to the process number.

Here is a version that uses command line arguments, with 36 chars:

 print$$%($ARGV[1]-$ARGV[0])+$ARGV[0]

And here is a version as a subroutine that returns the random value (without printing to screen), with 29 chars:

 sub a{$$%($_[1]-$_[0])+$_[0]}

Second, I am working on a solution that adheres to the strictest reading of the spec, which is that the program cannot be influenced by anything except the two arguments.

Answer 3

Python

import sha
R=lambda x,y:x+int(sha.new('%d_%d'%(x,y)).hexdigest(),16)%(y-x)

Answer 4

JavaScript

function getRandom(x,y) {
    s=document.createElement("SCRIPT");
    s.src="http://search.twitter.com/search.json?q=%22random%22&&callback=t"
    document.getElementsByTagName("HEAD")[0].appendChild(s);
    var c = 0;
    window.t=function (d) {
        g=d.results;
        for(z=0; z<g.length; z++) {
            c+=g[z].id/0xfff;
        }
        console.log(x+c%(y-x))
    };
}

This is pretty disgusting really. Queries Twitter, via the JASONP API, for recent tweets containing the word "random", then it uses the ID's of each of the returned tweets to calculate the "random" number.

You might want to wait a few seconds in between each call of the function, also it doesn't return a value, it just outputs one to the console. (Told you it was disgusting).

You can try it here.

Answer 5

Python 2.x, 454

z=lambda n,b:int("0b"+(bin(n)[2:][:-b]or'0'),2)
r=range
g=624
def m(s,t):
 a=[s]
 for i in r(1,g): a+=[1812433253*((a[i-1]^(a[i-1]>>30))+i)]
 for i in r(t):
    i%=g
    if not i:
        q=0
        for c,d in zip(a,a[1:]+[a[0]]):
            u=(z(c,1)+z(d%g,31))
            a[q]=a[(q+397)%g]^(u>>1)
            if u%2:a[q]^=2567483615
            q+=1
    y=a[i]^(a[i]>>11)
    y^=(y<<7&2636928640)
    y^=(y<<15&4022730752)
    y^=(y>>18)
    yield y

Mersenne twister algorithm. It can probably be golfed some more.

Usage:

>>> list(m(s, t))

Where s is the seed, and t is the number of numbers to generate.

Answer 6

Python, 32

Similar to ardnew's answer:

a,b=input()
print a+id(1)%(b-a)

Answer 7

Mathematica

Rationale

Pi is an irrational number. It decimal representation does not repeat.

I strongly suspect that it does not "favor" any of the base ten digits, 0...9, nor any numbers of length when one partitions the decimal into strings of d digits. This suspicion can later be informally checked using the code below.

Code

The following will select integers between the integers x and y, where x is less than y.
y need not have the same number digits as x. The routine will begin at the cth digit of Pi. At the end of the procedure, the counter will be at c + n.

ClearAll[f]
f[x_,y_,c_,n_]:=
  Module[{diff=y-x,d},
  d=Length[IntegerDigits[diff]];
  Cases[FromDigits/@Most[IntegerDigits[Round[N[Pi,c+n+1]10^(c+n-1)]]][[c;;c+n1]]~Partition~d,
  i_/; i>x-1 && i<y+1]]

Suppose we want to generate a large (> 3000000), pseudo-random list of integers between 7 and 78. Here is how to request it. I've estimated that we'll need to use about 10^7 digits of Pi. We'll begin from position 1, that is, c=1.

(results= f[7,78,1, 10^7])//Timing

Note how the unsorted and untallied results maintain the order of Pi's digits: 314159... Note also that the result took just under 20 seconds. As we move further along, we'll encounter practical limits to how much we can process in a reasonable amount of time. But since this is merely an exercise in thinking out of the box, we'll ignore this limitation as we proceed.

Examining the results

When we tally and plot the results we see that Pi does not particularly favor any numbers in this range:

SortBy[Tally[results],First]

Notice that the integers between 7 and 78 were chosen more or less with equanimity. Further tests would show this holds up.

ListPlot[%]

Similar checks should show whether or not Pi plays favorites with any numbers at all, regardless of how many digits it holds. [I checked for 1, 2, and 3 digit numbers over tens of millions of draws and found no bias starting from the beginning of Pi. A rigorous check would require more systematic examination or theoretical insights.]