After googling a bit I couldn't find a simple way to use a shell command to generate a random decimal integer number included in a specific range, that is between a minimum and a maximum.
I read about /dev/random, /dev/urandom and $RANDOM, but none of these can do what I need.
Is there another useful command, or a way to use the previous data?
You can try shuf from GNU coreutils:
shuf -i 1-100 -n 1
In the POSIX toolchest, you can use awk:
awk -v min=5 -v max=10 'BEGIN{srand(); print int(min+rand()*(max-min+1))}'
Do not use that as a source to generate passwords or secret data for instance, as with most awk implementations, the number can easily be guessed based on the time that command was run.
With many awk implementations, that command run twice within the same second will generally give you the same output.
On BSD and OSX you can use jot to return a single random (-r) number from the interval min to max, inclusive.
$ min=5
$ max=10
$ jot -r 1 $min $max
Unfortunately, the range and distribution of randomly generated numbers is influenced by the fact that jot uses double precision floating point arithmetic internally and printf(3) for output format, which causes rounding and truncation issues. Therefore, the interval's min and max are generated less frequently as demonstrated:
$ jot -r 100000 5 10 | sort -n | uniq -c
9918 5
20176 6
20006 7
20083 8
19879 9
9938 10
On OS X 10.11 (El Capitan) this appears to have been fixed:
$ jot -r 100000 5 10 | sort -n | uniq -c
16692 5
16550 6
16856 7
16579 8
16714 9
16609 10
and...
$ jot -r 1000000 1 10 | sort -n | uniq -c
100430 1
99965 2
99982 3
99796 4
100444 5
99853 6
99835 7
100397 8
99588 9
99710 10
For older versions of OS X, fortunately there are several workarounds. One is to use printf(3) integer conversion. The only caveat is that the interval maximum now becomes max+1. By using integer formatting, we get fair distribution across the entire interval:
$ jot -w %i -r 100000 5 11 | sort -n | uniq -c
16756 5
16571 6
16744 7
16605 8
16683 9
16641 10
Finally, to get a fair roll of the dice using the workaround, we have:
$ min=5
$ max_plus1=11 # 10 + 1
$ jot -w %i -r 1 $min $max_plus1
See jot(1) for the gory math and formatting details and many more examples.
The $RANDOM variable is normally not a good way to generated good random values. The output of /dev/[u]random need also to be converted first.
An easier way is to use higher level languages, like e.g. python:
To generate a random integer variable between 5 and 10 (5<=N<=10), use
python -c "import random; print random.randint(5,10)"
Do not use this for cryptographic applications.
You can get the random number through urandom
head -200 /dev/urandom | cksum
Output:
3310670062 52870
To retrieve the one part of the above number.
head -200 /dev/urandom | cksum | cut -f1 -d " "
Then the output is
3310670062
To generate a random integer variable between 5 and 10 (including both), use
echo $(( RANDOM % (10 - 5 + 1 ) + 5 ))
% works as a modulo operator.
There are probably better ways to convert the random variable $RANDOM to a specific range. Do not use this for cryptographic applications or in cases you need real, equal-distributed random variables (like for simulations).
# echo $(( $RANDOM % 256 )) will produce a "random" number between 0-255 in modern *sh dialects.
Maybe the UUID (on Linux) can be used to retrieve the random number
$ cat /proc/sys/kernel/random/uuid
cdd52826-327d-4355-9737-895f58ad11b4
To get the random number between 70 and 100
POSIXLY_CORRECT=1 awk -F - '{print(("0x"$1) % 30 + 70)}
' /proc/sys/kernel/random/uuid
cat /dev/urandom | tr -dc 'a-fA-F0-9' | fold -w 8 | head -n 1
This will generate an 8 digits long hexadecimal number.
Distribution is good:
for (( i = 1 ; i <= 100000 ; i++ )) do echo $(( RANDOM % (20 - 10 + 1 ) + 10 )) ; done | sort -n | uniq -c
Gives:
count value
9183 10
9109 11
8915 12
9037 13
9100 14
9138 15
9125 16
9261 17
9088 18
8996 19
9048 20
To stay entirely within bash and use the $RANDOM variable but avoid the uneven distribution:
#!/bin/bash
range=10
floor=20
if [ $range -gt 32768 ]; then
echo 'range outside of what $RANDOM can provide.' >&2
exit 1 # exit before entering infinite loop
fi
max_RANDOM=$(( 2**15/$range*$range ))
r=$RANDOM
until [ $r -lt $max_RANDOM ]; do
r=$RANDOM
done
echo $(( r % $range + $floor ))
This example would provide random numbers from 20 through 29.
Explanation: Any $RANDOM result greater than 2**15/$range*$range is in an incomplete modulus fold within which the result of $r % $range has a max value of 2**15%$range, so results from 0 to 2**15%$range have weight of 2**15/$range+1 and the value above have a weight of just 2**15/$range. The worst case scenario of the poor distribution is when the 2**15/$range is 1 and 2**15%$range is not 0. Here, we can see clearly the problem when the range is 2/3 of 2**15, where half the results have twice the probability:
$ range=$((2**15*2/3)); for (( i=0; i<10000; i++)); \
> do [ $((RANDOM%range) -le $((range/2)) ] \
> && ((le_10922++)) || ((gt_10922++)) ; done; \
> echo le_10922 $le_10922; echo gt_10922 $gt_10922
le_10922 6748
gt_10922 3253
Using RANDOM
MAX=999999 #Upper Range
MIN=100000 #Lower Range
DIFF=$((MAX-MIN+1)) #+1 to inlcude upper limit
R=$(($(($RANDOM%$DIFF))+MIN))
Using SHUF
MIN=1000
MAX=9999
COUNT=1 #count of Random Numbers to be generated
shuf -i $MIN-$MAX -n $COUNT
shuf -i 1000-9999 -n 1
Using /dev/random
od -An -N2 -i /dev/random #Generates a 2 byte Number, -N2=Generates 2 Random Number btween range 0-65535
