Número aleatorio de un rango en un script Bash

Necesito generar un número de puerto aleatorio entre 2000-65000un script de shell. El problema es$RANDOM es un número de 15 bits, ¡así que estoy atascado!

PORT=$(($RANDOM%63000+2001)) funcionaría bien si no fuera por la limitación de tamaño.

¿Alguien tiene un ejemplo de cómo puedo hacer esto, tal vez extrayendo algo /dev/urandomy poniéndolo dentro de un rango?

shuf -i 2000-65000 -n 1

¡Disfrutar!

Editar : el rango es inclusivo.

En Mac OS X y FreeBSD también puede usar jot:

jot -r 1  2000 65000

Según la página de manual de bash, $RANDOMse distribuye entre 0 y 32767; es decir, es un valor de 15 bits sin signo. Suponiendo que $RANDOMse distribuye uniformemente, puede crear un entero de 30 bits sin signo distribuido uniformemente de la siguiente manera:

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

Debido a que su rango no es una potencia de 2, un simple operación de módulo sólo será casi le dan una distribución uniforme, pero con un rango de entrada de 30 bits y un rango de salida de menos-que-16 bits, ya que tiene en su caso, esto realmente debería estar lo suficientemente cerca:

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

y aquí hay uno con Python

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

y uno con awk

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

La forma general más simple que me viene a la mente es una línea perl:

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

Siempre puedes usar dos números:

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

Todavía tiene que recortar a su rango. No es un método general de números aleatorios de n bits, pero funcionará para su caso, y todo está dentro de bash.

Si quieres ser realmente lindo y leer desde / dev / urandom, puedes hacer esto:

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

Eso leerá dos bytes y los imprimirá como un int sin signo; todavía tienes que hacer tu recorte.

Si no eres un experto en bash y estabas buscando convertir esto en una variable en un script bash basado en Linux, prueba esto:

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

Eso te da el rango de 200 a 700 $VAR, inclusive.

Aqui hay otro más. Pensé que funcionaría en casi cualquier cosa, pero la opción aleatoria de ordenar no está disponible en mi caja de centos en el trabajo.

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

$RANDOMes un número entre 0 y 32767. Desea un puerto entre 2000 y 65000. Estos son 63001 puertos posibles. Si nos atenemos a valores $RANDOM + 2000entre 2000 y 33500 , cubrimos un rango de 31501 puertos. Si lanzamos una moneda y luego agregamos condicionalmente 31501 al resultado, podemos obtener más puertos, de 33501 a 65001 . Entonces, si simplemente dejamos caer 65001, obtenemos la cobertura exacta necesaria, con una distribución de probabilidad uniforme para todos los puertos, parece.

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
}

Pruebas

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

Puedes hacerlo

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

Si necesita más detalles, consulte Shell Script Random Number Generator .

Lo mismo con el rubí:

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

La documentación de Bash dice que cada vez$RANDOM se hace referencia, se devuelve un número aleatorio entre 0 y 32767. Si sumamos dos referencias consecutivas, obtenemos valores de 0 a 65534, que cubren el rango deseado de 63001 posibilidades para un número aleatorio entre 2000 y 65000.

Para ajustarlo al rango exacto, utilizamos el módulo de suma 63001, que nos dará un valor de 0 a 63000. Esto a su vez solo necesita un incremento en 2000 para proporcionar el número aleatorio deseado, entre 2000 y 65000. Esto puede ser resumido de la siguiente manera:

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

Pruebas

# 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

Corrección del cálculo.

Aquí hay una prueba completa de fuerza bruta para la exactitud del cálculo. Este programa solo intenta generar todas las 63001 posibilidades diferentes al azar, utilizando el cálculo bajo prueba. El --jobsparámetro debería hacer que se ejecute más rápido, pero no es determinista (el total de posibilidades generadas puede ser inferior 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

Para determinar cuántas iteraciones se necesitan para obtener una probabilidad dada p/qde que se hayan generado todas las posibilidades de 63001, creo que podemos usar la expresión a continuación. Por ejemplo, aquí está el cálculo para una probabilidad mayor que 1/2 , y aquí para mayor que 9/10 .

O en OS-X, lo siguiente funciona para mí:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) está cerca de lo que quieres, creo.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))evita la limitación de tamaño que te preocupa. Como bash no hace distinciones entre una variable numérica y una variable de cadena, esto funciona perfectamente bien. El "número" $RANDOMpuede concatenarse como una cadena, y luego usarse como un número en un cálculo. ¡Asombroso!

Puede obtener el número aleatorio a través de urandom

head -200 /dev/urandom | cksum

Salida:

3310670062 52870

Para recuperar la parte del número anterior.

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

Entonces la salida es

3310670062

Para cumplir con sus requisitos,

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

Así es como generalmente genero números aleatorios. Luego uso "NUM_1" como la variable para el número de puerto que uso. Aquí hay un breve script de ejemplo.

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