Interesting task using random numbers only

Question

Given any number of the random real numbers from the interval [0,1] is there exist any method to construct a floating point number with zero fractional part?

Your algorithm can use only random() function calls and no variables or constants. No constants and variables are allowed, no type casting is allowed. You can use for/while, if/else or any other programming language operands.

Answer 1

float random_float() {
     return random(); // POSIX random returns a long.
} //  I assume that's what OP means, no indication otherwise.

Considering that you didn't even specify that the returned floats are supposed to be random, much less what distribution they should have, I think this is the best we can do.

The above does contain a typecast, but there is no way to construct a floating-point number without either using a floating-point constant 0. or 1. or a value from a FP-valued function, which random is not.

To cheat a bit (this produces a different distribution and is rather unstable):

float random_float() {
     if ( random() < random() ) {
         return expf( float() ) + random_float();
     } else return expf( float() ); // expf(float()) just a fancy name for 1
}

By the way, actual real numbers are beyond the grasp of computers. Inputting one would take infinite time.

Answer 2

Best I've come up with so far: generate a list of N random numbers, multiply them all together, this will go to 0 (which has a 0 fractional part) when N is large enough.

OK, I used a variable (N), but I'm not sure how to use for loops or if statements without a variable or constant.

If I had more time and the inclination I expect that I could prove that the product of N floats (or doubles) will go to 0 under IEEE arithmetic. As it is I played around with Matlab, and N == 800 seems sufficient.

EDIT: OP's insistence on avoiding all constants and variables leads me next to this solution:

random() * random() * random() * ...

I'll spare you all the other 797 calls to random. To all of you whose skulls split asunder at this mind-bogglingly ridiculous solution, may I point you to the question.

Lest you wonder or worry, I haven't a clue what random() returns in your language, here in my pseudocode it returns a floating-point number with as many bits as I wish (32, 64, 157 if I want) in the range [0,1] as required.

Answer 3

Here's a solution in Python:

from random import random

def positiverandom():
    return random() or positiverandom()

def zerofraction():
    return (positiverandom() == -positiverandom()) * random()

Usage example:

>>> zerofraction()
0.0

Answer 4

return ceil(random())

works.

If you allow only operators like +, -, *, sin you can prove that:

Every expression built using random variables from U[0,1] and arithmetic operations, using each random variable exactly once will represent an irrational number with probability 1.

Since your program must end with return expression it will be wrong (or won't halt) with probability 1.

Answer 5

 float random_float() {
     return 1.0;   /* chosen by random sphere roll, guaranteed to be random */
 }

Answer 6

Here we go!

<?php

random();

function random() {
    return 1.0;
}

As long as I can tell the story that 1.0 is quite correctly one of the random numbers in the interval [0, 1].

I did not use constants! My algorithm is the call to random(), not the implementation of random(). PHP just doesn't happen to have such a function so I had to make it myself, conveniently.

Answer 7

Bitwise AND the FP representations of all your real numbers together.

Answer 8

In Python:

>>> (-random() > random())*random()
0.0

But no doubt I'm going to be told that this violates some unwritten, yet-to-be-revealed condition of this bizarre problem.