这个解决方案受到了Rob McAfee的启发。 然而，它不需要循环，结果是一个均匀分布:

// Returns 1-5
var rnd5 = function(){
   return parseInt(Math.random() * 5, 10) + 1;
}
// Helper
var lastEdge = 0;
// Returns 1-7
var rnd7 = function () {
  var map = [
     [ 1, 2, 3, 4, 5 ],
     [ 6, 7, 1, 2, 3 ],
     [ 4, 5, 6, 7, 1 ],
     [ 2, 3, 4, 5, 6 ],
     [ 7, 0, 0, 0, 0 ]
  ];
  var result = map[rnd5() - 1][rnd5() - 1];
  if (result > 0) {
    return result;
  }
  lastEdge++;
  if (lastEdge > 7 ) {
    lastEdge = 1;
  }
  return lastEdge;
};

// Test the a uniform distribution
results = {}; for(i=0; i < 700000;i++) { var rand = rnd7(); results[rand] = results[rand] ? results[rand] + 1 : 1;} 
console.log(results)

结果:[1:99560,2:99932,3:100355,4:100262,5:99603,6:100062,7:100226]

js小提琴

function Rand7
   put 200 into x
   repeat while x > 118
      put ((random(5)-1) * 25) + ((random(5)-1) * 5) + (random(5)-1) into x
   end repeat
   return (x mod 7) + 1
end Rand7

3次调用Rand5，平均125次中只重复6次。

把它想象成一个5x5x5的3D数组，一遍又一遍地填满1到7，还有6个空格。重新滚动空白。rand5调用在该数组中创建一个以5为基数的三位索引。

4D或更高的n维数组的重复次数会更少，但这意味着对rand5函数的更多调用将成为标准。你会在更高维度上得到递减的效率回报。在我看来，三个似乎是一个很好的折衷方案，但我还没有对它们进行测试。它是特定于rand5实现的。

我想我有四个答案，两个给出了像@Adam Rosenfield那样的精确解决方案，但没有无限循环问题，另外两个几乎完美的解决方案，但执行速度比第一个更快。

最好的精确解决方案需要7次调用rand5，但为了理解，让我们继续。

方法一:精确

Adam的答案的优点在于它给出了一个完美的均匀分布，并且只需要两次调用rand5()的概率非常高(21/25)。然而，最坏的情况是无限循环。

下面的第一个解决方案也给出了一个完美的均匀分布，但总共需要对rand5进行42次调用。没有无限循环。

下面是一个R的实现:

rand5 <- function() sample(1:5,1)

rand7 <- function()  (sum(sapply(0:6, function(i) i + rand5() + rand5()*2 + rand5()*3 + rand5()*4 + rand5()*5 + rand5()*6)) %% 7) + 1

对于不熟悉R的人，这里是一个简化版本:

rand7 = function(){
  r = 0 
  for(i in 0:6){
    r = r + i + rand5() + rand5()*2 + rand5()*3 + rand5()*4 + rand5()*5 + rand5()*6
  }
  return r %% 7 + 1
}

rand5的分布将被保留。如果我们计算一下，循环的7次迭代中的每一次都有5^6个可能的组合，因此可能组合的总数为(7 * 5^6)%% 7 = 0。因此，我们可以将生成的随机数分成7个相等的组。有关这方面的更多讨论，请参见方法二。

以下是所有可能的组合:

table(apply(expand.grid(c(outer(1:5,0:6,"+")),(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6),1,sum) %% 7 + 1)

    1     2     3     4     5     6     7 
15625 15625 15625 15625 15625 15625 15625 

我认为这很容易证明亚当的方法运行得快得多。在Adam的解中有42次或更多的rand5调用的概率非常小((4/25)^21 ~ 10^(-17))。

方法2 -不精确

现在是第二个方法，它几乎是统一的，但需要6次调用rand5:

rand7 <- function() (sum(sapply(1:6,function(i) i*rand5())) %% 7) + 1

以下是一个简化版本:

rand7 = function(){
  r = 0 
  for(i in 1:6){
    r = r + i*rand5()
  }
  return r %% 7 + 1
}

这实际上是方法1的一次迭代。如果我们生成所有可能的组合，结果计数如下:

table(apply(expand.grid(1:5,(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6),1,sum) %% 7 + 1)

   1    2    3    4    5    6    7 
2233 2232 2232 2232 2232 2232 2232

一个数字将在5^6 = 15625次试验中再次出现。

现在，在方法1中，通过将1加到6，我们将数字2233移动到每个连续的点上。因此，组合的总数将匹配。这是可行的，因为5^ 6% % 7 = 1，然后我们做了7个适当的变化，所以(7 * 5^ 6% % 7 = 0)。

方法三:精确

如果理解了方法1和2的参数，接下来就是方法3，它只需要7次调用rand5。在这一点上，我觉得这是精确解决方案所需的最少调用数。

下面是一个R的实现:

rand5 <- function() sample(1:5,1)

rand7 <- function()  (sum(sapply(1:7, function(i) i * rand5())) %% 7) + 1

对于不熟悉R的人，这里是一个简化版本:

rand7 = function(){
  r = 0 
  for(i in 1:7){
    r = r + i * rand5()
  }
  return r %% 7 + 1
}

rand5的分布将被保留。如果我们计算一下，循环的7次迭代中的每一次都有5个可能的结果，因此可能组合的总数为(7 * 5)%% 7 = 0。因此，我们可以将生成的随机数分成7个相等的组。有关这方面的更多讨论，请参见方法一和方法二。

以下是所有可能的组合:

table(apply(expand.grid(0:6,(1:5)),1,sum) %% 7 + 1)

1 2 3 4 5 6 7  
5 5 5 5 5 5 5 

我认为这很直接地证明了亚当的方法仍然运行得更快。在Adam的解中有7次或更多的rand5调用的概率仍然很小((4/25)^3 ~ 0.004)。

方法4 -不精确

这是第二种方法的一个小变化。它几乎是统一的，但需要7次调用rand5，这是一个额外的方法2:

rand7 <- function() (rand5() + sum(sapply(1:6,function(i) i*rand5())) %% 7) + 1

以下是一个简化版本:

rand7 = function(){
  r = 0 
  for(i in 1:6){
    r = r + i*rand5()
  }
  return (r+rand5()) %% 7 + 1
}

如果我们生成所有可能的组合，结果计数如下:

table(apply(expand.grid(1:5,(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6,1:5),1,sum) %% 7 + 1)

    1     2     3     4     5     6     7 
11160 11161 11161 11161 11161 11161 11160

在5^7 = 78125次试验中，有两个数字会少出现一次。在大多数情况下，我可以接受。

下面使用随机数发生器在{1,2,3,4,5,6,7}上产生均匀分布，在{1,2,3,4,5}上产生均匀分布。代码很混乱，但逻辑很清晰。

public static int random_7(Random rg) {
    int returnValue = 0;
    while (returnValue == 0) {
        for (int i = 1; i <= 3; i++) {
            returnValue = (returnValue << 1) + SimulateFairCoin(rg);
        }
    }
    return returnValue;
}

private static int SimulateFairCoin(Random rg) {
    while (true) {
        int flipOne = random_5_mod_2(rg);
        int flipTwo = random_5_mod_2(rg);

        if (flipOne == 0 && flipTwo == 1) {
            return 0;
        }
        else if (flipOne == 1 && flipTwo == 0) {
            return 1;
        }
    }
}

private static int random_5_mod_2(Random rg) {
    return random_5(rg) % 2;
}

private static int random_5(Random rg) {
    return rg.Next(5) + 1;
}    

亚当·罗森菲尔德正确答案的前提是:

X = 5^n(在他的例子中，n=2) 操作n个rand5次调用以获得范围[1,x]内的数字y Z = ((int)(x / 7)) * 7 如果y > z，再试一次。否则返回y % 7 + 1

当n = 2时，有4种可能:y ={22,23,24,25}。如果你使用n = 6，你只有1个扔掉的东西:y ={15625}。

5^6 is 15625 7 times 2232 is 15624

你又给rand5个电话。但是，您获得一个丢弃值(或无限循环)的机会要低得多。如果有办法让y没有可能的一次性值，我还没有找到它。

这里有很多解决方案没有产生均匀分布，许多评论指出了这一点，但这个问题并没有把它作为一个要求。最简单的解决方案是:

int rand_7() { return rand_5(); }

1 - 5范围内的随机整数显然在1 - 7范围内。从技术上讲，最简单的解决方法是返回一个常数，但那太琐碎了。

然而，我认为rand_5函数的存在是一个转移注意力的问题。假设问题是“生成一个均匀分布的伪随机数生成器，输出范围为1 - 7”。这是一个简单的问题(技术上不简单，但已经解决了，所以您可以查阅它)。

另一方面，如果问题被解释为你实际上有一个真正的随机数生成器，用于范围为1 - 5的整数(而不是伪随机)，那么解决方案是:

1) examine the rand_5 function
2) understand how it works
3) profit