Losowa liczba z zakresu w skrypcie Bash

Muszę wygenerować losowy numer portu pomiędzy 2000-65000skryptem powłoki. Problemem jest $RANDOM15-bitowa liczba, więc utknąłem!

PORT=$(($RANDOM%63000+2001)) działałby ładnie, gdyby nie ograniczenie wielkości.

Czy ktoś ma przykład, w jaki sposób mogę to zrobić, może poprzez wyciągnięcie czegoś /dev/urandomi umieszczenie go w zasięgu?

shuf -i 2000-65000 -n 1

Cieszyć się!

Edycja : zakres obejmuje.

W systemach Mac OS X i FreeBSD możesz także użyć jot:

jot -r 1  2000 65000

Według strony podręcznika bash, $RANDOMjest on dystrybuowany między 0 a 32767; to jest 15-bitowa wartość bez znaku. Zakładając, że $RANDOMjest równomiernie rozłożona, możesz utworzyć równomiernie rozłożoną 30-bitową liczbę całkowitą bez znaku w następujący sposób:

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

Ponieważ twój zakres nie jest potęgą 2, prosta operacja modulo da prawie tylko jednolity rozkład, ale z 30-bitowym zakresem wejściowym i mniej niż 16-bitowym zakresem wyjściowym, jak masz w tym przypadku, to naprawdę powinno być wystarczająco blisko:

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

a oto jeden z Pythonem

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

i jeden z awk

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

Najprostszym ogólnym sposobem, jaki przychodzi mi na myśl, jest perl-one-liner:

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

Zawsze możesz po prostu użyć dwóch liczb:

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

Nadal musisz przyciąć swój zasięg. To nie jest ogólna n-bitowa metoda liczb losowych, ale zadziała w twoim przypadku i wszystko jest w środku.

Jeśli chcesz być naprawdę słodki i czytać z / dev / urandom, możesz to zrobić:

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

To przeczyta dwa bajty i wydrukuje je jako int bez znaku; nadal musisz zrobić wycinek.

Jeśli nie jesteś ekspertem od bashów i chciałeś zamienić to na zmienną w skrypcie bash opartym na Linuksie, spróbuj tego:

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

To daje zakres od 200 do 700 $VARwłącznie.

Oto kolejny. Myślałem, że zadziała na wszystko, ale losowa opcja sortowania nie jest dostępna na moim polu centos w pracy.

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

$RANDOMjest liczbą od 0 do 32767. Chcesz mieć port między 2000 a 65000. Są to 63001 możliwych portów. Jeśli będziemy trzymać się wartości $RANDOM + 2000między 2000 a 33500 , omówimy szereg 31501 portów. Jeśli przerzucimy monetę, a następnie warunkowo dodamy 31501 do wyniku, możemy uzyskać więcej portów, od 33501 do 65001 . Jeśli po prostu upuszczymy 65001, otrzymamy dokładnie wymagany zasięg, z jednolitym rozkładem prawdopodobieństwa dla wszystkich portów, wydaje się.

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
}

Testowanie

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

Możesz to zrobić

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

Jeśli potrzebujesz więcej informacji, zobacz Generator liczb losowych w skrypcie powłoki .

To samo z rubinem:

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

Dokumentacja Bash mówi, że przy każdym $RANDOModwołaniu zwracana jest losowa liczba od 0 do 32767. Jeśli zsumujemy dwa kolejne odniesienia, otrzymamy wartości od 0 do 65534, co obejmuje pożądany zakres 63001 możliwości dla liczby losowej między 2000 a 65000.

Aby dostosować go do dokładnego zakresu, używamy sumy modulo 63001, która da nam wartość od 0 do 63000. To z kolei potrzebuje tylko przyrostu o 2000, aby zapewnić pożądaną liczbę losową, między 2000 a 65000. Może to być podsumowane w następujący sposób:

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

Testowanie

# 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

Poprawność obliczeń

Oto pełny, brutalny test poprawności obliczeń. Ten program próbuje po prostu losowo wygenerować wszystkie 63001 różnych możliwości, wykorzystując testowane obliczenia. Ten --jobsparametr powinien przyspieszyć jego działanie, ale nie jest deterministyczny (suma wygenerowanych możliwości może być mniejsza niż 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

Aby ustalić, ile iteracji jest potrzebnych do uzyskania danego prawdopodobieństwa p/qwygenerowania wszystkich 63001 możliwości, uważam, że możemy użyć poniższego wyrażenia. Na przykład tutaj jest obliczenie dla prawdopodobieństwa większego niż 1/2 , a tutaj dla większego niż 9/10 .

Lub w systemie OS-X następujące funkcje działają dla mnie:

$ gsort --random-sort

PORT=$(($RANDOM%63000+2001)) myślę, że jest blisko tego, czego chcesz.

PORT=$(($RANDOM$RANDOM$RANDOM%63000+2001))omija ograniczenie rozmiaru, które Cię niepokoi. Ponieważ bash nie rozróżnia między zmienną liczbową a zmienną łańcuchową, działa to doskonale. „Liczba” $RANDOMmoże być łączona jak ciąg, a następnie używana jako liczba w obliczeniach. Niesamowity!

Możesz uzyskać losową liczbę poprzez urandom

head -200 /dev/urandom | cksum

Wynik:

3310670062 52870

Aby pobrać jedną część powyższego numeru.

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

Następnie wyjście jest

3310670062

Aby spełnić twoje wymagania,

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

W ten sposób zwykle generuję liczby losowe. Następnie używam „NUM_1” jako zmiennej dla używanego numeru portu. Oto krótki przykładowy skrypt.

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