Número aleatório de um intervalo em um Script Bash

Eu preciso gerar um número de porta aleatória entre 2000-65000um script de shell. O problema é que $RANDOMé um número de 15 bits, então estou preso!

PORT=$(($RANDOM%63000+2001)) funcionaria bem se não fosse pela limitação de tamanho.

Alguém tem um exemplo de como eu posso fazer isso, talvez extraindo algo /dev/urandome colocando-o dentro de um intervalo?

shuf -i 2000-65000 -n 1

Aproveitar!

Editar : o intervalo é inclusivo.

No Mac OS X e no FreeBSD, você também pode usar o jot:

jot -r 1  2000 65000

De acordo com a página do manual do bash, $RANDOMé distribuído entre 0 e 32767; isto é, é um valor de 15 bits não assinado. Supondo que $RANDOMseja distribuído uniformemente, você pode criar um número inteiro de 30 bits não assinado e distribuído uniformemente da seguinte maneira:

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

Como seu alcance não é 2, uma operação simples do módulo fornecerá quase uma distribuição uniforme, mas com um intervalo de entrada de 30 bits e um intervalo de saída inferior a 16 bits, como no seu caso, isso realmente deve estar perto o suficiente:

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

e aqui está um com Python

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

e um com awk

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

A maneira geral mais simples que vem à mente é uma linha de código perl:

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

Você sempre pode usar apenas dois números:

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

Você ainda precisa recortar no seu alcance. Não é um método geral de números aleatórios de n bits, mas funcionará no seu caso e está tudo dentro do bash.

Se você quiser ser realmente engraçado e ler em / dev / urandom, faça o seguinte:

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

Isso lerá dois bytes e os imprimirá como um int não assinado; você ainda precisa fazer o seu recorte.

Se você não é um especialista em bash e pretendia colocar isso em uma variável em um script bash baseado em Linux, tente o seguinte:

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

Isso leva a uma faixa de 200 a 700 $VAR, inclusive.

Aqui está mais um. Eu pensei que iria funcionar em praticamente qualquer coisa, mas a opção aleatória de sort não está disponível na minha caixa de centos no trabalho.

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

$RANDOMé um número entre 0 e 32767. Você deseja uma porta entre 2000 e 65000. Essas são 63001 portas possíveis. Se mantivermos valores $RANDOM + 2000entre 2000 e 33500 , cobriremos um intervalo de 31501 portas. Se jogarmos uma moeda e adicionarmos condicionalmente 31501 ao resultado, obteremos mais portas, de 33501 a 65001 . Então, se abandonarmos 65001, obteremos a cobertura exata necessária, com uma distribuição de probabilidade uniforme para todas as portas, ao que 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
}

Teste

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

Você consegue fazer isso

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

Se você precisar de mais detalhes, consulte Gerador de números aleatórios de scripts de shell .

Mesmo com ruby:

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

A documentação do Bash diz que sempre$RANDOM é referenciada, um número aleatório entre 0 e 32767 é retornado. Se somarmos duas referências consecutivas, obtemos valores de 0 a 65534, que cobrem o intervalo desejado de 63001 possibilidades para um número aleatório entre 2000 e 65000.

Para ajustá-lo ao intervalo exato, usamos o módulo de soma 63001, que fornecerá um valor de 0 a 63000. Isso, por sua vez, só precisa de um incremento de 2000 para fornecer o número aleatório desejado, entre 2000 e 65000. Isso pode ser resumidos da seguinte forma:

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

Teste

# 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

Correção do cálculo

Aqui está um teste completo de força bruta para a correção do cálculo. Este programa apenas tenta gerar todas as 63001 possibilidades diferentes aleatoriamente, usando o cálculo em teste. O --jobsparâmetro deve torná-lo mais rápido, mas não é determinístico (o total de possibilidades geradas pode ser menor que 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 quantas iterações são necessárias para obter uma determinada probabilidade p/qde todas as 63001 possibilidades terem sido geradas, acredito que podemos usar a expressão abaixo. Por exemplo, aqui está o cálculo para uma probabilidade maior que 1/2 e aqui para maior que 9/10 .

Ou no OS-X, o seguinte funciona para mim:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) está perto do que você quer, eu acho.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))contorna a limitação de tamanho que o incomoda. Como o bash não faz distinções entre uma variável numérica e uma variável de sequência, isso funciona perfeitamente bem. O "número" $RANDOMpode ser concatenado como uma string e, em seguida, usado como um número em um cálculo. Surpreendente!

Você pode obter o número aleatório através urandom

head -200 /dev/urandom | cksum

Resultado:

3310670062 52870

Para recuperar a parte do número acima.

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

Então a saída é

3310670062

Para cumprir sua exigência,

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

É assim que costumo gerar números aleatórios. Então eu uso "NUM_1" como a variável para o número da porta que eu uso. Aqui está um pequeno exemplo 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