Zufallszahl aus einem Bereich in einem Bash-Skript

Ich muss eine zufällige Portnummer zwischen 2000-65000aus einem Shell-Skript generieren . Das Problem ist $RANDOMeine 15-Bit-Zahl, also stecke ich fest!

PORT=$(($RANDOM%63000+2001)) würde gut funktionieren, wenn es nicht für die Größenbeschränkung wäre.

Hat jemand ein Beispiel dafür, wie ich das tun kann, vielleicht indem ich etwas extrahiere /dev/urandomund es in einen Bereich bringe?

shuf -i 2000-65000 -n 1

Genießen!

Bearbeiten : Der Bereich ist inklusive.

Unter Mac OS X und FreeBSD können Sie auch jot verwenden:

jot -r 1  2000 65000

Laut Bash-Manpage $RANDOMist zwischen 0 und 32767 verteilt; Das heißt, es ist ein vorzeichenloser 15-Bit-Wert. Unter der Annahme, dass die $RANDOMVerteilung gleichmäßig ist, können Sie eine gleichmäßig verteilte vorzeichenlose 30-Bit-Ganzzahl wie folgt erstellen:

$(((RANDOM<<15)|RANDOM))

Da Ihr Bereich keine Potenz von 2 ist, erhalten Sie mit einer einfachen Modulo-Operation nur eine nahezu gleichmäßige Verteilung, jedoch mit einem 30-Bit-Eingangsbereich und einem weniger als 16-Bit-Ausgabebereich, wie Sie es in Ihrem Fall getan haben. das sollte wirklich nah genug sein:

PORT=$(( ((RANDOM<<15)|RANDOM) % 63001 + 2000 ))

und hier ist einer mit Python

randport=$(python -S -c "import random; print random.randrange(2000,63000)")

und einer mit awk

awk 'BEGIN{srand();print int(rand()*(63000-2000))+2000 }'

Der einfachste allgemeine Weg, der mir in den Sinn kommt, ist ein Perl-Einzeiler:

perl -e 'print int(rand(65000-2000)) + 2000'

Sie können immer nur zwei Zahlen verwenden:

PORT=$(($RANDOM + ($RANDOM % 2) * 32768))

Sie müssen immer noch an Ihrem Bereich befestigen. Es ist keine allgemeine n-Bit-Zufallszahlenmethode, aber sie funktioniert für Ihren Fall und ist alles in Bash.

Wenn Sie wirklich süß sein und aus / dev / urandom lesen möchten, können Sie dies tun:

od -A n -N 2 -t u2 /dev/urandom

Das liest zwei Bytes und druckt sie als vorzeichenloses int; Sie müssen noch Ihren Ausschnitt machen.

Wenn Sie kein Bash-Experte sind und dies in eine Variable in einem Linux-basierten Bash-Skript umwandeln möchten, versuchen Sie Folgendes:

VAR=$(shuf -i 200-700 -n 1)

Damit haben Sie einen Bereich von 200 bis $VAReinschließlich 700 .

Hier ist ein anderes. Ich dachte, es würde bei fast allem funktionieren, aber die zufällige Option von sort ist auf meiner Centos-Box bei der Arbeit nicht verfügbar.

 seq 2000 65000 | sort -R | head -n 1

$RANDOMist eine Zahl zwischen 0 und 32767. Sie möchten einen Port zwischen 2000 und 65000. Dies sind 63001 mögliche Ports. Wenn wir uns an Werte $RANDOM + 2000zwischen 2000 und 33500 halten , decken wir einen Bereich von 31501 Ports ab. Wenn wir eine Münze werfen und dann bedingt 31501 zum Ergebnis hinzufügen, können wir mehr Ports von 33501 bis 65001 erhalten . Wenn wir dann nur 65001 fallen lassen, erhalten wir genau die erforderliche Abdeckung mit einer einheitlichen Wahrscheinlichkeitsverteilung für alle Ports, wie es scheint.

random-port() {
    while [[ not != found ]]; do
        # 2000..33500
        port=$((RANDOM + 2000))
        while [[ $port -gt 33500 ]]; do
            port=$((RANDOM + 2000))
        done

        # 2000..65001
        [[ $((RANDOM % 2)) = 0 ]] && port=$((port + 31501)) 

        # 2000..65000
        [[ $port = 65001 ]] && continue
        echo $port
        break
    done
}

Testen

i=0
while true; do
    i=$((i + 1))
    printf "\rIteration $i..."
    printf "%05d\n" $(random-port) >> ports.txt
done

# Then later we check the distribution
sort ports.txt | uniq -c | sort -r

Du kannst das

cat /dev/urandom|od -N2 -An -i|awk -v f=2000 -v r=65000 '{printf "%i\n", f + r * $1 / 65536}'

Weitere Informationen finden Sie unter Shell Script Random Number Generator .

Gleiches gilt für Rubin:

echo $(ruby -e 'puts rand(20..65)') #=> 65 (inclusive ending)
echo $(ruby -e 'puts rand(20...65)') #=> 37 (exclusive ending)

In der Bash-Dokumentation heißt es, dass bei jedem $RANDOMVerweis eine Zufallszahl zwischen 0 und 32767 zurückgegeben wird. Wenn wir zwei aufeinanderfolgende Referenzen summieren, erhalten wir Werte von 0 bis 65534, was den gewünschten Bereich von 63001 Möglichkeiten für eine Zufallszahl zwischen 2000 und 65000 abdeckt.

Um es auf den genauen Bereich einzustellen, verwenden wir die Summe modulo 63001, die einen Wert von 0 bis 63000 ergibt. Dies erfordert wiederum nur ein Inkrement um 2000, um die gewünschte Zufallszahl zwischen 2000 und 65000 bereitzustellen. Dies kann sein wie folgt zusammengefasst:

port=$((((RANDOM + RANDOM) % 63001) + 2000))

Testen

# Generate random numbers and print the lowest and greatest found
test-random-max-min() {
    max=2000
    min=65000
    for i in {1..10000}; do
        port=$((((RANDOM + RANDOM) % 63001) + 2000))
        echo -en "\r$port"
        [[ "$port" -gt "$max" ]] && max="$port"
        [[ "$port" -lt "$min" ]] && min="$port"
    done
    echo -e "\rMax: $max, min: $min"
}

# Sample output
# Max: 64990, min: 2002
# Max: 65000, min: 2004
# Max: 64970, min: 2000

Richtigkeit der Berechnung

Hier ist ein vollständiger Brute-Force-Test für die Richtigkeit der Berechnung. Dieses Programm versucht nur, alle 63001 verschiedenen Möglichkeiten zufällig unter Verwendung der zu testenden Berechnung zu generieren. Der --jobsParameter sollte die Ausführung beschleunigen, ist jedoch nicht deterministisch (die Gesamtzahl der generierten Möglichkeiten kann unter 63001 liegen).

test-all() {
    start=$(date +%s)
    find_start=$(date +%s)
    total=0; ports=(); i=0
    rm -f ports/ports.* ports.*
    mkdir -p ports
    while [[ "$total" -lt "$2" && "$all_found" != "yes" ]]; do
        port=$((((RANDOM + RANDOM) % 63001) + 2000)); i=$((i+1))
        if [[ -z "${ports[port]}" ]]; then
            ports["$port"]="$port"
            total=$((total + 1))
            if [[ $((total % 1000)) == 0 ]]; then
                echo -en "Elapsed time: $(($(date +%s) - find_start))s \t"
                echo -e "Found: $port \t\t Total: $total\tIteration: $i"
                find_start=$(date +%s)
            fi
        fi
    done
    all_found="yes"
    echo "Job $1 finished after $i iterations in $(($(date +%s) - start))s."
    out="ports.$1.txt"
    [[ "$1" != "0" ]] && out="ports/$out"
    echo "${ports[@]}" > "$out"
}

say-total() {
    generated_ports=$(cat "$@" | tr ' ' '\n' | \sed -E s/'^([0-9]{4})$'/'0\1'/)
    echo "Total generated: $(echo "$generated_ports" | sort | uniq | wc -l)."
}
total-single() { say-total "ports.0.txt"; }
total-jobs() { say-total "ports/"*; }
all_found="no"
[[ "$1" != "--jobs" ]] && test-all 0 63001 && total-single && exit
for i in {1..1000}; do test-all "$i" 40000 & sleep 1; done && wait && total-jobs

Um zu bestimmen, wie viele Iterationen erforderlich sind, um eine bestimmte Wahrscheinlichkeit p/qzu erhalten, dass alle 63001-Möglichkeiten generiert wurden, können wir meines Erachtens den folgenden Ausdruck verwenden. Hier ist zum Beispiel die Berechnung für eine Wahrscheinlichkeit größer als 1/2 und hier für mehr als 9/10 .

Oder unter OS-X funktioniert für mich Folgendes:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) ist nah an dem, was du willst, denke ich.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))umgeht die Größenbeschränkung, die Sie stört. Da bash nicht zwischen einer Zahlenvariablen und einer Zeichenfolgenvariablen unterscheidet, funktioniert dies einwandfrei. Die "Zahl" $RANDOMkann wie eine Zeichenfolge verkettet und dann als Zahl in einer Berechnung verwendet werden. Tolle!

Sie können die Zufallszahl durch bekommen urandom

head -200 /dev/urandom | cksum

Ausgabe:

3310670062 52870

Um den einen Teil der obigen Nummer abzurufen.

head -200 /dev/urandom | cksum | cut -f1 -d " "

Dann ist die Ausgabe

3310670062

Um Ihre Anforderungen zu erfüllen,

head -200 /dev/urandom |cksum | cut -f1 -d " " | awk '{print $1%63000+2001}'

So generiere ich normalerweise Zufallszahlen. Dann verwende ich "NUM_1" als Variable für die von mir verwendete Portnummer. Hier ist ein kurzes Beispielskript.

#!/bin/bash

clear
echo 'Choose how many digits you want for port# (1-5)'
read PORT

NUM_1="$(tr -dc '0-9' </dev/urandom | head -c $PORT)"

echo "$NUM_1"

if [ "$PORT" -gt "5" ]
then
clear
echo -e "\x1b[31m Choose a number between 1 and 5! \x1b[0m"
sleep 3
clear
exit 0
fi