c# - 从一个列表创建两个随机列表

Question

我想获取一个包含大约 12 个对象的字符串列表，并将其拆分为两个字符串列表，但将其完全随机化。

列表示例:

列表 1:

EXAMPLE 1
EXAMPLE 2
EXAMPLE 3
EXAMPLE 4
EXAMPLE 5
EXAMPLE 6
EXAMPLE 7
EXAMPLE 8

在这里应用一些逻辑......

结果给了我两个列表:列表 1:

EXAMPLE 5
EXAMPLE 6
EXAMPLE 1
EXAMPLE 8

list 2:

EXAMPLE 2
EXAMPLE 3
EXAMPLE 4
EXAMPLE 7

我是 C# MVC 的新手，所以我在 Stack 上找到了一些答案，但没有人能够回答我的问题。

编辑:到目前为止我所尝试的给了我一个随机的团队成员。我现在想对此进行扩展并创建上面提到的两个列表。

  [HttpPost]
    public ActionResult Result(Models.TeamGenerator model)
    {
        var FormNames = model.Names;

        string[] lines = FormNames.Split(
            new[] { Environment.NewLine },
            StringSplitOptions.None);

        List<string> listOfLines = new List<string>();

        foreach (var i in lines)
        {
            listOfLines.Add(i);
        }
        string[] result1 = listOfLines.Where(item => item != string.Empty).ToArray();

        Random genRandoms = new Random();
        int aRandomTeam = genRandoms.Next(listOfLines.Count);

        string currName = listOfLines[aRandomTeam];

        return View();
    }

*编辑** 感谢您的解决方案!我现在已经让我的应用程序正常工作并设法将其发布到网络上，https://www.teamgenerator.online .

Answer 1

1. 创建一个与字符串列表大小相同的 bool 数组。
2. 用 true 填充 bool 数组的一半，用 false 填充另一半。
3. 打乱 bool 值数组。
4. 遍历字符串列表。对于每个元素，如果 bool 数组中的相应元素为 true，则将该元素包含在第一个列表中；否则将其包含在第二个列表中。

如果这很重要，这种方法可以使项目保持与原始数组中相同的顺序。 (如果不是，只需将整个字符串数组打乱，然后取前半部分和后半部分)。

示例代码:

using System;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            var strings = Enumerable.Range(1, 20).Select(i => i.ToString()).ToList();

            var rng = new Random();
            int n = strings.Count;

            var include = // Create array of bools where half the elements are true and half are false
                Enumerable.Repeat(true, n/2) // First half is true
                .Concat(Enumerable.Repeat(false, n-n/2)) // Second half is false
                .OrderBy(_ => rng.Next()) // Shuffle
                .ToArray(); 

            var list1 = strings.Where((s, i) =>  include[i]).ToList(); // Take elements where `include[index]` is true
            var list2 = strings.Where((s, i) => !include[i]).ToList(); // Take elements where `include[index]` is false

            Console.WriteLine(string.Join(", ", list1));
            Console.WriteLine(string.Join(", ", list2));
        }
    }
}

---

这是一种完全不同的方法，它使用标准算法的修改版本从 N 项中选择 K 项(在本例中，K = N/2):

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            var strings = Enumerable.Range(1, 20).Select(n => n.ToString()).ToList();

            var list1 = new List<string>();
            var list2 = new List<string>();

            var rng       = new Random();
            int available = strings.Count;
            int remaining = available / 2;

            foreach (var s in strings)
            {
                if (rng.NextDouble() < remaining / (double) available)
                {
                    list1.Add(s);
                    --remaining;
                }
                else
                {
                    list2.Add(s);
                }

                --available;
            }

            Console.WriteLine(string.Join(", ", list1));
            Console.WriteLine(string.Join(", ", list2));
        }
    }
}

这种方法比我的第一个解决方案性能更高，但由于您的列表只有大约 12 个项目，所以这对您的问题来说并不重要。