首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >给定骰子的X输入,生成一个特定的数字

给定骰子的X输入,生成一个特定的数字
EN

Stack Overflow用户
提问于 2018-12-04 09:53:27
回答 2查看 221关注 0票数 2

我正试图想出一个解决方案,我需要掷出一些骰子(都是相同的大小),并达到指定的数目。如果我有所有的验证,以确保数字是有效的,理论上可以得出预期的结果,有人有一个很好的算法来解决这个问题吗?注意,它应该看起来是随机的,而不仅仅是一个直接的除法。

一些例子

卷3 d6,得到14 ->,输出5,3,6或6,6,2 滚动4 d20,得到66 ->,以便它可以输出16,14,19,17

我需要一个通用函数,它可以接受任意大小的骰子、要滚动的任何数量以及所需的结果。

我最初的尝试如下,尽管这并不能产生所需的输出(目前您可以忽略mod,这也是允许修饰符)。这个例子也没有验证所需的输出是可以实现的,但这不是问题的一部分。

代码语言:javascript
复制
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)
EN

回答 2

Stack Overflow用户

回答已采纳

发布于 2018-12-04 13:07:04

红宝石溶质:

代码语言:javascript
复制
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

结果:

代码语言:javascript
复制
[3, 4, 4]
[5, 6]
[2, 3, 4, 2]

所以它基本上是递归函数。每一步:

  • 掷骰子(在允许的范围内min_roll..max_roll)
  • 调用相同的函数,但通过骰子减少已消耗的数量,并按滚动值扩展结果数组。

注意一件事:通过这种行为,你可能在结果的开头有更多的数字。为了避免这种情况,只需在其结束时混淆函数的结果即可。

票数 1
EN

Stack Overflow用户

发布于 2018-12-04 14:24:10

递归:

代码语言:javascript
复制
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, []))

非递归的:

代码语言:javascript
复制
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));

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

代码语言:javascript
复制
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));

非递归解决方案,以最小的内存消耗和提高性能,通过计算上一个轧辊的基础上。

代码语言:javascript
复制
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));

票数 2
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/53610101

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档