根据某些标准生成部分随机布尔值数组[关闭]

Question

我正在尝试根据某些标准生成随机数据。我被困在如何开始，所以我没有任何代码。

我只是想要一些关于如何实现这一目标的指南。您无需提供完整的代码。

所以，说到问题，假设我们有这些现有数据：

Total - 10
Won   -  7
Lost  -  3
Longest Winning Streak - 5
Longest Losing Streak - 2

现在我需要生成满足上述条件的随机布尔值数组（true 代表胜利，false 代表失败）。

因此，在这种情况下，输出可以是以下任何一种：

0011011111
1111101100
1010011111
..........

困扰我的是连胜部分。如果不是连胜，我可以生成七个1(s) 和三个0(s)，然后随机洗牌。

注意：我更喜欢 C#、VB.NET、JavaScript 或 Python 的解决方案，但欢迎使用任何语言。

Answer 1

我建议使用遗传算法。

    class Program
{
    static int len = 10;
    static int win = 7;
    static int lws = 5;
    static int lls = 2;

    static Random rnd = new Random();

    static void Main(string[] args)
    {
        int genSz = 15;
        var generation = new List<Chromosome>();
        Helper.Repeat(() => generation.Add(new Chromosome()), genSz);

        int gen = 1;
        while (generation.First().Fitness != 0)
        {
            //procreation
            Helper.Repeat(() => {
                int x1 = rnd.Next(genSz / 2);
                int x2 = rnd.Next(genSz);
                generation.Add(new Chromosome(generation[x1], generation[x2]));
            }, genSz);
            //selection
            generation = generation.OrderBy(x => x.Fitness).Take(genSz).ToList();
            Console.WriteLine("GENERATION " + gen++);
            foreach (var x in generation)
            {
                Console.WriteLine(x);
            }
            Console.ReadLine();
        }
        Console.ReadLine();
    }

    class Chromosome
    {
        bool[] genes = new bool[len];

        public Chromosome() { }

        public Chromosome(Chromosome p1, Chromosome p2)
        {
            //crossingover
            rnd.Shuffle(ref p1, ref p2);    //may reorder parents or not
            var x = rnd.Next(len);
            Array.Copy(p1.genes, 0, genes, 0, x);
            Array.Copy(p2.genes, x, genes, x, len - x);
            //mutation
            if (rnd.Flip())
            {
                x = rnd.Next(len);
                genes[x] = !genes[x];
            }
        }
        public int Fitness
        {
            get
            {
                int w = genes.Count(g => g);
                int l = len - w;
                int ws = genes.LongestStreak(g => g);
                int ls = genes.LongestStreak(g => !g);
                return Math.Abs(w - win) + Math.Abs(lws - ws) + Math.Abs(lls - ls);
            }
        }
        public override string ToString()
        {
            return "[" + new string(genes.Select(g => g ? '*' : '.').ToArray()) + "] " + Fitness.ToString();
        }
    }
}

public static class Helper
{
    public static bool Flip(this Random rnd) => rnd.Next(2) == 0;
    public static void Shuffle<T>(this Random rnd, ref T a, ref T b, bool allowNoChange = true)
    {
        if (allowNoChange && rnd.Flip()) return; //no reordering
        T tmp = a; a = b; b = tmp;
    }

    public static int LongestStreak<T>(this IEnumerable<T> sequence, Predicate<T> selector)
    {
        int current = 0;
        int longest = 0;
        foreach (T x in sequence)
        {
            if (selector(x))
            {
                current++;
                if (current > longest) longest = current;
            }
            else
            {
                current = 0;
            }
        }
        return longest;
    }

    public static void Repeat(this Action action, int N)
    {
        for (int n = 0; n < N; n++) action();
    }
}

第二种变体 - 蛮力。如果序列很短，可以使用。您还可以使用它获得所有可能的变体。

    class Program
{
    static void Main(string[] args)
    {
        var res = new[] { true, false }.Words(10).Where(w => {
            return
                w.Count(g => g) == 7 &&
                w.LongestStreak(g => g) == 5 &&
                w.LongestStreak(g => !g) == 2;
        });
        foreach (var v in res)
        {
            foreach (var b in v)
            {
                Console.Write(b ? "*" : ".");
            }
            Console.WriteLine();
        }
        Console.WriteLine(res.Count());
        Console.ReadLine();
    }
}

public static class Helper
{
    public static IEnumerable<IEnumerable<T>> Words<T>(this IEnumerable<T> alphabet, int len)
    {
        foreach (var l in alphabet)
        {
            if (len == 1)
            {
                yield return l.Yield();
            }
            else
            {
                foreach (var w in alphabet.Words(len - 1))
                {
                    yield return w.Prepend(l);
                }
            }
        }
    }

    public static IEnumerable<T> Yield<T>(this T item)
    {
        yield return item;
    }

    static IEnumerable<T> Prepend<T>(this IEnumerable<T> rest, T first)
    {
        yield return first;
        foreach (var item in rest)
            yield return item;
    }

    public static int LongestStreak<T>(this IEnumerable<T> sequence, Predicate<T> selector)
    {
        int current = 0;
        int longest = 0;
        foreach (T x in sequence)
        {
            if (selector(x))
            {
                current++;
                if (current > longest) longest = current;
            }
            else
            {
                current = 0;
            }
        }
        return longest;
    }
}

Answer 2

我的建议是使用算法从长度-n（您的 total 数字）字符串中选择 k 位（您的 won 数字）。在这里，我使用@foglebird 写的kbits(n, k) function。然后，您可以使用列表推导过滤掉不需要的排列。

import itertools

def kbits(n, k):
    result = []
    for bits in itertools.combinations(range(n), k):
        s = ['0'] * n
        for bit in bits:
            s[bit] = '1'
        result.append(''.join(s))
    return result

total = 10
won = 7
lost = 3
max_win = 5
max_lose = 2

answer = [x for x in kbits(total, won) if '1'*(max_win+1) not in x and '0'*(max_lose+1) not in x]

Answer 3

我发布了一个答案，然后发现我错过了一些关键要求。我添加并更改了一些内容以解决这些缺失的元素。

核心方法在大多数情况下都会失败，但它的速度非常快，以至于您可以循环执行，直到得到一个好的答案。根据实际值，在法律结果很少的情况下，您似乎需要运气。

使用的步骤：

• 为最长的连胜选择一个随机点（在示例中为获胜）
• 用损失括起来以防止在设置剩余时延长它
• 找到具有足够连续槽的索引以保持连续丢失
• 随机选择一个并设置连续亏损（如果没有则返回）
• 将所有 Leftovers 设置为 Not the value at n-1 以避免扩展或创建新的连胜

因此，无论 WinCount 和 LossCount 是否正确，都是命中或未命中。这似乎比大小合适的条纹更容易被发现。包装器方法测试结果以拒绝并重新运行。使用给定的值，它通常会在前 10 次左右找到获胜者。

---

构造字符串表示的核心方法，以及一个helper：

' ToDo change to return Bool() = string is easier to read
Private Function FarhamStreaks(winStrk As Int32, loseStrk As Int32, total As Int32) As String

    ' -1 == not set
    Dim result = Enumerable.Repeat(-1, total).ToArray

    ' set longest streak first
    Dim wNDX = RNG.Next(0, total + 1 - winStrk)
    For n As Int32 = 0 To winStrk - 1
        result(wNDX + n) = 1
    Next
    ' bracket with losers so the w streak cant extend
    If wNDX > 0 Then result(wNDX - 1) = 0
    If wNDX + winStrk < result.Length - 1 Then result(wNDX + winStrk) = 0

    ' look for eligible consecutive starting slots
    ' might be none
    Dim lossNdx As New List(Of Int32)
    For n As Int32 = 0 To result.Count - 1
        Dim count = CountConsecutiveLooserSlotsFrom(n, result)

        If (n + 1) < result.Count AndAlso count >= loseStrk Then
            lossNdx.Add(n)
        End If
    Next

    If lossNdx.Count = 0 Then
        ' do over 
        ' the code has never gotten here
        ' but depends on the mix of values
        Return ""
    End If

    ' set losses
    Dim lNdx = lossNdx(RNG.Next(0, lossNdx.Count))
    For n As Int32 = 0 To loseStrk - 1
        result(lNdx + n) = 0
    Next

    ' set the leftovers based on next value to avoid 
    ' extending streaks
    For n As Int32 = 0 To result.Length - 1
        If result(n) = -1 Then
            If n > 0 Then
                result(n) = If(result(n - 1) = 0, 1, 0)
            Else
                result(n) = If(result(n + 1) = 0, 1, 0)
            End If
        End If
    Next

    Dim resultString = String.Join(",", result)

    ' convert to boolean
    Dim realResult(total) As Boolean
    For n As Int32 = 0 To total - 1
        realResult(n) = Convert.ToBoolean(result(n))
    Next

    Return resultString
End Function

' find candidate slots for the shorter streak:
Private Function CountConsecutiveLooserSlotsFrom(ndx As Integer, theArray As Int32()) As Int32
    Dim count As Int32 = 1    ' including ndx

    For n As Int32 = ndx To theArray.Length - 2
        If theArray(n) <> 1 AndAlso theArray(n + 1) <> 1 Then
            count += 1
        Else
            Exit For
        End If
    Next
    Return count
End Function

验证候选结果（和性能指标）的方法：

Private Function MakeFarhamStreak(wins As Int32, winStreak As Int32,
                                  lossStreak As Int32,
                                  total As Int32) As String
    Const MaxTries As Int32 = 999
    Dim losses = (total - wins)
    Dim reverse As Boolean = (lossStreak > winStreak)
    Dim candidate As String
    Dim sw As New Stopwatch
    Dim pass, fail As Int32
    Dim count As Int32

    sw.Start()

    For n As Int32 = 0 To MaxTries

        If reverse Then
            candidate = FarhamStreaks(lossStreak, winStreak, total)
            ' to do: un-reverse (Not) the results - 
        Else
            candidate = FarhamStreaks(winStreak, lossStreak, total)
        End If

        Dim result = candidate.Split(","c)

        ' test win count
        count = candidate.Where(Function(f) f = "1").Count
        If count <> wins Then
            fail += 1
            Continue For
        End If

        ' test loss count
        count = candidate.Where(Function(f) f = "0").Count
        If count <> losses Then
            fail += 1
            Continue For
        End If

        Dim tmp = candidate.Replace(","c, "")

        ' test win streak size
        Dim wstreaks = tmp.Select(Function(c, i) tmp.Substring(i).
                                      TakeWhile(Function(q) q = c AndAlso q = "1").
                                      Count()).
                                  Max
        If wstreaks <> winStreak Then
            fail += 1
            Continue For
        End If

        Dim lstreaks = tmp.Select(Function(c, i) tmp.Substring(i).
                          TakeWhile(Function(q) q = c AndAlso q = "0").
                          Count()).
                      Max
        If lstreaks <> lossStreak Then
            fail += 1
            Continue For
        End If

        pass += 1
        If pass = 1 Then
            Console.WriteLine("First Pass in {0}ms  (try # {1} = {2})",
                              sw.ElapsedMilliseconds, n, candidate)
            ' normally, return at this point
        End If
    Next

End Function

将较短的条纹放在较长的条纹周围更容易，因此它会根据需要颠倒 parm 顺序。没有代码可以翻转/没有结果。

结果：

在 18 毫秒内首次通过（尝试 #4 = 1,1,1,1,1,0,0,1,0,1）
失败总数 753 75.38%
总通过率 247 24.72%
999 个候选人的总时间 29ms

它在尝试 #4 中找到了第一个传递值 - 对于 10、7w、5ws、2ls 值，它通常在前 10 个中找到一个。