あなたの仕事は、周りにあるハードウェアでハードウェア乱数ジェネレーターを即興することです。

チャレンジ

次のプロパティを持つプログラムを作成します。

1. 0または1（他には何も）を出力しません。
2. 出力は、コンピューターの内部状態だけでなく、物理プロセスに依存します。
3. 後続の実行の出力間に関係はありません（1分間隔）。
4. 出力は現実的な努力では予測できません。
5. 出力される確率は00.2〜0.8です。
6. かなり高い確率で1分以内に実行されます。

明らかでない場合は、プログラムにこれらのプロパティがある理由を説明する必要があります。

明確化と制限

以下は、人気コンテストの非常に多くの制限のように思えるかもしれませんが、最終的には、プログラムが質問の精神の範囲内にとどまることを保証し、ある程度機能し、完全に過剰であるために人気があるソリューションを回避することがすべてですむしろ退屈。

• システム時間は物理プロセスとしてカウントされません。
• 8インチfloopy-diskドライブからUSBロケットランチャー、ヘッドフォンまで、消費者グレードのハードウェアを使用できます（乱数生成を目的としない場合）。ハードウェアは大量生産され、価格が1000ドル未満の場合、消費者グレードであるため、電波望遠鏡、CERN、MRI、または自作の粒子検出器は使用できません。
• 電源を入れる（電源スイッチがある場合）、適切にインストールして機能するなど、ハードウェアの状態とアライメントに関して最も基本的な仮定のみを行うことができます。たとえば、CDドライブは一般にディスクを読み取ることができ、詰まることはないと想定できますが、CDドライブが開いている、閉じている、またはディスクが入っているとは想定できません。別の例では、特別な相互作用を可能にするために2つのハードウェアを揃えることはできませんが、同じ部屋にあると想定できます。
• ハードウェアは、破損しない限り、どのような状態のままでもかまいません。
• ハードウェアが自然環境にあることを前提とする必要がありますが、それ以上ではありません。たとえば、ハードウェアが液体ヘリウムのタンク内、非常に防音および耐光性の部屋内、または空間内に配置されていないと仮定できます。ただし、根本的な努力によってのみ回避できるものを除き、サウンドおよび光源が存在すると想定することはできません。
• プログラムは、選択した非難解なオペレーティングシステムを備えた標準的なデスクトップコンピューターで実行する必要があります。乱数生成用に特別に設計されていないソフトウェアを使用できます。
• インターネットアクセスを想定することはできません。
• 人間が存在することも存在しないことも想定できませんが、例えば、ファンを手動で停止したり、マイクをできるだけ頻繁にオフにする以外のプログラムを実行するなどして、プログラムに意図的に干渉する人はいないと想定できます。
• ソフトウェア設定に関して最も基本的な仮定のみを行うことができます。たとえば、ドライバーをインストールしてアクティブ化することを想定できますが、サウンドをミュートするための準備が必要です。
• ソフトウェア設定は任意の状態のままにしておくことができます。

ボーナス

特に短い解決策に対して特別な賞金が授与されました。これは、指示の数によるものであり、文字によるものではありませんでした。勝者は（私の基準に従って結ばれました）：

• フランキーによるこの答え。
• Tejas Kaleによるこの答え。

私は1つの答えしか与えられず、Tejas Kaleの答えはたくさん勝ちました。

シェル

マイクストリームから単一のサンプルを読み取り、その最下位ビットを出力します。これはノイズが支配的です。

編集：マイクのミュートを解除するように変更されました...そして、他のすべても！

# Warning - unmutes EVERYTHING!
for DEV in `amixer | grep Simple | sed -e "s/.*'\(.*\)'.*/\\1/" -e "s/ /~/g"`
do
    amixer -q -- sset "`echo $DEV | sed 's/~/ /g'`" unmute 100% 2>/dev/null
done

echo $(( `od -N1 -d < /dev/dsp | head -n1 | sed 's/.* //'` & 1 ))

バッシュ

echo $[`ping -qc1 127.1|sed 's/[^1-9]/+/g'`0&1]

単一のpingの応答時間からローカルホストへのエントロピーを収集します。

の出力では、応答時間が正確に3回表示されることに注意してくださいping -qc1。

PING 127.1 (127.0.0.1) 56(84) bytes of data.

--- 127.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.044/0.044/0.044/0.000 ms

他のすべての数値と定数であり、さらに重要なことには、応答時間とは無関係です。

sed 's/[^1-9]/+/g'すべてのゼロおよび非数字をプラス記号に変換しecho $[...0&1]、結果の合計のパリティを出力します。

JavaScript + HTML5 DeviceMotion

var hash = function(x) {
    var h = 0
    for (var i = 0; i < x.length; i++) {
        h += x.charCodeAt(i)
        h ^= h << 5
        h ^= h >> 3
        h ^= h << 13
        h &= 0xffff
    }
    return h
}
var listener = function(e) {
    var accelerationString = JSON.stringify(e.acceleration)
    var hashed = hash(accelerationString)
    alert(hashed % 2)
    window.removeEventListener("devicemotion", listener, true)
}
window.addEventListener("devicemotion", listener, true);

JSFiddleはこちら。

サポートされているデバイス（主にモバイルデバイス）でHTML5 DeviceMotion APIを使用します。結果のaccelerationオブジェクトをJSONに変換し、ハッシュし、剰余2を法とします。

ほとんどのコードはハッシュ関数です（JavaScriptを破壊し、標準ライブラリがまったくない）。おそらくもっと短くなるかもしれませんが、私は良いハッシュ関数を使うのが好きです。

Python +ウェブカメラ

ここから恥知らずに盗まれたコードを使用して、ウェブカメラを使用してショットを撮り、データをハッシュし、最下位ビットを印刷します。

#!/usr/bin/python
import pygame.camera, hashlib

pygame.camera.init()
cam = pygame.camera.Camera(pygame.camera.list_cameras()[0])
cam.start()
raw = cam.get_raw()
cam.stop()
pygame.camera.quit()

h = hashlib.sha256()
h.update(raw)
print ord(h.digest()[-1]) % 2

Perl

3つの操作のタイミングを計ることにより、ハードドライブの応答時間を確認します。

• 独自のソースを読む
• 自分自身を削除する
• 再び自分自身を書く

最後に、かかった時間がフロートとしてパックされ、11番目の最上位ビット（仮数の2番目に重要なビット）が使用されます。

use Time::HiRes qw(time);

$t1 = time;
open SELF, "<$0";
read SELF, $_, $^H;
close SELF;

unlink $0;

open SELF, ">$0";
print SELF $_;
close SELF;

print 1&unpack(xB3, pack(f, time-$t1))

バッシュ

echo $[`sensors|sed 's/[^1-9]/+/g'`0&1]

sensors 現在のシステム温度とファン速度を出力します。

acpitz-virtual-0
Adapter: Virtual device
temp1:        +52.0°C  (crit = +98.0°C)

thinkpad-isa-0000
Adapter: ISA adapter
fan1:        3510 RPM

coretemp-isa-0000
Adapter: ISA adapter
Physical id 0:  +54.0°C  (high = +86.0°C, crit = +100.0°C)
Core 0:         +51.0°C  (high = +86.0°C, crit = +100.0°C)
Core 1:         +46.0°C  (high = +86.0°C, crit = +100.0°C)

sed 's/[^1-9]/+/g'すべてのゼロおよび非数字をプラス記号に変換し$[...0&1]、結果の合計のパリティをエコー出力します。

正規表現とパリティの計算は、デニスの答えから借りました。

バッシュ

(echo -en "ibase=16;";(find /proc/[0-9]*/s* -type f -maxdepth 2 ; find /sys /proc/[^0-9]* -type f) 2>&1 | xargs -n1 sha256sum  2>&1 | sha256sum | tr abcdef ABCDEF | sed 's/  -/%2/' )| bc

念のため、すべてを使用します...

に依存

• （すべて何とかどこかでその値を公開に関するほとんどのハードウェアセンサーのセンサーの測定値/sysまたは/proc）
• システム上のすべてのプロセスの数、メモリレイアウト、およびランタイム（「システムの状態」と見なされる場合がありますが、通常はハードウェアのタイミングに依存します）
• システムに応じて、/proc/<pid>/s*sched / schedstat などのさまざまな値は、それらのプロセスを実行するために必要なハードウェアの速度に依存します。
• 私が考えていなかったかもしれないものは、それらのファイルでも利用可能です。

私のシステムのランタイムは10秒以内ですが、大きく異なる場合があります。特に、これをrootとして実行しないでください。または、少なくとも除外するように変更し/proc/kcoreないでください（そこに含まれるエントロピーを含めるために多くの時間を費やさない限り、おそらくすべてが含まれます）

シェル+ Wi-Fi

sudo airmon-ng start wlan0 > /dev/null && sudo dumpcap -a duration:30 -i mon0 -w out.cap > /dev/null && sha512sum out.cap | grep -c "^[0-7]" && sudo airmon-ng stop mon0 > /dev/null

Wi-Fiカードを監視モードにし、受信した30秒分のパケット（隣接ネットワークからの読み取り不能な暗号化データを含む）をダンプし、パケットデータのsha512ハッシュを取得し、ハッシュの最初の文字が0-7の場合1を返します。Wi-Fiカードがwlan0であり、現在mon0デバイスがないと仮定します。

近くにwi-fiデバイスがない場合、出力は毎回同じであるため、予測可能です。

Intelが製造した最新の8086互換プロセッサには、適切なランダム性を生成する簡単にアクセスできる周辺機器が含まれています。その周辺機器の駆動はrdrand、周辺機器が利用できないかエントロピーから外れている場合、ランダムビットパターンを生成するか、キャリーフラグを設定する命令を使用して行われます。

次の80386 Linux用の短いプログラムは、cpuid命令によって周辺機器が使用可能かどうかを確認し、乱数の生成を試みます。周辺機器または乱数が利用できない場合、プログラムはのステータスで終了します1。乱数を生成できる場合、a 1またはa 0が出力され、プログラムは終了ステータスで終了します0。

名前を付けて保存しrand.sて組み立てる

as --32 -o rand.o rand.s
ld -melf_i386 -o rand rand.o

アセンブリ全体は次のとおりです。

        .globl _start
        .type _start,@function
_start:
        # check if the cpuid instruction is available by trying to
        # toggle the id flag in the eflags register
        pushfl
        mov (%esp),%eax
        btc $21,%eax    # toggle id bit
        push %eax
        popfl           # check if id bit was saved
        pushfl
        pop %eax        # load new flags
        pop %ecx        # load original flags
        xor %ecx,%eax   # difference is in %eax
        bt $21,%eax     # check if bit was flipped
        jnc .Lfailure

        # if we reach this part, we have a cpuid instruction
        # next, check if rdrand exists
        mov $1,%eax     # load cpuid leaf 1
        cpuid
        bt $30,%ecx     # is rdrnd available?
        jnc .Lfailure

        # let's try to get some random data
        rdrand %ax      # don't waste randomness; one bit would suffice
        jnc .Lfailure   # no randomness available
        and $1,%eax     # isolate one bit of randomness
        add $0x30,%al   # 0x30 = '0'
        push %eax
        mov $4,%eax     # prepare a write system call
        mov $1,%ebx
        mov %esp,%ecx   # where we placed the data before
        mov %ebx,%edx   # one byte
        int $0x80

        # okay, we're done here. Let's exit
        mov %ebx,%eax   # do an exit system call with status 0
        xor %ebx,%ebx
        int $0x80

.Lfailure:
        mov $1,%eax     # do an exit system call with status 1
        mov %eax,%ebx
        int $0x80

        .size _start,.-_start

そして、結果の77バイトのマシンコードのダンプ：

08048098 <_start>:
 8048098:   9c                      pushf  
 8048099:   8b 04 24                mov    (%esp),%eax
 804809c:   0f ba f8 15             btc    $0x15,%eax
 80480a0:   50                      push   %eax
 80480a1:   9d                      popf   
 80480a2:   9c                      pushf  
 80480a3:   58                      pop    %eax
 80480a4:   59                      pop    %ecx
 80480a5:   31 c8                   xor    %ecx,%eax
 80480a7:   0f ba e0 15             bt     $0x15,%eax
 80480ab:   73 2f                   jae    80480dc <_start+0x44>
 80480ad:   b8 01 00 00 00          mov    $0x1,%eax
 80480b2:   0f a2                   cpuid  
 80480b4:   0f ba e1 1e             bt     $0x1e,%ecx
 80480b8:   73 22                   jae    80480dc <_start+0x44>
 80480ba:   66 0f c7 f0             rdrand %ax
 80480be:   73 1c                   jae    80480dc <_start+0x44>
 80480c0:   83 e0 01                and    $0x1,%eax
 80480c3:   04 30                   add    $0x30,%al
 80480c5:   50                      push   %eax
 80480c6:   b8 04 00 00 00          mov    $0x4,%eax
 80480cb:   bb 01 00 00 00          mov    $0x1,%ebx
 80480d0:   89 e1                   mov    %esp,%ecx
 80480d2:   89 da                   mov    %ebx,%edx
 80480d4:   cd 80                   int    $0x80
 80480d6:   89 d8                   mov    %ebx,%eax
 80480d8:   31 db                   xor    %ebx,%ebx
 80480da:   cd 80                   int    $0x80
 80480dc:   b8 01 00 00 00          mov    $0x1,%eax
 80480e1:   89 c3                   mov    %eax,%ebx
 80480e3:   cd 80                   int    $0x80

バッシュ

最も不必要に高価な乱数収集方法を目指しています。emacsを100万回スポーンするのにかかる時間を計り、次にDennisのトリックを使用して、かかった時間を単一のブール値に変換します（私のマシンでは約7秒かかります）。

$[`(time (seq 1000000 | xargs -P1000 emacs  >/dev/null 2>&1)) |& sed 's/[^1-9]/+/g'`0&1]

Arduino Mega1280

編集：ピンに差し込まれたものに対して堅牢な更新バージョン。このアイデアは、ATMega1280がウォッチドッグ発振器に別の内部発振器を使用するという事実に依存しています。フラグを設定するウォッチドッグ割り込みをセットアップし、システムクロック（Arduinoではこれは16MHzの外部水晶）に基づいてカウンターを設定し、クロックジッタ/変動を処理できるようにします。

#include <avr/interrupt.h>

int time;
volatile bool wdt_ran;

// watchdog interrupt handler
ISR(WDT_vect, ISR_BLOCK)
{
  wdt_ran = true;
}

void setup()  
{
  // setup watchdog interrupt
  cli();
  MCUSR &= ~(1 << WDRF);
  WDTCSR |= (1<<WDCE) | (1<<WDE);
  WDTCSR = (1<<WDIE) | (1<<WDP2) | (1<<WDP1) | (1<<WDP0);
  sei();
  // Open serial communications and wait for port to open:
  Serial.begin(57600);
}

void loop()
{
  if(wdt_ran)
  {
    Serial.println(abs(time%2));
    wdt_ran = false;
  }
  ++time;
}

Javascript

http://jsfiddle.net/prankol57/9a6s0gmv/

ビデオ入力を取ります。

乱数の計算に使用したスクリーンショットを見ることができます。

var m = (navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia);

var constraints = {
  video: {
    mandatory: {
      maxWidth: 350,
      maxHeight: 350
    }
  },
  audio: false
};

var video = document.querySelector("video"), canvas = document.createElement("canvas");
document.body.appendChild(canvas);
canvas.width = 350;
canvas.height = 350;

function start() {
    m.call(navigator, constraints, function (stream) {
        video.src = window.URL.createObjectURL(stream);
    }, function() {
        alert("An error occured. Did you deny permission?");
    });
}

if (m) {
    start();
} else {
    alert('getUserMedia() is not supported in your browser');
}

function getRandomData() {
    var ctx = canvas.getContext("2d");
    ctx.drawImage(video, 0, 0);
    var data = ctx.getImageData(0, 0, 350, 350).data;
    var total = 0;
    for (var i = 0; i < data.length; ++i) {
        total += data[i];
        total %= 2;
    }
    alert("The random number is " + total);
}

document.querySelector("button").onclick = getRandomData;

Linuxのシェル

ハードディスクの読み取り速度+レイアウトが予測できないこのディスク上の頻繁に更新されるディレクトリのアクセス時間を測定します。

# Set this to the device node of whatever drive you want to measure
DRIVE_DEVICE=sda
# This must be a path that is
# a) on device "/dev/$DRIVE_PATH"
# b) frequently updated to add additional access time randomization due to
#    less-predictable disk layout due to less-predictable time, amount and
#    ordering uf updates, like logfile directories, maybe cache directories.
FIND_PATH=/var/log
# Better than using 'sync' - sync only the disk that we actually read from
# also sync both internal drive and system buffers
hdparm -f -F "/dev/$DRIVE_DEVICE"
# Note: bash's built-in time command doesn't support formats :/
# Note: the result is only going to be as good as the system's time command,
#       which isn't necessarily equally good on other U*ICes
t=$(command time -f '%e' -- find "$FIND_PATH" -printf '' 2>&1)
echo $((${t#*.}&1))

必要なもの：

1) read and execute access to every directory under "$FIND_PATH"
2) sending (flush) control commands to a hard drive via a device node.
   Requires root access per default, but can be delegated to a less privileged user
   either by using sudo on this script or by applying
       chgrp 'some_system_group' "$DRIVE_DEVICE" &&
       chmod g+rx "$DRIVE_DEVICE"
   if this is acceptable on your system.

このアプローチには、システム上のデータを変更せず、primoのデータよりもperlを必要としないという利点があります。

シェル

Linuxでテストしましたが、おそらくU * IXにも/ proc / statがありますか？

これは、追加のプロセスを1つだけ開始し、追加のファイルを1つだけ（ディスク上でもない）読み取り、37文字の短さです。また、非常に高速です。

t=1`sum /proc/stat`;echo $[${t% *}&1]

これはすべてのカーネルお​​よびユーザーランドプロセスの状態によって決定されると考えるかもしれませんが、/ proc / statにはIO待機時間、ハードウェア割り込みのサービス時間、アイドルタスクに費やされた時間などが含まれるため、そうではありません外部ハードウェア入力に依存します。

Matlab

マイクソリューション：

recObj=audiorecorder;recordblocking(recObj,10);rem(sum(getaudiodata(recObj)<0),2)

10秒の音を録音し、録音のネガティブサンプルの数を見つけ、この数が偶数の場合は0を出力し、奇数の場合は1を出力します。したがって、50％の確率で0です。このアプローチは、無音の録音では避けられないわずかなノイズでも、ランダムな出力を生成するのに十分であることを意味します。次のわずかに長いコードは、短い記録を使用して数値ジェネレーターを高速化し、より高いビットレートで補正し、ノイズを増やします。

recObj=audiorecorder(8000,16,1);recordblocking(recObj,0.1);rem(sum(getaudiodata(recObj)<0),2)

静かな状態でのテストでは、後者のコードを100回実行すると、コードは51回ゼロを出力します。ノイズの多い条件下で100回実行すると、40回ゼロが生成されました。

編集：元のコードの欠陥を指摘してくれたEmilに感謝します:-)

バッシュ

（デニスに感謝します）

echo $[`w|sed 's/[^1-9]/+/g'`0&1]

コンピューターの加速度計の最下位ビットを取得します（hdapsLinuxモジュールが必要です）。

#!/usr/bin/env python
import re
m = re.search('([-\d]+),([-\d]+)',
              open('/sys/devices/platform/hdaps/position', 'r').read())
print((int(m.group(1)) ^ int(m.group(2))) & 1)

これは基本的にセンサーのノイズを測定します。

スマイルベーシック

XON MOTION 'enable motion sensor
ACCEL OUT ,,Z 'get Z acceleration (up/down)
PRINT Z<-1 'if Z is less than -1, output 1, otherwise 0.

3DSのモーションセンサーを使用します。加速度計のZ軸は通常（重力のため）約-1であり、ランダムノイズにより、それより上または下になることがあります。

マイクを使用するものは次のとおりです。

XON MIC 'enable microphone
DIM REC%[0] 'make array
MICSTART 0,3,1 'start recording. 0=8180Hz, 3=8 bit unsigned, 1=1 second
WAIT 1 'delay (1 frame is enough since we only check the first sample)
MICSAVE MIC 'save recording
PRINT MIC[0]>0 'if the first sample isn't negative, output 1

バッシュ

Soham自身の提案を受け入れました（使用top）：

echo $[`top -bn1|sed 's/[^1-9]/+/g'`0&1]

編集：Sohamの動作と同じように動作します。topの出力内のすべての非数値文字を「+」に変換し、結果の文字列のパリティを評価します。

topの 'b'フラグはバッチモードで実行されるため、最初の1画面だけでなく、すべてのプロセスを報告します。