将一个随机值分成四个总和

Question

我有一个像 24 这样的值，我有四个文本框。如何动态生成四个加起来为 24 的值？

所有值必须为整数，不能为负数，结果不能为6、6、6、6；它们必须不同，例如：8、2、10、4。（但 5、6、6、7 也可以。）

Answer 1

对于您陈述的问题，可以生成一个包含所有可能解决方案的数组，然后随机选择一个。实际上有 1,770 种可能的解决方案。

var solutions = [[Int]]()

for i in 1...21 {
    for j in 1...21 {
        for k in 1...21 {
            let l = 24 - (i + j + k)
            if l > 0 && !(i == 6 && j == 6 && k == 6) {
                solutions.append([i, j, k, l])
            }
        }
    }
}

// Now generate 20 solutions
for _ in 1...20 {
    let rval = Int(arc4random_uniform(UInt32(solutions.count)))
    println(solutions[rval])
}

这避免了以初始设置时间和存储为代价的任何偏差。

---

这可以通过以下方式改进：

• 通过仅存储前 3 个数字来减少存储空间。第 4 个总是 24 -（前 3 个的总和）
• 通过将每个解决方案存储为单个整数来减少存储空间：(i * 10000 + j * 100 + k)
• 通过意识到每个循环不需要进入 21 来加速解决方案的生成。

---

这是将每个解决方案存储为单个整数并优化循环的解决方案：

var solutions = [Int]()

for i in 1...21 {
    for j in 1...22-i {
        for k in 1...23-i-j {
            if !(i == 6 && j == 6 && k == 6) {
                solutions.append(i * 10000 + j * 100 + k)
            }
        }
    }
}

// Now generate 20 solutions
for _ in 1...20 {
    let rval = Int(arc4random_uniform(UInt32(solutions.count)))
    let solution = solutions[rval]

    // unpack the values
    let i = solution / 10000
    let j = (solution % 10000) / 100
    let k = solution % 100
    let l = 24 - (i + j + k)

    // print the solution
    println("\([i, j, k, l])")
}

Answer 2

func getRandomValues(amountOfValues:Int, totalAmount:Int) -> [Int]?{
    if amountOfValues < 1{
        return nil
    }

    if totalAmount < 1{
        return nil
    }

    if totalAmount < amountOfValues{
        return nil
    }

    var values:[Int] = []
    var valueLeft = totalAmount

    for i in 0..<amountOfValues{

        if i == amountOfValues - 1{
            values.append(valueLeft)
            break
        }
       var value = Int(arc4random_uniform(UInt32(valueLeft - (amountOfValues - i))) + 1)
        valueLeft -= value
        values.append(value)
    }

    var shuffledArray:[Int] = []

    for i in 0..<values.count {
        var rnd = Int(arc4random_uniform(UInt32(values.count)))
        shuffledArray.append(values[rnd])
        values.removeAtIndex(rnd)
    }

    return shuffledArray
}

getRandomValues(4, 24)

这不是最终答案，但应该是一个（好的）起点。

它是如何工作的：它需要 2 个参数。随机值的数量（在您的情况下为 4）和总量（在您的情况下为 24）。

它在总金额和 0 之间取一个随机值，将其存储在一个数组中，然后从存储剩余金额的变量中减去该值并存储新值。

它在剩余数量和 0 之间取一个新的随机值，将其存储在一个数组中，然后再次从剩余数量中减去该值并存储新值。

当它是需要的最后一个数字时，它会查看剩余的数量并将其添加到数组中

编辑：

将+1 添加到随机值可以消除数组中存在0 的问题。

编辑 2：

对数组进行洗牌确实会增加将高值作为第一个值的机会。

Answer 3

不幸的是，非确定性但完全随机的一种解决方案如下：

总共 4 个数字中的 24 个：
选择 1 到 21 之间的四个随机数
重复直到总数等于 24 并且它们不都是 6。

在找到解决方案之前，这将平均循环大约 100 次。

Answer 4

这是https://stackoverflow.com/a/8064754/1187415 中给出的算法的 Swift 实现，略带 修改，因为所有数字都必须是正数。

产生N个总和为M的正随机整数的方法是

• 构建一个包含数字 0 的数组，后跟 N-1 个不同的 1 .. M-1 范围内的随机数，最后是数字 M。
• 计算后续数组元素的差异。

在第一步中，我们需要 N-1 个元素的随机子集 集合 { 1, ..., M-1 }。这可以通过迭代这个来实现 以 n/m 的概率设置和选择每个元素，其中 m 是我们可以选择的剩余元素数量 n 是要选择的剩余元素数。

不是将选择的随机数存储在数组中，而是 立即计算与先前选择的数字的差异 并存储。

这给出了以下功能：

func randomNumbers(#count : Int, withSum sum : Int) -> [Int] {

    precondition(sum >= count, "`sum` must not be less than `count`")

    var diffs : [Int] = []
    var last = 0        // last number chosen

    var m = UInt32(sum - 1)     // remaining # of elements to choose from
    var n = UInt32(count - 1)   // remaining # of elements to choose
    for i in 1 ..< sum  {
        // Choose this number `i` with probability n/m:
        if arc4random_uniform(m) < n {
            diffs.append(i - last)
            last = i
            n--
        }
        m--
    }
    diffs.append(sum - last)

    return diffs
}

println(randomNumbers(count: 4, withSum: 24))

如果所有元素都相等（例如 6+6+6+6=24）的解不是 允许，您可以重复该方法，直到找到有效的解决方案：

func differentRandomNumbers(#count : Int, withSum sum : Int) -> [Int] {

    precondition(count >= 2, "`count` must be at least 2")

    var v : [Int]
    do {
        v = randomNumbers(count: count, withSum: sum)
    } while (!contains(v, { $0 != v[0]} ))
    return v
}

---

这是一个简单的测试。它计算 1,000,000 个随机表示 7 作为 3 个正整数之和，并计算分布 结果。

let set = NSCountedSet()
for i in 1 ... 1_000_000 {
    let v = randomNumbers(count: 3, withSum: 7)
    set.addObject(v)
}
for (_, v) in enumerate(set) {
    let count = set.countForObject(v)
    println("\(v as! [Int]) \(count)")
}

结果：

[1, 4, 2] 66786 [1, 5, 1] 67082 [3, 1, 3] 66273 [2, 2, 3] 66808 [2, 3, 2] 66966 [5, 1, 1] 66545 [2, 1, 4] 66381 [1, 3, 3] 67153 [3, 3, 1] 67034 [4, 1, 2] 66423 [3, 2, 2] 66674 [2, 4, 1] 66418 [4, 2, 1] 66292 [1, 1, 5] 66414 [1, 2, 4] 66751

---

Swift 3 更新：

func randomNumbers(count : Int, withSum sum : Int) -> [Int] {

    precondition(sum >= count, "`sum` must not be less than `count`")

    var diffs : [Int] = []
    var last = 0        // last number chosen

    var m = UInt32(sum - 1)     // remaining # of elements to choose from
    var n = UInt32(count - 1)   // remaining # of elements to choose
    for i in 1 ..< sum  {
        // Choose this number `i` with probability n/m:
        if arc4random_uniform(m) < n {
            diffs.append(i - last)
            last = i
            n -= 1
        }
        m -= 1
    }
    diffs.append(sum - last)

    return diffs
}

print(randomNumbers(count: 4, withSum: 24))

Answer 5

这是一个解决方案，它应该显着*比其他一些方法具有更少的偏差。它的工作原理是生成请求数量的随机浮点数，将它们全部相乘或相除，直到它们加起来达到目标​​总数，然后将它们四舍五入为整数。舍入过程会改变总数，因此我们需要通过对随机项进行加减来进行修正，直到它们相加到正确的数量为止。

func getRandomDoubles(#count: Int, #total: Double) -> [Double] {
    var nonNormalized = [Double]()
    nonNormalized.reserveCapacity(count)
    for i in 0..<count {
        nonNormalized.append(Double(arc4random()) / 0xFFFFFFFF)
    }
    let nonNormalizedSum = reduce(nonNormalized, 0) { $0 + $1 }
    let normalized = nonNormalized.map { $0 * total / nonNormalizedSum }
    return normalized
}

func getRandomInts(#count: Int, #total: Int) -> [Int] {
    let doubles = getRandomDoubles(count: count, total: Double(total))
    var ints = [Int]()
    ints.reserveCapacity(count)
    for double in doubles {
        if double < 1 || double % 1 >= 0.5 {
            // round up
            ints.append(Int(ceil(double)))
        } else {
            // round down
            ints.append(Int(floor(double)))
        }
    }
    let roundingErrors = total - (reduce(ints, 0) { $0 + $1 })
    let directionToAdjust: Int = roundingErrors > 0 ? 1 : -1
    var corrections = abs(roundingErrors)
    while corrections > 0 {
        let index = Int(arc4random_uniform(UInt32(count)))
        if directionToAdjust == -1 && ints[index] <= 1 { continue }
        ints[index] += directionToAdjust
        corrections--
    }
    return ints
}

*编辑：Martin R 正确地指出，这并不像人们预期的那样统一，实际上高度偏向于 1-24 范围中间的数字。我不推荐使用此解决方案，但我将其搁置，以便其他人知道不要犯同样的错误。

Answer 6

作为递归函数，算法非常好：

func getRandomValues(amount: Int, total: Int) -> [Int] {
    if amount == 1 { return [total] }
    if amount == total { return Array(count: amount, repeatedValue: 1) }
    let number = Int(arc4random()) % (total - amount + 1) + 1
    return [number] + getRandomValues(amount - 1, total - number)
}

并进行安全检查：

func getRandomValues(amount: Int, total: Int) -> [Int]? {
    if !(1...total ~= amount) { return nil }
    if amount == 1 { return [total] }
    if amount == total { return Array(count: amount, repeatedValue: 1) }
    let number = Int(arc4random()) % (total - amount + 1) + 1
    return [number] + getRandomValues(amount - 1, total - number)!
}

正如@MartinR 指出的那样，上面的代码非常有偏见。因此，为了使输出值均匀分布，您应该使用这段代码：

func getRandomValues(amount: Int, total: Int) -> [Int] {
    var numberSet = Set<Int>()

    // add splitting points to numberSet
    for _ in 1...amount - 1 {
        var number = Int(arc4random()) % (total - 1) + 1
        while numberSet.contains(number) {
            number = Int(arc4random()) % (total - 1) + 1
        }
        numberSet.insert(number)
    }

    // sort numberSet and return the differences between the splitting points
    let sortedArray = (Array(numberSet) + [0, total]).sort()
    return sortedArray.enumerate().flatMap{
        indexElement in
        if indexElement.index == amount { return nil }
        return sortedArray[indexElement.index + 1] - indexElement.element
    }
}