shell教程
OutOfMemory.CN技术专栏-> shell-> shell教程-> 9.6. $RANDOM: 产生随机整数

9.6. $RANDOM: 产生随机整数

$RANDOM是Bash的一个返回伪随机[1]整数(范围为0-32767)的内部函数(而不是一个常量或变量),它不应该用于产生加密的密钥.例子9-24.产生随机整数#!/bin/bash#每次调用$RANDOM都会返回不同的随机整数.#范围为:0-32767(带符号的16位整数).MAXCOUNT=10count=1echoecho"$MAXCOUNTrandomnumbers:"echo"---

$RANDOM是Bash的一个返回伪随机 [1]整数(范围为0 - 32767)的内部函数(而不是一个常量或变量),它不应该用于产生加密的密钥.


例子 9-24. 产生随机整数

#!/bin/bash

# 每次调用$RANDOM都会返回不同的随机整数.
# 范围为: 0 - 32767 (带符号的16位整数).

MAXCOUNT=10
count=1

echo
echo "$MAXCOUNT random numbers:"
echo "-----------------"
while [ "$count" -le $MAXCOUNT ]      # 产生10($MAXCOUNT)个随机整数.
do
  number=$RANDOM
  echo $number
  let "count += 1"  # 增加计数.
done
echo "-----------------"

# 如果你需要某个范围的随机整数,可以使用取模操作符.(译者注:事实上,这不是一个非常好的办法。理由请见man 3 rand)
# 取模操作会返回除法的余数.

RANGE=500

echo

number=$RANDOM
let "number %= $RANGE"
#           ^^
echo "Random number less than $RANGE  ---  $number"

echo



#  如果你需要一个大于某个下限的随机整数,
#+ 应该增加测试以便抛弃所有小于此下限值的数值.

FLOOR=200

number=0   #初始化
while [ "$number" -le $FLOOR ]
do
  number=$RANDOM
done
echo "Random number greater than $FLOOR ---  $number"
echo

   # 让我们检测另外一个完成上面循环作用的简单办法,即
   #       let "number = $RANDOM + $FLOOR"
   # 这能避免了while循环,并且运行得更快。
   # 但,使用这个技术可能会产生问题,思考一下是什么问题?



# 联合上面两个技巧重新产生在两个限制值之间的随机整数.
number=0   #初始化
while [ "$number" -le $FLOOR ]
do
  number=$RANDOM
  let "number %= $RANGE"  # Scales $number down within $RANGE.
done
echo "Random number between $FLOOR and $RANGE ---  $number"
echo



# 产生二元值,即"真"或"假".
BINARY=2
T=1
number=$RANDOM

let "number %= $BINARY"
#  注意    let "number >>= 14"    会产生更平均的随机分布   #(译者注:正如在man手册里提到的,更高位的随机分布更平均,
#+ (除了最后的二元值右移出所有的值).                       #取模操作使用低位来产生随机会相对不平均)
if [ "$number" -eq $T ]
then
  echo "TRUE"
else
  echo "FALSE"
fi

echo


# 模拟掷骰子.
SPOTS=6   # 模除 6 会产生 0 - 5 之间的值.
          # 结果增1会产生 1 - 6 之间的值.
          # 多谢Paulo Marcel Coelho Aragao的简化.
die1=0
die2=0
# 这会比仅设置SPOTS=7且不增1好?为什么会好?为什么会不好?

# 单独地掷每个骰子,然后计算出正确的机率.

    let "die1 = $RANDOM % $SPOTS +1" # 掷第一个.
    let "die2 = $RANDOM % $SPOTS +1" # 掷第二个.
    #  上面的算术式中,哪个操作符优先计算 --
    #+ 取模 (%) 还是 加法 (+)?


let "throw = $die1 + $die2"
echo "Throw of the dice = $throw"
echo


exit 0


例子 9-25. 模拟从一副纸牌里随机抽一张纸牌

#!/bin/bash
# pick-card.sh

# 这是从一个数组中随机选择元素的例子.


# 抽出一张任意牌.

Suites="Clubs
Diamonds
Hearts
Spades"

Denominations="2
3
4
5
6
7
8
9
10
Jack
Queen
King
Ace"

# 注意变量值由多行组成.


suite=($Suites)                # 读入一个数组.
denomination=($Denominations)

num_suites=${#suite[*]}        # 计算有几个数组元素.
num_denominations=${#denomination[*]}

echo -n "${denomination[$((RANDOM%num_denominations))]} of "
echo ${suite[$((RANDOM%num_suites))]}


# $bozo sh pick-cards.sh
# Jack of Clubs


# 多谢"jipe,"指出$RANDOM的这个用法.
exit 0

Jipe 指出了一套技巧来产生一个范围里的随机数。

#  产生 6 和 30之间的随机数.
   rnumber=$((RANDOM%25+6))

#  产生在 6 - 30 之间的随机数,
#+ 但随机数还同时要满足被3整除.
   rnumber=$(((RANDOM%30/3+1)*3))

#  注意这将始终不能工作.
#  如果$RANDOM返回0,它就会失败.

#  Frank Wang建议用下面的办法:
   rnumber=$(( RANDOM%27/3*3+6 ))

Bill Gradwohl 提出一个改良的公式,这个公式只用于正数.

rnumber=$(((RANDOM%(max-min+divisibleBy))/divisibleBy*divisibleBy+min))

上面Bill展示了一个通用的函数,它可以返回两个指定值之间的随机数。


例子 9-26. 指定值之间的随机数

#!/bin/bash
# random-between.sh
# 产生两个指定值之间的随机数.
# 由Bill Gradwohl编写,并由本书作者作了些许修改.
# 已得到程序作者的许可.


randomBetween() {
   #  产生在$min和$max之前的正或负的随机数
   #+ 并且能被$divisibleBy整数除.
   #
   #  给出一个合理的随机分配的返回值.
   #
   #  Bill Gradwohl - Oct 1, 2003

   syntax() {
   # 在函数中内嵌函数
      echo
      echo    "Syntax: randomBetween [min] [max] [multiple]"
      echo
      echo    "Expects up to 3 passed parameters, but all are completely optional."
      echo    "min is the minimum value"
      echo    "max is the maximum value"
      echo    "multiple specifies that the answer must be a multiple of this value."
      echo    "    i.e. answer must be evenly divisible by this number."
      echo
      echo    "If any value is missing, defaults area supplied as: 0 32767 1"
      echo    "Successful completion returns 0, unsuccessful completion returns"
      echo    "function syntax and 1."
      echo    "The answer is returned in the global variable randomBetweenAnswer"
      echo    "Negative values for any passed parameter are handled correctly."
   }

   local min=${1:-0}
   local max=${2:-32767}
   local divisibleBy=${3:-1}
   # 默认值分配,用来处理没有参数传递进来的时候.

   local x
   local spread

   # 确认divisibleBy是正值.
   [ ${divisibleBy} -lt 0 ] && divisibleBy=$((0-divisibleBy))

   # 完整性检查.
   if [ $# -gt 3 -o ${divisibleBy} -eq 0 -o  ${min} -eq ${max} ]; then
      syntax
      return 1
   fi

   # 察看是否min和max颠倒了.
   if [ ${min} -gt ${max} ]; then
      # Swap them.
      x=${min}
      min=${max}
      max=${x}
   fi

   #  如果min自己并不能够被$divisibleBy整除,
   #+ 那么就调整min的值,使其能够被$divisibleBy整除,前提是不能放大范围.
   if [ $((min/divisibleBy*divisibleBy)) -ne ${min} ]; then
      if [ ${min} -lt 0 ]; then
         min=$((min/divisibleBy*divisibleBy))
      else
         min=$((((min/divisibleBy)+1)*divisibleBy))
      fi
   fi

   #  如果min自己并不能够被$divisibleBy整除,
   #+ 那么就调整max的值,使其能够被$divisibleBy整除,前提是不能放大范围.
   if [ $((max/divisibleBy*divisibleBy)) -ne ${max} ]; then
      if [ ${max} -lt 0 ]; then
         max=$((((max/divisibleBy)-1)*divisibleBy))
      else
         max=$((max/divisibleBy*divisibleBy))
      fi
   fi

   #  ---------------------------------------------------------------------
   #  现在,来做真正的工作.

   #  注意,为了得到对于端点来说合适的分配,
   #+ 随机值的范围不得不落在
   #+ 0 和 abs(max-min)+divisibleBy之间, 而不是 abs(max-min)+1.

   #  对于端点来说,
   #+ 这个少量的增加将会产生合适的分配.

   #  修改这个公式,使用abs(max-min)+1来代替abs(max-min)+divisibleBy的话,
   #+ 也能够产生正确的答案, 但是在这种情况下生成的随机值对于正好为端点倍数
   #+ 的这种情况来说将是不完美的,因为在正好为端点倍数的情况的随机率比较低,
   #+ 因为你才加1而已,这比正常的公式所产生的机率要小得多(正常为加divisibleBy)
   #  ---------------------------------------------------------------------

   spread=$((max-min))
   [ ${spread} -lt 0 ] && spread=$((0-spread))
   let spread+=divisibleBy
   randomBetweenAnswer=$(((RANDOM%spread)/divisibleBy*divisibleBy+min))

   return 0

   #  然而,Paulo Marcel Coelho Aragao指出
   #+ 当$max和$min不能被$divisibleBy整除时,
   #+ 这个公式将会失败.
   #
   #  他建议使用如下的公式:
   #    rnumber = $(((RANDOM%(max-min+1)+min)/divisibleBy*divisibleBy))

}

# 让我们测试一下这个函数.
min=-14
max=20
divisibleBy=3


#  产生一个数组answers,answers的下标用来表示在范围内可能出现的值,
#+ 而内容记录的是对于这个值出现的次数,如果我们循环足够多次,一定会得到一次出现机会.

declare -a answer
minimum=${min}
maximum=${max}
   if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then
      if [ ${minimum} -lt 0 ]; then
         minimum=$((minimum/divisibleBy*divisibleBy))
      else
         minimum=$((((minimum/divisibleBy)+1)*divisibleBy))
      fi
   fi


   #  如果maximum自己并不能够被$divisibleBy整除,
   #+ 那么就调整maximum的值,使其能够被$divisibleBy整除,前提是不能放大范围.

   if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then
      if [ ${maximum} -lt 0 ]; then
         maximum=$((((maximum/divisibleBy)-1)*divisibleBy))
      else
         maximum=$((maximum/divisibleBy*divisibleBy))
      fi
   fi


#  我们需要产生一个下标全为正的数组,
#+ 所以我们需要一个displacement来保正都为正的结果.


displacement=$((0-minimum))
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
   answer[i+displacement]=0
done


# 现在我们循环足够多的次数来得到我们想要的答案.
loopIt=1000   #  脚本作者建议 100000,
              #+ 但是这实在是需要太长的时间了.

for ((i=0; i<${loopIt}; ++i)); do

   #  注意,我们在这里调用randomBetween函数时,故意将min和max颠倒顺序
   #+ 我们是为了测试在这种情况下,此函数是否还能得到正确的结果.

   randomBetween ${max} ${min} ${divisibleBy}

   # 如果答案不是我们所预期的,那么就报告一个错误.
   [ ${randomBetweenAnswer} -lt ${min} -o ${randomBetweenAnswer} -gt ${max} ] && echo MIN or MAX error - ${randomBetweenAnswer}!
   [ $((randomBetweenAnswer%${divisibleBy})) -ne 0 ] && echo DIVISIBLE BY error - ${randomBetweenAnswer}!

   # 将统计值存到answer之中.
   answer[randomBetweenAnswer+displacement]=$((answer[randomBetweenAnswer+displacement]+1))
done



# 让我们察看一下结果

for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
   [ ${answer[i+displacement]} -eq 0 ] && echo "We never got an answer of $i." || echo "${i} occurred ${answer[i+displacement]} times."
done


exit 0

$RANDOM到底有多随机?最好的办法就是写个脚本来测试一下.跟踪随机数的分配情况.
让我们用随机数摇一个骰子 . . .


例子 9-27. 用RANDOM模拟掷单个骰子

#!/bin/bash
# RANDOM到底有多random?

RANDOM=$$       # 使用脚本的进程ID来作为随机数的产生种子.

PIPS=6          # 一个骰子有6面.
MAXTHROWS=600   # 如果你没别的事干,那么可以增加这个数值.
throw=0         # 抛骰子的次数.

ones=0          # 必须把所有count都初始化为0,
twos=0          #+因为未初始化的变量为null,不是0.
threes=0
fours=0
fives=0
sixes=0

print_result ()
{
echo
echo "ones =   $ones"
echo "twos =   $twos"
echo "threes = $threes"
echo "fours =  $fours"
echo "fives =  $fives"
echo "sixes =  $sixes"
echo
}

update_count()
{
case "$1" in
  0) let "ones += 1";;   # 因为骰子没有0,所以给1.
  1) let "twos += 1";;   # 对tows做同样的事.
  2) let "threes += 1";;
  3) let "fours += 1";;
  4) let "fives += 1";;
  5) let "sixes += 1";;
esac
}

echo


while [ "$throw" -lt "$MAXTHROWS" ]
do
  let "die1 = RANDOM % $PIPS"
  update_count $die1
  let "throw += 1"
done

print_result

exit 0

#  如果RANDOM是真正的随机,那么摇出来结果应该平均的.
#  $MAXTHROWS设为600,那么每面都应该为100,上下的出入不应该超过20.
#
#  记住RANDOM毕竟只是一个伪随机数,
#+ 并且不是十分完美的.

#  随机数的产生是一个深奥并复杂的问题.
#  足够长的随机序列,不但会展现杂乱无章的一面,
#+ 而且会展现机会均等的一面.

# 练习 (容易):
# ---------------
# 重写这个例子,做成抛1000次硬币的形式.
# 分为正反两面.

像我们在上边的例子中看到的,最好在每次随机数产生时都使用新的种子.应为如果使用同样的种子的话,那么随机数将产生相同的序列. [2] (C中random()函数也会有这样的行为.)


例子 9-28. 重新分配随机数种子

#!/bin/bash
# seeding-random.sh: 设置RANDOM变量作为种子.

MAXCOUNT=25       # 决定产生多少个随机数.

random_numbers ()
{
count=0
while [ "$count" -lt "$MAXCOUNT" ]
do
  number=$RANDOM
  echo -n "$number "
  let "count += 1"
done
}

echo; echo

RANDOM=1          # 为随机数的产生设置RANDOM种子.
random_numbers

echo; echo

RANDOM=1          # 设置同样的种子...
random_numbers    # ...将会和上边产生的随机数列相同.
                  #
                  # 复制一个相同的随机数序列在什么时候有用呢?

echo; echo

RANDOM=2          # 再试一下,但这次使用不同的种子...
random_numbers    # 将给出一个不同的随机数序列.

echo; echo

# RANDOM=$$  使用脚本的进程id 作为随机数的种子.
# 从'time'或'date'命令中取得RANDOM作为种子也是很常用的办法.

# 一个有想象力的方法...
SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')
#  首先从/dev/urandom(系统伪随机设备文件)中取出1行,
#+ from /dev/urandom (system pseudo-random device-file),
#+ 然后着这个可打印行转换为(8进制)数,通过使用"od"命令,
#+ 最后使用"awk"来获得一个数.
RANDOM=$SEED
random_numbers

echo; echo

exit 0

/dev/urandom设备文件提供了一种比单独使用$RANDOM更好的,能产生更"随机"的随机数的方法.dd if=/dev/urandom of=targetfile bs=1 count=XX能够产生一个很分散的为随机数.然而,将这个数赋值到一个脚本文件的变量中,还需要可操作性,比如使用"od"命令(就像上边的例子,见Example 12-13),或者使用dd命令(见Example 12-55),或者管道到"md5sum"命令中(见Example 33-14).

当然还有其它的产生伪随机数的方法.Awk就可以提供一个方便的方法.


例子 9-29. 使用awk产生伪随机数

#!/bin/bash
# random2.sh: 产生一个范围0 - 1的为随机数.
# 使用awk的rand()函数.

AWKSCRIPT=' { srand(); print rand() } '
#            Command(s) / 传到awk中的参数
# 注意,srand()函数用来产生awk的随机数种子.


echo -n "Random number between 0 and 1 = "

echo | awk "$AWKSCRIPT"
# 如果你省去'echo'那么将发生什么?

exit 0


# 练习:
# ---------

# 1) 使用循环结构,打印出10个不同的随机数.
#      (提示: 在循环的每次执行过程中,你必须使用"srand()"函数来生成不同的
#+     种子.如果你没做这件事那么将发生什么?

# 2) 使用一个整数乘法作为一个放缩因子,在10到100的范围之间,
#+   来产生随机数.

# 3) 同上边的练习 #2,但这次产生随机整数.

"date"命令也可以用来产生伪随机整数序列.

[1]

真正的随机事件(在它存在的范围内),只发生在特定的几个未知的自然界现象中,比如放射性衰变.计算机只能产生模拟的随机事件,并且计算机产生的"随机"数因此只能称为伪随机数.

[2]

计算机产生的伪随机数序列用的种子可以被看成是一种标识标签.比如,使用种子23所产生的伪随机数序列就被称作序列#23.

一个伪随机序列的特点就是在这个序列开始重复之前的所有元素的个数的和,也就是这个序列的长度.一个好的伪随机产生算法将可以产生一个非常长的不重复的序列.

© 内存溢出 OutOfMemory.CN