Nombre aléatoire d'une plage dans un script Bash

J'ai besoin de générer un numéro de port aléatoire entre 2000-65000un script shell. Le problème est $RANDOMun nombre de 15 bits, donc je suis coincé!

PORT=$(($RANDOM%63000+2001)) fonctionnerait bien sans la limitation de taille.

Quelqu'un at-il un exemple de la façon dont je peux le faire, peut-être en extrayant quelque chose /dev/urandomet en le plaçant dans une plage?

shuf -i 2000-65000 -n 1

Prendre plaisir!

Edit : la gamme est inclusive.

Sur Mac OS X et FreeBSD, vous pouvez également utiliser jot:

jot -r 1  2000 65000

Selon la page de manuel bash, $RANDOMest répartie entre 0 et 32767; c'est-à-dire qu'il s'agit d'une valeur non signée de 15 bits. En supposant que la $RANDOMdistribution est uniforme, vous pouvez créer un entier non signé de 30 bits uniformément distribué comme suit:

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

Étant donné que votre plage n'est pas une puissance de 2, une simple opération modulo ne vous donnera quasiment qu'une distribution uniforme, mais avec une plage d'entrée de 30 bits et une plage de sortie inférieure à 16 bits, comme vous l'avez dans votre cas, cela devrait vraiment être assez proche:

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

et en voici un avec Python

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

et un avec awk

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

La manière générale la plus simple qui me vient à l'esprit est un perl one-liner:

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

Vous pouvez toujours simplement utiliser deux nombres:

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

Vous devez toujours couper à votre portée. Ce n'est pas une méthode générale de nombre aléatoire à n bits, mais cela fonctionnera pour votre cas, et tout est dans bash.

Si vous voulez être vraiment mignon et lire dans / dev / urandom, vous pouvez le faire:

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

Cela lira deux octets et les imprimera comme un entier non signé; vous devez toujours faire votre coupure.

Si vous n'êtes pas un expert bash et que vous cherchiez à l'intégrer dans une variable dans un script bash basé sur Linux, essayez ceci:

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

Cela vous fait passer de 200 à 700 $VAR, inclus.

En voici un autre. Je pensais que cela fonctionnerait sur à peu près n'importe quoi, mais l'option aléatoire de sort n'est pas disponible sur ma boîte centos au travail.

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

$RANDOMest un nombre compris entre 0 et 32767. Vous voulez un port entre 2000 et 65000. Ce sont 63001 ports possibles. Si nous nous en tenons à des valeurs $RANDOM + 2000comprises entre 2000 et 33500 , nous couvrons une gamme de 31501 ports. Si nous lançons une pièce puis ajoutons conditionnellement 31501 au résultat, nous pouvons obtenir plus de ports, de 33501 à 65001 . Ensuite, si nous supprimons simplement 65001, nous obtenons la couverture exacte nécessaire, avec une distribution de probabilité uniforme pour tous les ports, semble-t-il.

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
}

Essai

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

Tu peux le faire

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

Si vous avez besoin de plus de détails, consultez Générateur de nombres aléatoires de script Shell .

Même chose avec le rubis:

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

La documentation de Bash indique que chaque fois qu'il $RANDOMest référencé, un nombre aléatoire compris entre 0 et 32767 est renvoyé. Si nous additionnons deux références consécutives, nous obtenons des valeurs de 0 à 65534, ce qui couvre la plage souhaitée de 63001 possibilités pour un nombre aléatoire entre 2000 et 65000.

Pour l'ajuster à la plage exacte, nous utilisons la somme modulo 63001, qui nous donnera une valeur de 0 à 63000. Cela à son tour a juste besoin d'un incrément de 2000 pour fournir le nombre aléatoire souhaité, entre 2000 et 65000. Cela peut être résumées comme suit:

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

Essai

# 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

Exactitude du calcul

Voici un test complet de force brute pour l'exactitude du calcul. Ce programme essaie simplement de générer toutes les 63001 possibilités différentes au hasard, en utilisant le calcul sous test. Le --jobsparamètre devrait le faire fonctionner plus rapidement, mais il n'est pas déterministe (le total des possibilités générées peut être inférieur à 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

Pour déterminer combien d'itérations sont nécessaires pour obtenir une probabilité donnée que p/qtoutes les possibilités 63001 aient été générées, je pense que nous pouvons utiliser l'expression ci-dessous. Par exemple, voici le calcul pour une probabilité supérieure à 1/2 , et ici pour supérieure à 9/10 .

Ou sur OS-X, les travaux suivants me conviennent:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) est proche de ce que tu veux je pense.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))contourne la limitation de taille qui vous dérange. Étant donné que bash ne fait aucune distinction entre une variable numérique et une variable chaîne, cela fonctionne parfaitement bien. Le "nombre" $RANDOMpeut être concaténé comme une chaîne, puis utilisé comme nombre dans un calcul. Incroyable!

Vous pouvez obtenir le nombre aléatoire via urandom

head -200 /dev/urandom | cksum

Production:

3310670062 52870

Pour récupérer la partie du numéro ci-dessus.

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

Ensuite, la sortie est

3310670062

Pour répondre à votre besoin,

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

C'est ainsi que je génère habituellement des nombres aléatoires. Ensuite, j'utilise "NUM_1" comme variable pour le numéro de port que j'utilise. Voici un court exemple de script.

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