给定 X 次掷骰子输入，生成特定数字

Question

我正在尝试提出一个解决方案，我需要掷一些骰子（所有骰子大小相同）并达到指定的数字。如果我已经进行了所有验证以确保数字有效并且理论上可以达到预期的结果，那么有没有人有一个很好的算法来解决这个问题？请注意，它应该是随机的，而不仅仅是一个直线。

一些例子

掷出 3 d6 得到 14 -> 所以它可以输出 5,3,6 或 6,6,2

掷 4 d20 得到 66 -> 所以它可以输出 16,14,19,17

我需要一个通用函数，它可以接受任意大小的骰子、任意掷骰数和期望的结果。

我最初的尝试如下，虽然这不会产生所需的输出（你现在可以忽略mod，这也是为了允许修饰符）。此示例还缺少对可实现所需输出的验证，但这不是问题的一部分。

let desired = 19
let mod = 0
let dm = desired - mod
let n = 5;// number of dice
let d = 6 // dice sides
let nums = []

for(i =0; i< n; i++) {
    nums.push(Math.round(Math.random() * Math.round(d)) + 1)
}

let sum = nums.reduce((acc,val) => acc + val)


nums = nums.map(a => Math.round((a/sum) * dm))

let diff = dm - (nums.reduce((acc,val) => acc + val))
function recursive(diff) {
    let ran = nums[Math.random() * Math.round(nums.length -1)]
    if(nums[ran] + diff > d || nums[ran] + diff < 1) {
        recursive(diff)
    } else {
        nums[ran] += diff
    }
}
while(diff != 0) {
    recursive(diff)
    diff += diff < 0 ? 1 : -1;
}

alert(nums)

Answer 1

递归：

function foo(desired, rolls, sides, current) {
  if (rolls === 0) {
    return current.reduce((s, c) => s + c) === desired ? current : null;
  }
  
  const random = [];
  for (let i = 1; i <= sides; i++) {
    const randomIndex = Math.floor(Math.random() * (random.length + 1))
    random.splice(randomIndex, 0, i);
  }
  
  for (const n of random) {
    const result = foo(desired, rolls - 1, sides, [...current, n]);
    if (result) {
      return result;
    }
  }
}

console.log(foo(14, 3, 6, []))

非递归：

function foo(desired, rolls, sides) {
  const stack = [[]];
  while (stack.length) {
    const current = stack.pop();    
    const random = [];
    for (let i = 1; i <= sides; i++) {
      const randomIndex = Math.floor(Math.random() * (random.length + 1));
      random.splice(randomIndex, 0, i);
    }
  
    for (const n of random) {
      if (current.length === rolls - 1) {
        if (current.reduce((s, c) => s + c + n) === desired) {
          return [...current, n];
        }
      } else {
        stack.push([...current, n]);
      }
    }
  }   
}

console.log(foo(14, 3, 6));

具有最小内存消耗的非递归：

function foo(desired, rolls, sides) {
  const currentIndexes = Array(rolls).fill(0);
  const randoms = Array.from({ length: rolls }, () => {
    const random = [];
    for (let i = 1; i <= sides; i++) {
      const randomIndex = Math.floor(Math.random() * (random.length + 1));
      random.splice(randomIndex, 0, i);
    }
    return random;
  })
  while (true) {
    if (currentIndexes.reduce((s, idx, i) => s + randoms[i][idx], 0) === desired) {
      return currentIndexes.map((idx, i) => randoms[i][idx]);
    }
    for (let i = currentIndexes.length - 1; i >= 0; i--) {
      if (currentIndexes[i] < sides - 1) {
        currentIndexes[i] += 1;
        break;
      }
      currentIndexes[i] = 0;
    }
  }
}

console.log(foo(14, 3, 6));

通过基于前一卷计算最后一卷，具有最小内存消耗和提高性能的非递归解决方案。

function foo(desired, rolls, sides) {
  const currentIndexes = Array(rolls - 1).fill(0);
  const randoms = Array.from({ length: rolls - 1 }, () => {
    const random = [];
    for (let i = 1; i <= sides; i++) {
      const randomIndex = Math.floor(Math.random() * (random.length + 1));
      random.splice(randomIndex, 0, i);
    }
    return random;
  })
  while (true) {
    const diff = desired - currentIndexes.reduce((s, idx, i) => s + randoms[i][idx], 0);
    if (diff > 0 && diff <= sides) {
      return [...currentIndexes.map((idx, i) => randoms[i][idx]), diff];
    }
    for (let i = currentIndexes.length - 1; i >= 0; i--) {
      if (currentIndexes[i] < sides - 1) {
        currentIndexes[i] += 1;
        break;
      }
      currentIndexes[i] = 0;
    }
  }
}

console.log(foo(66, 4, 20));

Answer 2

红宝石解决方案：

def foo(count, dim, desired, results = [])
  return results if count == 0
  raise ArgumentError if count > desired
  raise ArgumentError if count * dim < desired

  max_roll = (dim <= desired - count) ? dim : desired - count + 1
  min_roll = [(desired - (count-1) * dim), 1].max
  roll = (rand(min_roll..max_roll))
  results << roll

  foo(count - 1, dim, desired - roll, results)

  results
end

puts foo(3, 6, 11).inspect
puts foo(2, 6, 11).inspect
puts foo(4, 4, 11).inspect

结果：

[3, 4, 4]
[5, 6]
[2, 3, 4, 2]

所以基本上它是递归函数。对于每个步骤：

• 掷骰子（在 min_roll..max_roll 允许的范围内）
• 调用相同的函数，但通过骰子已经消耗的数字减少计数，并通过滚动值扩展结果数组

注意一件事：这种行为可能会导致结果开头的数字更大。为了避免这种情况，只需在它的末尾随机播放函数的结果