限制伪随机python列表中的重复次数

Question

对于科学实验，我需要生成一个伪随机顺序来管理两个不同的测试，每个测试 10 次。我用过这段代码：

import random
randy  = [1] * 10 + [2] * 10 
random.shuffle(randy)

这给了我一个很好的打乱的测试顺序，但是我需要确保重复测试的最大数量不大于 3。换句话说，不要在一个测试中执行“1”测试超过 3 次行。

谁能想到一个好方法来做到这一点？多次洗牌并不能保证成功。有什么方法可以可靠地检查洗牌列表并相应地进行更改？谢谢！

Answer 1

John Y 的解决方案让您搜索整个解决方案空间；尽管这是可以忍受的，但几乎不值得这样做。相反，只需乐观地采样：

import random

sequences = []
order = [1, 0] * 10

while len(sequences) < 10:
    random.shuffle(order)

    if order in sequences:
        continue

    sequences.append(order[:])

然后要删除长度为 4 的组，您可以检查类似

from itertools import groupby

while len(sequences) < 10:
    random.shuffle(order)

    if order in sequences:
        continue

    if all(len(list(group)) < 4 for _, group in groupby(order)):
        sequences.append(order[:])

Answer 2

这是一个乐观重试策略：

#!/usr/bin/env python
from random import choice

def added1(lst, bank):
    if len(bank) == 0:
        return lst
    selection = choice(bank)
    lst.append(selection)
    bank.remove(selection)
    if selection == 1:
        return added11(lst, bank)
    return added2(lst, bank)

def added11(lst,bank):
    if len(bank) == 0:
        return lst
    bank.remove(2)
    lst.append(2)
    return added2(lst, bank)

def added2(lst, bank):
    if len(bank) == 0:
        return lst
    selection = choice(bank)
    lst.append(selection)
    bank.remove(selection)
    if selection == 2:
        return added22(lst, bank)
    return added1(lst, bank)

def added22(lst,bank):
    if len(bank) == 0:
        return lst
    bank.remove(1)
    lst.append(1)
    return added1(lst, bank)

def start(lst, bank):
    bank_bkp = bank[:]
    while True:
        try:
            if len(bank) == 0:
                return lst
            selection = choice(bank)
            lst.append(selection)
            bank.remove(selection)
            if selection == 1:
                return added1(lst, bank)
            return added2(lst, bank)
        except:
            # retry
            bank = bank_bkp[:]
            lst = []


print start([], [1] * 10 + [2] * 10)

输出：

[1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 2, 2]

它基于表示此自动机中状态的简单函数：

执行规则，以及一组选项。如果选项库用完 - 它会再次尝试。

可能可能会花费很多时间，但不会：

print timeit.repeat('start([], [1] * 10 + [2] * 10)', setup="from __main__ import start", number=10000, repeat=3)

输出：

[0.14524006843566895, 0.14585399627685547, 0.14375996589660645]

注意：这是递归的，因此拥有超过 2000 名成员的银行需要您明确允许更深层次的递归。

Answer 3

对于如此小规模的问题，我不同意@texasflood 的评论，即预先计算所有可能性，然后从中挑选是非常低效的。事实上，所声明的参数非常小，使用纯粹的蛮力来生成所有可能性是非常容易管理的，我将在下面演示。

在您的特定情况下，您始终只运行 20 个测试，并且您只有 2 个可能的测试可供选择。所以你知道你不可能有超过 2**20 个序列，即使没有其他约束。这只是 1048576 种可能性，用今天的内存很容易管理。

此外，根据您的问题陈述，您只能使用 10 个测试和 10 个测试。这将可能性的数量减少到 184756。（使用经典的概率计数技术，这被计算为 20!/(10!*10!)。）

那是在您甚至消除连续运行四个（或更多）相同测试的可能性之前。

所以，我强烈建议只计算所有可用的可能性，然后在这个可能性集合上使用random.choice。

为了让您入门，这里有一个简单的循环，用于获取恰好包含 10 个 0 和 10 个 1 的所有可能序列：

sequences = []
for n in range(2**20):
    b = bin(n)[2:].zfill(20)
    if b.count('1') == 10:
        sequences.append(b)

请注意，bin 函数（需要 Python 2.6 或更高版本）生成整数的二进制字符串表示形式，它以 '0b' 开头（因此将 [2:] 去掉）。

我将把它作为练习留给读者，以消除四行序列。 （提示：您可以简单地改进我上面给出的示例代码，通过测试二进制字符串中是否存在'1111' 或'0000'。您将得到总共66486 个可用序列，相当小按今天的标准计算。）

Answer 4

我会自己制作洗牌器，因为它可能是最快、最优雅的选择：

randy = []

ones = [1] * 10
twos = [2] * 10

for i in range(20):
    if len(randy) > 3 and randy[i-1] == randy[i-2] == randy[i-3]:
        randy.append(ones.pop() if randy[i-1] == 1 else twos.pop())
    else:
        randy.append(random.choice([ones, twos]).pop())

Answer 5

这并不完全保留 10 个 1 和 10 个 2，因此可能不是您所追求的，但它取决于机会（目前每个 50%），如果需要，您可以添加新测试。

import random
from operator import itemgetter

#randy = [ [item,amount], ... ]
randy  = [[1,10],[2,10]]

#This turns the above list into the same format of your 'randy'
itemList = [j for k in[([i[0]]*i[1])for i in randy]for j in k]  

randomList = [-1]  #This stops the check from causing problems at the start
for i in range(len(itemList)):
    while True:
        newChoice = random.choice( itemList )
        if len(set(randomList[-2:]+[newChoice]))-1: #Checks the last 2 values plus the new value aren't all the same
            randomList.append( newChoice )
            break
shuffledList = randomList[1:]

Answer 6

这是 Veedrac 答案的优化版本，您只想获得一个正确的列表。如果你想动态地获得一个序列会更有趣，但如果你想避免序列重复就不会那么有趣了。

from random import shuffle
from itertools import groupby

def get_binary_sequence(sequence_length, maximum_repetitions):
    order = [True, False] * int(sequence_length/2)
    while True:
        shuffle(order)
        if all(len(list(group)) <= maximum_repetitions _, group in groupby(order)):
            return order