如何将字符串列表拆分为更小的字符串列表块

Question

我要解决的问题如下：

我有一个List<string>，我们称之为“initialList”。

我需要与该列表中的所有字符串进行交互，所以我必须枚举它。但是，问题来了，我每次交互时都必须取其中的“x”个元素。

x 是 new Random().Next(_minValue, _maxValue);，所以每次都是随机的。

这是我想做的一个真实例子：

假设列表initialList 包含以下元素： test, test2, test3, test4, test5, test6, test7, test8, test9, test10, test11, test12.

我想遍历所有元素，一次取 2-3 个字符串，然后保存一个包含组合字符串的新字符串。

因此，一种可能的输出（因 Random 返回的值而异）是：

{ "test",  "test1", "test2" }, 
{ "test3", "test4" }, 
{ "test5", "test6" }, 
{ "test7", "test8" }, 
{ "test9", "test10", "test11" }, 
{ "test12" }

我想做什么：

for (var i = 0; i < _users.Count; i += _random.Next(_minMentions, _maxMentions + 1))
{
    var mergedString = ?? // get the values of the next _random.Next(_minMentions, _maxMentions + 1) strings
}

我在想，但是如果我在循环之外生成随机数，那么它总是一样的。我希望字符串的数量每次都是随机的。

另外，考虑通过选择具有索引的元素来执行 LINQ，但不知道如何从那里着手。

感谢您的帮助。

Answer 1

我知道有很多很好的答案，但如果你喜欢 IEnumerable，这里有一些东西

public static class EnumerableGroupOf
    {
        public static IEnumerable<IEnumerable<TSource>> RandomGroupOf<TSource>(this IEnumerable<TSource> source, int[] groupLengths)
        {
            Random random = new Random();

            var itemsLeft = source;

            while (itemsLeft.Any())
            {
                var count = groupLengths[random.Next(0, groupLengths.Length)];

                var items = itemsLeft.Take(count);

                itemsLeft = itemsLeft.Skip(count);

                yield return items;
            }
        }
    }

这不会跳过并接受所有项目，只是铰接项目，因此使用 Enumerable 可能会表现得更好。

Answer 2

你可以直接试试GroupBy:

  List<string> initialList = Enumerable
    .Range(1, 15)
    .Select(i => $"test{i}")
    .ToList();

  int _minMentions = 2;
  int _maxMentions = 3;

  // Random(1): to make outcome reproducible
  // In real life should be new Random();  
  Random _random = new Random(1); 

  int group = 0;
  int groupLength = 0;

  var result = initialList
    .Select((item) => {
      if (--groupLength <= 0) {
        group += 1;
        groupLength = _random.Next(_minMentions, _maxMentions + 1);
      }

      return new { item, group };
    })
    .GroupBy(item => item.group)
    .Select(chunk => chunk
       .Select(item => item.item)
       .ToList())
    .ToList();

  string test = string.Join(Environment.NewLine, result
    .Select(items => string.Join(", ", items))); 

  Console.Write(test);

结果：

test1, test2
test3, test4
test5, test6
test7, test8, test9
test10, test11, test12
test13, test14
test15

Answer 3

我认为最好的解决方案是使用 LINQ Skip 跳过您已经处理过的元素并使用Take 提取随机数量的元素。

const int _minValue = 2;
const int _maxValue = 4; // note max of random is exclusive, so this config takes 2 or 3 elements

var _random = new Random(Guid.NewGuid().GetHashCode());

List<string> initialList = new List<string>{"test", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10", "test11", "test12"};

var currentPosition = 0;

while (currentPosition < initialList.Count()) {
    var toTake = _random.Next(_minValue, _maxValue);
    var mergedString = string.Join(", ", initialList.Skip(currentPosition).Take(toTake)); 
    currentPosition += toTake;
}

请注意，此代码可能会导致最后一个 mergedString 仅包含一个元素（最后一个）。

工作示例：C# Fiddle。

Answer 4

希望这会给你一个想法。

var mergedList = new List<string>();
for(int i = 0; i < initialList.Count; ){
    var n = _random.Next(2,4);
    mergedList.Add(initialList.Skip(i).Take(n).Aggregate((x,y) => x + y));
    i += n;
}

Answer 5

以下是使用 Linq 实现它的方法：

var initialList = new[]
{
    "test", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10", "test11",
    "test12"
};

var newLists = new List<IEnumerable<string>>();
var rnd = new Random();
int minMentions = 2;
int maxMentions = 3;
int c = 0;

while (c < initialList.Length)
{
    int elementsToTake = rnd.Next(minMentions, maxMentions + 1);
    newLists.Add(initialList.Skip(c).Take(elementsToTake));
    c += elementsToTake;
}

这会导致（随机）：

{ test, test2, test3 }
{ test4, test5 }
{ test6, test7, test8 }
{ test9, test10, test11 }
{ test12 }

请注意，Take 只会占用可用的项目，因此您无需担心 elementsToTake 比 initialList 剩下的要大。

Answer 6

您可以使用 IEnumerable.Skip 和 Take 来循环您的初始列表并创建所需大小的块，直到您有要处理的元素。

List<string> initiallist = new List<string>
{"test", "test2", "test3", "test4", "test5", "test6", "test7", "test8", "test9", "test10", "test11", "test12"};

// We store the results here    
List<List<string>> result = new List<List<string>>();

Random rnd = new Random();
int pos = 0;
while (pos < initiallist.Count())
{
    // Define a block size of 2/3 elements
    int block = rnd.Next(2,4);

    // Extract the block size from the previous position
    List<string> temp = initiallist.Skip(pos).Take(block).ToList();

    // Add the sublist to our results
    result.Add(temp);

    // Point to the beginning of the next block
    pos += block;

}