งานของคุณคือสร้างตัวสร้างหมายเลขสุ่มฮาร์ดแวร์กับฮาร์ดแวร์ใด ๆ ก็ตามที่คุณมีอยู่

ท้าทาย

เขียนโปรแกรมด้วยคุณสมบัติต่อไปนี้:

1. มันพิมพ์อย่างใดอย่างหนึ่ง0หรือ1(และไม่มีอะไรอื่น)
2. เอาท์พุทขึ้นอยู่กับกระบวนการทางกายภาพและไม่เพียง แต่สถานะภายในของคอมพิวเตอร์
3. ไม่มีความสัมพันธ์ระหว่างเอาต์พุตของการรันที่ตามมา (แยกจากกันหนึ่งนาที)
4. ผลลัพธ์ไม่สามารถคาดการณ์ได้ด้วยความพยายามที่สมจริง
5. ความน่าจะเป็นของเอาต์พุต0อยู่ระหว่าง 0.2 ถึง 0.8
6. มันทำงานในเวลาน้อยกว่าหนึ่งนาทีด้วยความน่าจะเป็นที่สูงพอสมควร

คุณต้องอธิบายสาเหตุที่โปรแกรมของคุณมีคุณสมบัติเหล่านี้หากไม่ชัดเจน

คำชี้แจงและข้อ จำกัด

ต่อไปนี้อาจดูเหมือนข้อ จำกัด มากมายสำหรับการประกวดความนิยม แต่ในท้ายที่สุดมันทั้งหมดเพื่อให้แน่ใจว่าโปรแกรมยังคงอยู่ภายในจิตวิญญาณของคำถามค่อนข้างทำงานและเพื่อหลีกเลี่ยงการแก้ปัญหาที่เป็นที่นิยมเนื่องจากเป็น overkill ทั้งหมด แต่เป็นที่สุด ค่อนข้างน่าเบื่อ

• เวลาระบบไม่นับเป็นกระบวนการทางกายภาพ
• คุณสามารถใช้ฮาร์ดแวร์ระดับผู้บริโภคที่คุณต้องการตั้งแต่ไดรฟ์ฟล็อปปี้ดิสก์ขนาด 8 นิ้วไปจนถึงตัวปล่อยจรวด USBไปยังหูฟัง - เว้นแต่ว่าจะมีไว้สำหรับการสร้างหมายเลขสุ่ม ชิ้นส่วนของฮาร์ดแวร์เป็นเกรดสำหรับผู้บริโภคหากเป็นผลิตภัณฑ์ที่ผลิตเป็นจำนวนมากและมีค่าใช้จ่ายน้อยกว่า 1,000 $ / € / £ดังนั้นคุณจึงไม่สามารถใช้กล้องโทรทรรศน์วิทยุ CERN, MRIs หรือเครื่องตรวจจับอนุภาคในตัว
• คุณสามารถตั้งสมมติฐานพื้นฐานที่สุดได้เฉพาะกับสถานะและการจัดแนวของฮาร์ดแวร์เช่นการเปิดสวิตช์ (หากมีสวิตช์เปิดปิด) และติดตั้งและใช้งานได้อย่างเหมาะสม ตัวอย่างเช่นคุณสามารถสมมติให้ไดรฟ์ซีดีมีความสามารถในการอ่านดิสก์โดยทั่วไปและไม่ให้ติดขัด แต่คุณไม่สามารถสันนิษฐานได้ว่าจะเปิดหรือปิดหรือมีดิสก์อยู่ ในตัวอย่างอื่นคุณไม่สามารถถือว่าฮาร์ดแวร์สองชิ้นถูกจัดตำแหน่งเพื่อให้มีการโต้ตอบพิเศษ แต่คุณสามารถสันนิษฐานได้ว่าอยู่ในห้องเดียวกัน
• คุณอาจปล่อยให้ฮาร์ดแวร์อยู่ในสถานะที่คุณต้องการยกเว้นว่าคุณทำผิดพลาด
• คุณสามารถและต้องถือว่าฮาร์ดแวร์อยู่ในสภาพแวดล้อมที่เป็นธรรมชาติ แต่ไม่มีอะไรเพิ่มเติม ตัวอย่างเช่นคุณสามารถสันนิษฐานได้ว่าฮาร์ดแวร์ไม่ได้ถูกจัดวางในถังของเหลวฮีเลียมหรือในห้องกันเสียงและกันแสงหรือในพื้นที่ อย่างไรก็ตามคุณไม่สามารถคาดเดาแหล่งที่มาของเสียงและแสงใด ๆ ได้ยกเว้นแหล่งที่จะหลีกเลี่ยงได้ด้วยความพยายามที่รุนแรง
• โปรแกรมของคุณต้องทำงานบนคอมพิวเตอร์เดสก์ท็อปมาตรฐานที่มีระบบปฏิบัติการที่ไม่มีความลึกลับที่คุณเลือก คุณอาจใช้ซอฟต์แวร์ใด ๆ ที่ไม่ได้ออกแบบมาโดยเฉพาะสำหรับการสร้างหมายเลขสุ่ม
• คุณไม่สามารถเข้าอินเทอร์เน็ตได้
• คุณไม่สามารถคิดว่ามนุษย์ไม่อยู่หรือไม่อยู่ แต่คุณสามารถคิดได้ว่าไม่มีใครรบกวนโปรแกรมของคุณเช่นโดยการหยุดแฟนด้วยตนเองหรือรันโปรแกรมที่ไม่ทำอะไรเลยนอกจากปิดไมโครโฟนบ่อยที่สุด
• คุณสามารถตั้งสมมุติฐานพื้นฐานที่สุดเกี่ยวกับการตั้งค่าซอฟต์แวร์ได้เท่านั้น ตัวอย่างเช่นคุณสามารถสมมติว่าจะติดตั้งและเปิดใช้งานไดรฟ์เวอร์ แต่คุณต้องเตรียมพร้อมสำหรับการปิดเสียง
• คุณสามารถออกจากการตั้งค่าซอฟต์แวร์ในสถานะที่คุณต้องการ

โบนัส

รางวัลพิเศษถูกมอบให้กับทางออกที่สั้นโดยเฉพาะ นี่ค่อนข้างตามจำนวนคำสั่งและคล้ายกันมากกว่าโดยตัวอักษร ผู้ชนะคือ (ผูกตามเกณฑ์ของฉัน):

• คำตอบนี้โดย Franki
• คำตอบนี้โดย Tejas Kale

ฉันทำได้เพียงคำตอบเดียวและคำตอบของ 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 เดียวไปยัง localhost

โปรดทราบว่าเวลาตอบสนองจะปรากฏขึ้นสามครั้งในผลลัพธ์ของ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

โค้ดส่วนใหญ่เป็นฟังก์ชั่นแฮช (คุณจาวาสคริปต์แล้วและยังไม่มีไลบรารี่มาตรฐานของคุณ) มันอาจจะสั้นกว่านี้ แต่ฉันเป็นคนที่ชอบฟังก์ชั่นแฮชที่ดี

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

ตรวจสอบเวลาตอบสนองของ Harddrive โดยกำหนดเวลาการทำงานสามครั้ง:

• อ่านแหล่งที่มาของตัวเอง
• กำลังลบตัวมันเอง
• เขียนเองอีกครั้ง

ในที่สุดเวลาที่ถูกบรรจุจะเป็นแบบลอยและบิตที่สำคัญที่สุดที่ 11 จะถูกใช้

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'แปลงทุกศูนย์และไม่ใช่ตัวเลขให้เป็นเครื่องหมายบวกและ echo จะ$[...0&1]พิมพ์พาริตีของผลรวมที่ได้

การคำนวณ Regex และ parity คำนวณจากคำตอบของเดนนิส

ทุบตี

(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 วินาที แต่อาจแตกต่างกันมาก โดยเฉพาะอย่างยิ่งอย่าเรียกใช้เป็นรูทหรืออย่างน้อยก็แก้ไขเพื่อแยกออก/proc/kcore(ยกเว้นกรณีที่คุณยินดีที่จะใช้เวลามากในการรวมเอนโทรปีที่มีอยู่ในนั้นซึ่งอาจรวมทุกอย่างจริงๆ)

Shell + 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 ของข้อมูลแพ็กเก็ตและส่งคืน 1 หากตัวอักษรแรกของแฮช 0-7 . สมมติว่าการ์ด wi-fi ของคุณเป็นwlan0และคุณยังไม่มีmon0อุปกรณ์

หากไม่มีอุปกรณ์ Wi-Fi ในบริเวณใกล้เคียงผลลัพธ์จะถูกคาดเดาได้เพราะจะเหมือนกันทุกครั้ง

โปรเซสเซอร์ที่รองรับ 8086 รุ่นใหม่ที่ผลิตโดย Intel มีอุปกรณ์ต่อพ่วงที่เข้าถึงได้ง่ายซึ่งสร้างการสุ่มที่เหมาะสม การขับขี่อุปกรณ์ต่อพ่วงนั้นทำได้โดยใช้rdrandคำสั่งซึ่งจะสร้างรูปแบบบิตแบบสุ่มหรือตั้งค่าสถานะการพกพาหากอุปกรณ์ต่อพ่วงไม่พร้อมใช้งานหรือหลุดออกจากเอนโทรปี

โปรแกรมสั้น ๆ ต่อไปนี้สำหรับ 80386 Linux ตรวจสอบว่าอุปกรณ์ต่อพ่วงมีให้โดยใช้cpuidคำสั่งและพยายามสร้างหมายเลขสุ่ม 1หากทั้งอุปกรณ์ต่อพ่วงหรือจำนวนสุ่มไม่สามารถใช้งานโปรแกรมจะบอกเลิกกับสถานะของ หากสามารถสร้างตัวเลขสุ่มอาจจะเป็น1หรือ00จะพิมพ์ออกมาและโปรแกรมยุติกับสถานะทางออก

บันทึกเป็น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 ล้านครั้งจากนั้นใช้เคล็ดลับของ Dennis เพื่อเปลี่ยนเวลาที่ใช้เป็นบูลีนเดี่ยว (ใช้เวลาประมาณ 7 วินาทีในเครื่องของฉัน)

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

Arduino Mega1280

แก้ไข: เวอร์ชันที่อัปเดตซึ่งมีความทนทานต่อการมีอะไรที่เสียบเข้ากับหมุด แนวคิดนี้ขึ้นอยู่กับความจริงที่ว่า ATMega1280 ใช้ oscillator ภายในแยกต่างหากสำหรับ oscillator จ้องจับผิด ฉันเพียงแค่ติดตั้งการขัดจังหวะจ้องจับผิดที่ตั้งค่าสถานะมีตัวนับตามนาฬิการะบบ (บน 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;
}

จาวาสคริ

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.

วิธีการนี้มีข้อได้เปรียบในการไม่แก้ไขข้อมูลใด ๆ ในระบบและไม่ต้องการ Perl มากกว่าหนึ่งของ Primo

เปลือก

ทดสอบบน Linux แล้ว แต่บางที U * IX ของคุณอาจมี / proc / stat เช่นกัน?

นี่เป็นการเริ่มกระบวนการเพิ่มเติมเพียงครั้งเดียวอ่านไฟล์เพิ่มเติมเพียงไฟล์เดียว (ไม่แม้แต่บนดิสก์) และมีความยาว 37 ตัวอักษร มันค่อนข้างเร็วด้วย

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

หนึ่งอาจคิดว่าสิ่งนี้ถูกกำหนดโดยกระบวนการเคอร์เนลและ userland ทั้งหมด แต่นั่นไม่ใช่กรณีเนื่องจาก / proc / stat ยังรวมถึงเวลารอคอยของ IO เวลาในการขัดจังหวะฮาร์ดแวร์ที่ใช้เวลาทั้งหมดที่ใช้ในภารกิจว่างและอื่น ๆ ซึ่งทั้งหมด ขึ้นอยู่กับอินพุตของฮาร์ดแวร์ภายนอก

Matlab

โซลูชันไมโครโฟน:

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

บันทึกเสียง 10 วินาทีค้นหาจำนวนตัวอย่างเชิงลบในการบันทึกและส่งออก 0 หากจำนวนนี้เป็นเลขคู่และ 1 หากเป็นเลขคี่ ดังนั้น 0 กับความน่าจะเป็น 50% วิธีการดังกล่าวหมายความว่าแม้จะมีเสียงรบกวนเพียงเล็กน้อย แต่ไม่สามารถหลีกเลี่ยงได้ในการบันทึกเสียงแบบเงียบก็เพียงพอที่จะสร้างเอาต์พุตแบบสุ่ม โค้ดที่ยาวกว่านี้เล็กน้อยจะเร่งความเร็วของตัวสร้างตัวเลขโดยใช้การบันทึกที่สั้นกว่าชดเชยด้วยบิตเรตที่สูงกว่าซึ่งให้เสียงมากกว่า

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]

ใช้ accelerometer ที่มีนัยสำคัญน้อยที่สุดของคอมพิวเตอร์ (ต้องการhdapsโมดูล Linux):

#!/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)

โดยทั่วไปจะทำการวัดสัญญาณรบกวนของเซ็นเซอร์

SmileBASIC

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 ของ accelerometer จะอยู่ที่ประมาณ -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 ทำ มันจะเปลี่ยนทุกตัวละครที่ไม่ใช่ตัวเลขในการส่งออกของด้านบนเป็น '+' และจากนั้นความเท่าเทียมกันของสตริงที่เกิด

แฟล็ก 'b' ไปด้านบนจะรันในโหมดแบทช์เพื่อให้รายงานกระบวนการทั้งหมดไม่ใช่แค่หน้าจอแรกและ 'n1' บอกว่าจะเรียกใช้ 1 ซ้ำของด้านบน