## Inspired by randomness

Posted by Jonas Elfström Thu, 27 Oct 2011 21:19:00 GMT

Inspired by Randomly not so random I decided to play around with the subject.

Both Java and C# uses a linear congruential generator as their pseudorandom number generators.

The current implementation of the Random class is based on a modified version of Donald E. Knuth's subtractive random number generator algorithm."

I tried to find information on what values Microsoft uses for the m, a, and c parameters in their LGC implementation but I failed to do so.

A good random number generator should have certain properties.

The German Federal Office for Information Security (BSI) has established four criteria for quality of deterministic random number generators. They are summarized here:
K1 — A sequence of random numbers with a low probability of containing identical consecutive elements.

From the pseudorandom number generator article on Wikipedia. Let's see what we can do about that.

 ```1 2 3 4 5 ``` ```var random = new Random(116793166); for (int i = 0; i < 9; i++) { Console.Write(random.Next(10) + " "); }```

Outputs:

```1 1 1 1 1 1 1 1 1
```

Did I just break the K1 criteria above? You know I didn't but you might be interested in how I found the seed number. It's easy but also quite computational intensive, that's why I used Parallel.For.

 ```1 2 3 4 5 6 7 8 9 10 11 12 ``` ```Parallel.For(0, int.MaxValue, i => { var rnd = new Random(i); bool allSame = true; for (int j = 0; j < 9; j++) { allSame = allSame && rnd.Next(10) == 1; if (!allSame) break; } if (allSame) Console.WriteLine(i); });```

It took a couple of minutes for the number 116793166 to show up in my console.

To keep on playing I needed a random string generator. Mine looks like this.

 ```1 2 3 4 5 6 7 8 9 ``` ```private const string _chars = "abcdefghijklmnopqrstuvwxyz"; private static string RandomString(int size, Random rng) { var buffer = new char[size]; for (int i = 0; i < size; i++) buffer[i] = _chars[rng.Next(_chars.Length)]; return new string(buffer); }```

If the random generators were the same it looks like it should give the same result as the Java one but `RandomString(5, new Random(-229985452))` returns `tfsld`. Either my RandomString method works different than the Java one or it's the case that Java and .NET has slightly different settings of their LGCs.

Mathematically there's an infinite amount of inputs that results in a returned `hello`, for instance 1382472294, but here we are limited by the size of our integers.

I found the seed 1382472294 with the following little method and loop

 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ``` ```private static bool CompareToRandomString(string str, Random rng) { for (int i = 0; i < str.Length; i++) { if (_chars[rng.Next(_chars.Length)] != str[i]) return false; } return true; } ... const string lookingFor = "hello"; Parallel.For(0, int.MaxValue, i => { var rnd = new Random(i); if (CompareToRandomString(lookingFor, rnd)) Console.WriteLine(i); });```

I leave it up to you to implement a break out of that loop.

Ruby does not use a LGC but a Mersenne twister instead. It's still only pseudorandom so there's no problem finding patterns you like and being able to repeat them.

 ```1 2 ``` ```srand(2570940381) 9.times { print "%d " % rand(10) }```

Outputs:
`1 2 3 4 5 6 7 8 9`

 ```1 2 3 ``` ```charset=('a'..'z').to_a srand(124931) puts (0...4).map{ charset.to_a[rand(charset.size)] }.join```

Outputs:
`ruby`

Posted in Ruby, C#, Math, Java | 1 comment