Wie generiere ich Zufallszahlen in Bash?

Wie generiere ich eine Zufallszahl innerhalb eines Bereichs in Bash?

Verwenden Sie $RANDOM. Es ist oft nützlich in Kombination mit einfacher Shell-Arithmetik. Zum Beispiel, um eine Zufallszahl zwischen 1 und 10 (einschließlich) zu generieren:

$ echo $((1 + RANDOM % 10))
3

Der eigentliche Generator ist in variables.cder Funktion brand(). Ältere Versionen waren ein einfacher Lineargenerator. Version 4.0 von bashverwendet einen Generator mit einem Zitat aus einem Artikel von 1985, was vermutlich bedeutet, dass es eine anständige Quelle für Pseudozufallszahlen ist. Ich würde es nicht für eine Simulation verwenden (und schon gar nicht für Krypto), aber es ist wahrscheinlich ausreichend für grundlegende Skriptaufgaben.

Wenn Sie etwas tun, das ernsthafte Zufallszahlen erfordert, können Sie diese verwenden /dev/randomoder /dev/urandomwenn sie verfügbar sind:

$ dd if=/dev/urandom count=4 bs=1 | od -t d

Bitte sehen Sie $RANDOM:

$RANDOM ist eine interne Bash-Funktion (keine Konstante), die eine pseudozufällige Ganzzahl im Bereich von 0 bis 32767 zurückgibt. Sie sollte nicht zum Generieren eines Verschlüsselungsschlüssels verwendet werden.

Sie können auch shuf verwenden (erhältlich in coreutils).

shuf -i 1-100000 -n 1

Versuchen Sie dies aus Ihrer Shell:

$ od -A n -t d -N 1 /dev/urandom

Gibt hier an, -t ddass das Ausgabeformat dezimal signiert werden soll. -N 1sagt, ein Byte von zu lesen /dev/urandom.

Sie können auch eine Zufallszahl von awk erhalten

awk 'BEGIN {
   # seed
   srand()
   for (i=1;i<=1000;i++){
     print int(1 + rand() * 100)
   }
}'

Es gibt $ RANDOM. Ich weiß nicht genau, wie es funktioniert. Aber es funktioniert. Zum Testen können Sie Folgendes tun:

echo $RANDOM

Ich mag diesen Trick:

echo ${RANDOM:0:1} # random number between 1 and 9
echo ${RANDOM:0:2} # random number between 1 and 99

...

Zufallszahl zwischen 0 und 9 einschließlich.

echo $((RANDOM%10))

Wenn Sie ein Linux-System verwenden, können Sie eine Zufallszahl aus / dev / random oder / dev / urandom abrufen. Seien Sie vorsichtig, wenn / dev / random blockiert, wenn nicht genügend Zufallszahlen verfügbar sind. Wenn Sie Geschwindigkeit über Zufälligkeit benötigen, verwenden Sie / dev / urandom.

Diese "Dateien" werden mit Zufallszahlen gefüllt, die vom Betriebssystem generiert werden. Es hängt von der Implementierung von / dev / random auf Ihrem System ab, ob Sie echte oder Pseudozufallszahlen erhalten. Echte Zufallszahlen werden mithilfe von Rauschen generiert, das von Gerätetreibern wie Maus, Festplatte und Netzwerk erfasst wird.

Mit dd können Sie Zufallszahlen aus der Datei abrufen

Ich habe einige dieser Ideen aufgegriffen und eine Funktion entwickelt, die schnell ausgeführt werden sollte, wenn viele Zufallszahlen erforderlich sind.

Anrufen odist teuer, wenn Sie viele Zufallszahlen benötigen. Stattdessen rufe ich es einmal auf und speichere 1024 Zufallszahlen aus / dev / urandom. Wannrand Aufruf wird die letzte Zufallszahl zurückgegeben und skaliert. Es wird dann aus dem Cache entfernt. Wenn der Cache leer ist, werden weitere 1024 Zufallszahlen gelesen.

Beispiel:

rand 10; echo $RET

Gibt eine Zufallszahl in RET zwischen 0 und 9 einschließlich zurück.

declare -ia RANDCACHE
declare -i RET RAWRAND=$(( (1<<32)-1 ))

function rand(){  # pick a random number from 0 to N-1. Max N is 2^32
  local -i N=$1
  [[ ${#RANDCACHE[*]} -eq 0 ]] && { RANDCACHE=( $(od -An -tu4 -N1024 /dev/urandom) ); }  # refill cache
  RET=$(( (RANDCACHE[-1]*N+1)/RAWRAND ))  # pull last random number and scale
  unset RANDCACHE[${#RANDCACHE[*]}-1]     # pop read random number
};

# test by generating a lot of random numbers, then effectively place them in bins and count how many are in each bin.

declare -i c; declare -ia BIN

for (( c=0; c<100000; c++ )); do
  rand 10
  BIN[RET]+=1  # add to bin to check distribution
done

for (( c=0; c<10; c++ )); do
  printf "%d %d\n" $c ${BIN[c]} 
done

UPDATE: Das funktioniert nicht für alle N. Es verschwendet auch zufällige Bits, wenn es mit kleinem N verwendet wird. Beachten Sie, dass (in diesem Fall) eine 32-Bit-Zufallszahl genug Entropie für 9 Zufallszahlen zwischen 0 und 9 (10 * 9) hat = 1.000.000.000 <= 2 * 32) Wir können mehrere Zufallszahlen aus jedem 32 zufälligen Quellwert extrahieren.

#!/bin/bash

declare -ia RCACHE

declare -i RET             # return value
declare -i ENT=2           # keep track of unused entropy as 2^(entropy)
declare -i RND=RANDOM%ENT  # a store for unused entropy - start with 1 bit

declare -i BYTES=4         # size of unsigned random bytes returned by od
declare -i BITS=8*BYTES    # size of random data returned by od in bits
declare -i CACHE=16        # number of random numbers to cache
declare -i MAX=2**BITS     # quantum of entropy per cached random number
declare -i c

function rand(){  # pick a random number from 0 to 2^BITS-1
  [[ ${#RCACHE[*]} -eq 0 ]] && { RCACHE=( $(od -An -tu$BYTES -N$CACHE /dev/urandom) ); }  # refill cache - could use /dev/random if CACHE is small
  RET=${RCACHE[-1]}              # pull last random number and scale
  unset RCACHE[${#RCACHE[*]}-1]  # pop read random number
};

function randBetween(){
  local -i N=$1
  [[ ENT -lt N ]] && {  # not enough entropy to supply ln(N)/ln(2) bits
    rand; RND=RET       # get more random bits
    ENT=MAX             # reset entropy
  }
  RET=RND%N  # random number to return
  RND=RND/N  # remaining randomness
  ENT=ENT/N  # remaining entropy
};

declare -ia BIN

for (( c=0; c<100000; c++ )); do
  randBetween 10
  BIN[RET]+=1
done

for c in ${BIN[*]}; do
  echo $c
done

Das Lesen aus speziellen Dateien mit / dev / random- oder / dev / urandom-Zeichen ist der richtige Weg.

Diese Geräte geben beim Lesen wirklich zufällige Zahlen zurück und sollen der Anwendungssoftware bei der Auswahl sicherer Schlüssel für die Verschlüsselung helfen. Solche Zufallszahlen werden aus einem Entropiepool extrahiert, der durch verschiedene Zufallsereignisse bereitgestellt wird. {LDD3, Jonathan Corbet, Alessandro Rubini und Greg Kroah-Hartman]

Diese beiden Dateien sind insbesondere eine Schnittstelle zur Kernel-Randomisierung

void get_random_bytes_arch(void* buf, int nbytes)

Dies zieht wirklich zufällige Bytes von der Hardware, wenn diese Funktion von der implementierten Hardware ist (normalerweise) oder aus dem Entropiepool (bestehend aus Zeitabläufen zwischen Ereignissen wie Maus- und Tastatur-Interrupts und anderen Interrupts, die bei SA_SAMPLE_RANDOM registriert sind).

dd if=/dev/urandom count=4 bs=1 | od -t d

Dies funktioniert, schreibt jedoch nicht benötigte Ausgaben von ddin stdout. Der folgende Befehl gibt nur die Ganzzahl an, die ich benötige. Ich kann sogar eine bestimmte Anzahl von Zufallsbits erhalten, wenn ich die Bitmaske für die arithmetische Erweiterung anpasse:

me@mymachine:~/$ x=$(head -c 1 /dev/urandom > tmp && hexdump 
                         -d tmp | head -n 1 | cut -c13-15) && echo $(( 10#$x & 127 ))

Wie wäre es mit:

perl -e 'print int rand 10, "\n"; '

Vielleicht bin ich etwas zu spät, aber was ist mit jotder Generierung einer Zufallszahl innerhalb eines Bereichs in Bash?

jot -r -p 3 1 0 1

Dies erzeugt eine Zufallszahl ( -r) mit einer Genauigkeit von 3 Dezimalstellen ( -p). In diesem speziellen Fall erhalten Sie eine Zahl zwischen 0 und 1 ( 1 0 1). Sie können auch sequentielle Daten drucken. Die Quelle der Zufallszahl ist laut Handbuch:

Zufallszahlen werden durch arc4random (3) erhalten, wenn kein Startwert angegeben ist, und durch Zufallszahlen (3), wenn ein Startwert angegeben wird.

Basierend auf den großartigen Antworten von @Nelson, @Barun und @Robert ist hier ein Bash-Skript, das Zufallszahlen generiert.

• Kann generieren, wie viele Ziffern Sie möchten.
• Jede Ziffer wird separat generiert, /dev/urandomwas viel besser ist als die von Bash integrierte$RANDOM

#!/usr/bin/env bash

digits=10

rand=$(od -A n -t d -N 2 /dev/urandom |tr -d ' ')
num=$((rand % 10))
while [ ${#num} -lt $digits ]; do
  rand=$(od -A n -t d -N 1 /dev/urandom |tr -d ' ')
  num="${num}$((rand % 10))"
done
echo $num

Generieren Sie eine Zufallszahl im Bereich von 0 bis n (vorzeichenbehaftete 16-Bit-Ganzzahl). Ergebnis in $ RAND Variable gesetzt. Beispielsweise:

#!/bin/bash

random()
{
    local range=${1:-1}

    RAND=`od -t uI -N 4 /dev/urandom | awk '{print $2}'`
    let "RAND=$RAND%($range+1)"
}

n=10
while [ $(( n -=1 )) -ge "0" ]; do
    random 500
    echo "$RAND"
done

Zufällige Verzweigung eines Programms oder ja / nein; 1/0; wahre / falsche Ausgabe:

if [ $RANDOM -gt 16383  ]; then              # 16383 = 32767/2 
    echo var=true/1/yes/go_hither
else 
    echo var=false/0/no/go_thither
fi

von wenn Sie faul sind, sich an 16383 zu erinnern:

if (( RANDOM % 2 )); then 
    echo "yes"
else 
    echo "no"
fi