Комп'ютери не з ніде створюють випадкові числа без основи, як, швидше за все, час є універсальною основою випадковості.

Я хочу, щоб ви створили код, який створює випадкові числа за допомогою цих правил:

• Час не дозволяється бути основою в будь-якій точці програми.
• Заздалегідь визначені випадкові / псевдовипадкові функції не допускаються.
• Згенеровані числа можуть бути в будь-якому діапазоні. Ну принаймні два різних цілих числа: D
• Цифри перегукуються.

JavaScript

Це було весело!

arr = []
index = 0

function init(seed) {
    index = 0
    arr[0] = seed
    for (var i = 1; i < 624; i ++) {
        arr[i] = (1812433253 * (arr[i-1] ^ (arr[i-1] >>> 30)) + i) | 0
    }
 }

function getNumber() {
    if (index == 0) generateNumbers()

    var y = arr[index]
    y ^= (y >>> 11)
    y ^= ((y << 7) & 2636928640)
    y ^= ((y << 15) & 4022730752)
    y ^= (y >>> 18)

    index = (index + 1) % 624
    return y
}

function generateNumbers() {
    for (var i = 0; i < 624; i ++) {
        var y = (arr[i] & 0x80000000) + (arr[(i+1) % 624] & 0x7fffffff)
        arr[i] = arr[(i + 397) % 624] ^ (y >>> 1)
        if (y % 2 != 0) arr[i] ^= 2567483615
    }
}

// let's get our seed now from the SE API
var x = new XMLHttpRequest()
x.open('GET', 'http://api.stackexchange.com/2.2/answers?pagesize=10&order=desc&sort=activity&site=stackoverflow&filter=!Sri2UzKb5mTfr.XgjE', false)
x.send(null)
// we've got the answer data, now just add up all the numbers.
// only 4 digits at a time to prevent too big of a number.
var seed = 0
var numbers = x.responseText.match(/\d{0,4}/g)
for (var i = 0; i < numbers.length; i++) seed += +numbers[i]

init(seed)
for (var i = 0; i < 10; i++) console.log(getNumber())

Я написав Twister Mersenne в JS. Тоді я зрозумів, що треба звідкись дістати насіння.

Отже, я вирішив отримати це від API обміну стеками! (Я міг би використовувати localStorageта збільшувати лічильник, але це не дивно.) Отже, я схопив 10 останніх найактивніших відповідей, а потім просто взяв кожні 4 або менше послідовних цифр у відповіді та додав їх.

Ці насіння завжди різні, оскільки переповнення стека постійно оновлюється (і моя квота продовжує зменшуватися!) Номери включають в себе ідентифікатори відповідей, ідентифікатори запитань, бали, кількість підрахунків / зменшення кількості рахунків, відповідність / ідентифікатори власника та дані обгортання (квота та таке ). На одному пробігу я потрапив 256845, потім 270495, а потім 256048і т.д. ....

Він записує до консолі 10 випадкових 32-бітних номерів, що доповнюють два. Вибірка зразка:

247701962
-601555287
1363363842
-1184801866
1761791937
-163544156
2021774189
2140443959
1764173996
-1176627822

Java

import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;

/**
 *
 * @author Quincunx
 */
public class NoTimeRandom extends Random {

    private AtomicLong seed;

    public NoTimeRandom() {
        byte[] ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        int seed1 = 1;
        for (byte b : ba) {
            seed1 += b;
        }

        ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        long seed2 = 1;
        for (byte b : ba) {
            seed2 += b;
        }

        seed = new AtomicLong(seed1 ^ seed2);
    }

    @Override
    protected int next(int bits) {
        long oldseed, newseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            newseed = (oldseed * 25214903917L + 11) & 281474976710655L;
        } while (!seed.compareAndSet(oldseed, newseed));

        return (int) (newseed >>> (48 - bits));
    }

    public static void main(String[] args) {
        Random r = new NoTimeRandom();

        for (int i = 0; i < 5; i++) {
            System.out.println(r.nextInt());
        }
    }

}

Чара в тому public NoTimeRandom(). Масиви, передані до рядків, можуть сплутати нових програмістів, оскільки числа випадкові. Приклад (для char[]: [C@4a8e91eb). nextМетод копіюється з java.util.Random.

Вибірка зразка:

134277366
467041052
-555611140
-1741034686
1420784423

Перевіримо ефективність цього rng:

У моїй відповіді на приблизну криву Белла , генерація даних, яку я використовував, залежить від хорошого rng. Давайте запустимо це з цим як rng. Вихід:

Так само, як я думав. Це досить паршивий rng.

С

Компілюйте прапор -pthread (або все, що використовує ваш компілятор).

#include <stdio.h>
#include <pthread.h>

#define m (unsigned long)2147483647
#define q (unsigned long)127773
#define a (unsigned int)16807
#define r (unsigned int)2836 

static unsigned long seed;
pthread_t t[20];
int lo, hi, done;

void *pseudorandom(void *id)
{
    while(done)
    {
        int test;
        hi = seed/q;
        lo = seed%q;
        test = a * lo - r * hi;
        if (test > 0) seed = test;
        else seed = test + m;
    }
}

main()
{
     int i;
     seed = 54321;
     done = 1;

     for(i = 0; i < 20; i++) 
     {
          pthread_create(&(t[i]), NULL, &pseudorandom, NULL);
     }

     for (i = 0; i < 10; i++) 
     {
          printf("%lu\n", seed);
     }

     done = 0;
}

Я не впевнений, чи відповідає це чи ні на основі стандарту "час не дозволений", оскільки він в основному використовує планувальник як джерело ентропії шляхом навмисного ігнорування безпеки потоку. Він працює за допомогою досить основної псуедо-випадкової функції ( генератора випадкових чисел Лемера ) з жорстко кодованим початковим насінням. Потім запускається 20 потоків, у яких усі виконують обчислення Лемера зі спільним набором змінних.

Здається, працює досить добре, ось декілька послідовних циклів:

comintern ~ $ ./a.out
821551271
198866223
670412515
4292256
561301260
1256197345
959764614
874838892
1375885882
1788849800
comintern ~ $ ./a.out
2067099631
953349057
1736873858
267798474
941322622
564797842
157852857
1263164394
399068484
2077423336

EDIT: Дав трохи більше думки і зрозумів, що цей час взагалі не заснований. Навіть при повністю детермінованому планувальнику ентропія не походить від часових відрізків - це відбувається від завантаження всіх запущених процесів у системі.

EDIT 2 Після отримання деякого натхнення від @Quincunx розміщення кривої дзвінка, я скинув 12 МБ випадковості у файл і завантажив його в CAcert . Він не вдався до всіх твердих тестів, але отримав поважних 7,999573 з 8 на тесті ЛОР (лише Потенційно детермінований). Цікаво, що подвоєння кількості ниток погіршило її.

С

Він генерує випадкове число в діапазоні 0-255, беручи насіння з https://stackoverflow.com/questions, використовуючи wget.

#include <stdio.h>
main()
{
    FILE *file;
    unsigned char c,x;
    system("wget -O - https://stackoverflow.com/questions > quest.html");
    file = fopen ("quest.html", "r");
    while(c=fgetc(file) != EOF) x+=c;
    fclose(file);
    printf("%d",x);
}

Проба зразка:

C:\Users\izabera>random
--2014-03-02 16:15:28--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85775 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,775      40.3K/s   in 2.1s

2014-03-02 16:15:31 (40.3 KB/s) - `-' saved [85775/85775]

15 /* <=================== THIS IS THE RANDOM NUMBER */
C:\Users\izabera>random
--2014-03-02 16:15:36--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85836 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,836      50.0K/s   in 1.7s

2014-03-02 16:15:38 (50.0 KB/s) - `-' saved [85836/85836]

76
C:\Users\izabera>random
--2014-03-02 16:15:56--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85244 (83K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,244      36.0K/s   in 2.3s

2014-03-02 16:15:59 (36.0 KB/s) - `-' saved [85244/85244]

144

C ++

#include<iostream>
int main()
{
    int *ptr=new int,i=0;
    for(;i<5;i++)
    {
        std::cout<<*(ptr+i)<<'\n';
    }
    return 0;
}  

вихід

будь-які 5 випадкових чисел

три зразки

перл

Що це все за сміття з отриманням насіння через Інтернет? Мені здається, що мені підман ;-) Я вважаю за краще віддавати своє насіння криптографічній хеш-функції і давати вихід у діапазоні від 0 до 2 ^ 160-1 так:

use Digest::SHA1 qw(sha1);
use bigint;
sub r {
  $_ = \3;
  /^.*x([0-9a-f]+).$/;
  hex((unpack "H*", sha1 "some_salt".$1.$$)[0])
}
print join " ", r'

Кожен раз, коли у вас є ентропія невизначеної якості, спосіб розподілити її більш регулярно (але не підвищувати її якість!) - це передавати її на зразок SHA1 або MD5 або близько того, як я це робив тут. Для попереднього хеш-насіння я використав pid та адресу випадкової посилання. Звичайно, ви можете додати інші входи для більшої ентропії, наприклад, на x86 ви можете використовувати TSC - (але вбудований код складання в perl - це трохи ведмідь, тому я пропустив його).

Якщо ви хочете мати інший вихід, ніж хлопець на наступному комп’ютері, просто налаштуйте "some_salt" так, щоб це було на ваш смак. Або залиште це зовсім, якщо ви мінімаліст =)

Java

Моє рішення зловживає hashCode()методом Objectзанять.

class G22640 {
    static class Rand {
        public int nextInt() {
            return new Object().hashCode();
        }
    }

    public static void main(String args[]) {
        Rand r = new Rand();
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt());
        }
    }
}

Вибірка зразка:

31859448
22101035
11593610
4580332
25736626
32157998
3804398
32440180
19905449
2772678

Мотивований іншою відповіддю, що демонструє випадковість рішення, я змінив своє рішення, щоб повернути середні 16 біт intповернутого Object.hashCode().

import java.io.*;

class G22640 {
    static class Rand {
        public short nextShort() {
            return (short) ((new Object().hashCode() >> 8) & 0xFFFF);
        }
    }

    public static void main(String args[]) throws IOException {
        Rand r = new Rand();

        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextShort());
        }

        // generateToFile("random_22640.txt");
    }

    private static void generateToFile(String fileName) throws IOException {
        Rand r = new Rand();
        BufferedOutputStream o = new BufferedOutputStream(new FileOutputStream(fileName));

        for (int i = 0; i < 10000000; i++) {
            int a = r.nextShort();
            for (int j = 0; j < 2; j++) {
                o.write(a & 0xFF);
                a >>= 8;
            }
        }

        o.flush();
        o.close();
    }
}

Я створив файл у 19 Мб (складається з 10 ⁷ short ) і подав його в CACert . Ось скріншот результату (він був відредагований, щоб виглядати добре, але цифри залишаються такими, як є):

Я був здивований результатом, оскільки він проходить 7,999991 при тесті Ентропії та здає (?) Всі 7 тестів на Діярда.

Javascript
Створення випадкових випадків з переміщенням миші користувача

var ranArr=[];
var random=0;
var first=second=0;
function generateR(event) {
ranArr.push(parseFloat(event.clientX+document.body.scrollLeft))
ranArr.push(parseFloat(event.clientY+document.body.scrollTop));
var len=ranArr.length;

for(var i=0;i<len;i++) {
    if(i<len/2) {

    first+=ranArr[i];
    } else {
    second += ranArr[i];
    }
}
third = second/first;
third = third+"";
console.log(third.substr(5));
}
document.onmousemove=function(event){generateR(event)};

Останні п'ять скопійованих даних:
9637090187003
7828470680762
6045869361238
4220720695015
2422653391073

Bash, діапазон: вставки між 0 і 1

echo -n & echo "$! % 2" | bc

Рубін

На жаль, тільки для Mac. Ми використовуємо soxдля витягування байтів з мікрофона (як струна, ах ...), повернення його назад, щоб отримати заголовок статусу на кінці (* кашель *), рубаємо його, відсікаємо заголовок, беремо MD5 з шматочків , відкиньте нечислові символи з хеша, додайте решта великі цілі числа разом, наклейте 0.на передню частину , перетворіть у поплавок, виконано.

Створює поплавці різної довжини на проміжку 0..1.

require 'open3'
require 'digest'

class InsecureRandom
  def self.random_number
    n = self.get_bytes
    .map! { |r| Digest::MD5.hexdigest(r) }
    .map! { |r| r.gsub(/[a-z]/, '') }
    .map!(&:to_i)
    .reduce(0,:+)

    "0.#{n}".to_f
  end

  private
  def self.get_bytes
    Open3.popen3('sox -d -q -e unsigned-integer -p') do |_, stdout, _|
      stdout.read(20000).reverse.split('\\').to_a.take(20)
    end
  end
end

randomish = Array.new(20) { InsecureRandom.random_number }
puts randomish
# >> 0.2333530765409607
# >> 0.17754047429753905
# >> 0.936039801228352
# >> 0.2781141892158962
# >> 0.6243140263525706
# >> 0.1583419168189452
# >> 0.2173713056635174
# >> 0.930577106355
# >> 0.11215268787922089
# >> 0.13292311877287152
# >> 0.14791818448435443
# >> 0.4864648362730452
# >> 0.5133193113765809
# >> 0.3076637743531015
# >> 0.16060112015793476
# >> 0.7294970251624926
# >> 0.18945368886946876
# >> 0.9970215825154781
# >> 0.13775531752383308
# >> 0.5794383903900283

С

Генерація випадкових за допомогою ідентифікатора процесу.

#include <unistd.h>
#include <stdio.h>

int     main(void)
{
    int out;
    out *= out *= out = getpid();
    printf("%d\n", out % 1024);
    return (0);
}

Вибірка зразка:

-767
0
769
-1008
337
-768
369
-752
-415
0
-863
784
-463
256
657

СПІН

Якби це було код-гольф, я виграв би!

byte a
?a@

пітон

Лаконічність Пітона ніколи не перестає дивувати. Оскільки використання випадкового зображення imgur, мабуть, не вірно, я використав чудове джерело випадковості: чат stackoverflow!

   import urllib.request

def getrand():
    req = urllib.request.Request("http://chat.stackoverflow.com/")
    response = urllib.request.urlopen(req)
    the_page = str(response.read())

    x = 1
    for char in the_page:
        x = (3*x + ord(char) + 1)%2**32

    print(x)

5 випробувань:

3258789746
1899058937
3811869909
274739242
1292809118

Не справді випадково, але знову ж таки жодне з них не є.

перл

Я побачив багато відповідей, які робили HTTP-запити, що мені здається марнотратним, оскільки під обкладинками на дроті є випадкові номери. Тому я вирішив написати якийсь код, щоб провести його по нижньому рівню:

use IO::Socket::INET;
print ((sockaddr_in(getsockname(IO::Socket::INET->new(
    PeerAddr => "google.com", PeerPort => 80, Proto => "tcp"
))))[0]);

Дає випадкові порти в діапазоні 0..65535, теоретично. На практиці існує ряд портів, які ви ніколи не побачите, тому розподіл далеко не ідеальний. Але це, AFAICT - мінімальна кількість роботи, яку ви можете зробити, щоб отримати деяку ентропію від віддаленого хоста, у якого відкритий порт.

PS - Поводження з помилками залишається читачем як вправа ;-)

С

// alternating two pure-RNG inspired by http://xkcd.com/221/
int getRandomNumber()
{
   static int dice_roll = 0;
   dice_roll++;
   if ((dice_roll % 2) == 1)
   {
      return 4;
   } 
   else
   {
      return 5;
   } 
}

int main(int argc, char **argv)
{
    printf("%d\n%d\n", getRandomNumber(), getRandomNumber())
    return 0;
}