PHP rand()排除某些数字

时间:2013-06-14 13:19:39

标签: php

我有这个:

<?php  $n = rand(1,1600); echo $n ?>

我想从随机数中排除让我们说234,1578,763,1274和其他数字。我该怎么做?

10 个答案:

答案 0 :(得分:12)

<?php

while( in_array( ($n = rand(1,1600)), array(234, 1578 ,763 , 1274) ) );

答案 1 :(得分:10)

试试这个

do {   
    $n = rand(1,1600);

} while(in_array($n, array(234, 1578 ,763 , 1274 ));
echo $n;

答案 2 :(得分:8)

检查数字是否是您不想要的数字,如果它是一个新的随机数。

function getRandomNumber() {
    do {
        $n = mt_rand(1,1600);
    } while(in_array($n, array(234,1578, 763, 1274)));

    return $n;
}

答案 3 :(得分:1)

或者避免使用随机(可能无限)的运行时间进行循环:

/**
 * Returns a random integer between $min and $max (inclusive) and
 * excludes integers in $exarr, returns false if no such number
 * exists.
 * 
 * $exarr is assumed to be sorted in increasing order and each
 * element should be unique.
 */
function random_exclude($min, $max, $exarr = array()) {

    if ($max - count($exarr) < $min) {
        return false;
    }

    // $pos is the position that the random number will take
    // of all allowed positions
    $pos = rand(0, $max - $min - count($exarr));

    // $num being the random number
    $num = $min;

    // while $pos > 0, step to the next position
    // and decrease if the next position is available
    for ($i = 0; $i < count($exarr); $i += 1) {

        // if $num is on an excluded position, skip it
        if ($num == $exarr[$i]) {
            $num += 1;
            continue;
        }

        $dif = $exarr[$i] - $num;

        // if the position is after the next excluded number,
        // go to the next excluded number
        if ($pos >= $dif) {
            $num += $dif;

            // -1 because we're now at an excluded position
            $pos -= $dif - 1;
        } else {
            // otherwise, return the free position
            return $num + $pos;
        }
    }

    // return the number plus the open positions we still had to go
    return $num + $pos;
}

此函数选择一个随机位置并遍历排除数组以找到空闲位置。它的运行时间取决于要排除的数量。如果要排除某些范围,可能需要调整算法以将此考虑在内。

答案 4 :(得分:1)

始终使用加密强算法生成随机数:

/**
 * @param int   $from     From number
 * @param int   $to       To number
 * @param array $excluded Additionally exclude numbers
 * @return int
 */
function randomNumber($from, $to, array $excluded = [])
{
    $func = function_exists('random_int') ? 'random_int' : 'mt_rand';

    do {
        $number = $func($from, $to);
    } while (in_array($number, $excluded, true));

    return $number;
}

var_dump(randomNumber(1, 100));
var_dump(randomNumber(1, 10, [5, 6, 7, 8]));
var_dump(randomNumber(1, 100, range(10, 90)));

我还建议在使用多个PHP版本时使用paragonie/random_compat库以实现兼容性。

答案 5 :(得分:0)

您可以创建一个包含有效数字的数组。

然后,您的随机数生成应该将索引返回到该数组。

答案 6 :(得分:0)

如果您没有太多要排除的数字,如果您找到不需要的号码,只需重试就会更轻松,更快捷:

$n = 0;
while (in_array($n, array(0, 234, 1578 ,763 , 1274))) {
  $n = rand(1,1600); 
}

echo $n;

答案 7 :(得分:0)

另一个解决方案如下:

function random_number($min, $max, $exclude)
{
      $number = rand($min, $max);

  if(in_array($number, $exclude))
  {
      random_number($min, $max, $exclude);
  } else {
      return $number;
  }
}

$number = random_number(1,10, [2,5,6]);

答案 8 :(得分:0)

随着“黑名单”整数的数量接近整个整数范围的数量,采用@regenschein的建议变得越来越具有吸引力。

一种非迭代方法可能看起来像这样:

$range = range(1, 1600);
$blacklist = [234, 1578, 763, 1274]; // 4 blacklisted versus 1600 full range is NOT compelling
$valids = array_diff($range, $blacklist);
echo array_values($valids)[rand(0, count($valids) - 1)];
// or
echo $valids[array_rand($valids)];
// the two approaches use different randomizers

或者,如果您像混洗一样开心,可以这样做:

$blacklist = [234, 1578, 763, 1274];
$range = range(1, 1600);
$valids = array_diff($range, $blacklist);
shuffle($valids);
echo $valids[0];

*注意array_diff()特别适用于要传递多个黑名单数组的情况-只需将它们用逗号分隔即可。

例如:

var_export($valids = array_diff(range(1, 100), range(5, 50), range(61, 99), [55]));

输出:

array (
  0 => 1,
  1 => 2,
  2 => 3,
  3 => 4,
  50 => 51,
  51 => 52,
  52 => 53,
  53 => 54,
  55 => 56,
  56 => 57,
  57 => 58,
  58 => 59,
  59 => 60,
  99 => 100,
)

答案 9 :(得分:0)

我知道这有点老了,但是我认为op试图做的是将整数洗牌。如果是这样,以下方法更好

$array = array(1,2,3,4,5,6,7);
shuffle($array);

这段代码将随机化数组精确元素的顺序,而不会重复,并将结果返回到数组本身内部。