Numero casuale da un intervallo in uno script Bash

Devo generare un numero di porta casuale tra 2000-65000uno script di shell. Il problema è che $RANDOMun numero di 15 bit, quindi sono bloccato!

PORT=$(($RANDOM%63000+2001)) funzionerebbe bene se non fosse per la limitazione delle dimensioni.

Qualcuno ha un esempio di come posso farlo, magari estraendo qualcosa /dev/urandome facendolo rientrare in un intervallo?

shuf -i 2000-65000 -n 1

Godere!

Modifica : l'intervallo è inclusivo.

Su Mac OS X e FreeBSD puoi anche usare jot:

jot -r 1  2000 65000

Secondo la pagina man di bash, $RANDOMè distribuito tra 0 e 32767; cioè, è un valore senza segno a 15 bit. Supponendo che $RANDOMsia distribuito uniformemente, è possibile creare un intero senza segno a 30 bit distribuito uniformemente come segue:

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

Poiché il tuo intervallo non è una potenza di 2, una semplice operazione modulo ti darà quasi una distribuzione uniforme, ma con un intervallo di input di 30 bit e un intervallo di output inferiore a 16 bit, come nel tuo caso, questo dovrebbe davvero essere abbastanza vicino:

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

ed eccone uno con Python

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

e uno con awk

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

Il modo generale più semplice che viene in mente è un perl one-liner:

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

Puoi sempre usare solo due numeri:

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

Devi ancora agganciare al tuo intervallo. Non è un metodo numerico casuale n-bit, ma funzionerà per il tuo caso, ed è tutto all'interno di bash.

Se vuoi essere davvero carino e leggere da / dev / urandom, puoi farlo:

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

Questo leggerà due byte e li stamperà come un int senza segno; devi ancora fare il ritaglio.

Se non sei un esperto di bash e stavi cercando di inserirlo in una variabile in uno script bash basato su Linux, prova questo:

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

Questo ti porta nell'intervallo compreso tra 200 e 700 $VARinclusi.

Eccone un altro. Ho pensato che avrebbe funzionato praticamente su qualsiasi cosa, ma l'opzione casuale di sort non è disponibile sul mio centos box al lavoro.

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

$RANDOMè un numero compreso tra 0 e 32767. Si desidera una porta tra 2000 e 65000. Sono 63001 possibili porte. Se manteniamo valori compresi $RANDOM + 2000tra 2000 e 33500 , copriamo un intervallo di 31501 porte. Se lanciamo una moneta e quindi aggiungiamo condizionalmente 31501 al risultato, possiamo ottenere più porte, da 33501 a 65001 . Quindi se lasciamo cadere 65001, otteniamo l'esatta copertura necessaria, con una distribuzione di probabilità uniforme per tutte le porte, a quanto pare.

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
}

analisi

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

Puoi farlo

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

Se hai bisogno di maggiori dettagli vedi Generatore di numeri casuali di Shell Script .

Lo stesso con il rubino:

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

La documentazione di Bash afferma che ogni volta che $RANDOMviene fatto riferimento, viene restituito un numero casuale compreso tra 0 e 32767. Se sommiamo due riferimenti consecutivi, otteniamo valori da 0 a 65534, che copre l'intervallo desiderato di 63001 possibilità per un numero casuale compreso tra 2000 e 65000.

Per adattarlo all'intervallo esatto, utilizziamo la somma modulo 63001, che ci darà un valore compreso tra 0 e 63000. Ciò a sua volta richiede solo un incremento di 2000 per fornire il numero casuale desiderato, tra 2000 e 65000. Questo può essere riassunto come segue:

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

analisi

# 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

Correttezza del calcolo

Ecco un test completo a forza bruta per la correttezza del calcolo. Questo programma cerca solo di generare casualmente tutte le 63001 diverse possibilità, usando il calcolo sotto test. Il --jobsparametro dovrebbe renderlo più veloce, ma non è deterministico (il totale delle possibilità generate potrebbe essere inferiore a 63001).

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

Per determinare quante iterazioni sono necessarie per ottenere una determinata probabilità che p/qsiano state generate tutte le 63001 possibilità, credo che possiamo usare l'espressione sotto. Ad esempio, ecco il calcolo per una probabilità maggiore di 1/2 e qui per maggiore di 9/10 .

O su OS-X funziona per me:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) è vicino a quello che vuoi, penso.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))aggira la limitazione dimensionale che ti disturba. Poiché bash non fa distinzioni tra una variabile numerica e una variabile stringa, questo funziona perfettamente. Il "numero" $RANDOMpuò essere concatenato come una stringa e quindi utilizzato come numero in un calcolo. Sorprendente!

Puoi ottenere il numero casuale attraverso urandom

head -200 /dev/urandom | cksum

Produzione:

3310670062 52870

Per recuperare una parte del numero sopra.

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

Quindi l'output è

3310670062

Per soddisfare le vostre esigenze,

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

Ecco come di solito generi numeri casuali. Quindi uso "NUM_1" come variabile per il numero di porta che utilizzo. Ecco un breve script di esempio.

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