-6

我想编写一个方法，将字符串数组划分为n 个单独的数组，每个数组大约是我指定的大小。

例如，如果我要划分的数组有 23 个元素，那么如果我指定 7 作为大约元素数：

1st array with 8 elements
2nd array with 8 elements 
3rd array with 7 elements

另一个例子是如果有 100 个元素并且我指定每个数组有 18 个元素，那么：

1st array 20 
2nd array 20
3rd array 20
4th array 20
5th array 20

到目前为止，我知道该函数需要返回一个字符串数组列表，但我不知道该怎么做：

private List<string[]> divStrings(int ExpectedStringsPerArray, 
    string[] AllStrings)
{
    // ...
}

数组的数量将是

 Math.Floor(AllStrings.Count()/ExpectedStringsPerArray)

如何在 C# 中将数组划分为单独的数组？

4

4 回答 4

4

我可能错误地解释了您的问题，因为这似乎太容易了：

  1. 确定将源数组划分为多少个数组。( totalCount / elementsPerArray )
  2. 对于每个数组：
    1. 确定要放入多少元素。（元素剩余/数组剩余）
    2. 将这些元素复制到一个新数组中。

在代码中：

private static List<string[]> DivideStrings(int expectedStringsPerArray, string[] allStrings)
{
    List<string[]> arrays = new List<string[]>();

    int arrayCount = allStrings.Length / expectedStringsPerArray;

    int elemsRemaining = allStrings.Length;
    for (int arrsRemaining = arrayCount; arrsRemaining >= 1; arrsRemaining--)
    {
        int elementCount = elemsRemaining / arrsRemaining;

        string[] array = CopyPart(allStrings, elemsRemaining - elementCount, elementCount);
        arrays.Insert(0, array);

        elemsRemaining -= elementCount;
    }

    return arrays;
}

 

private static T[] CopyPart<T>(T[] array, int index, int length)
{
    T[] newArray = new T[length];
    Array.Copy(array, index, newArray, 0, length);
    return newArray;
}

像这样使用时：

const int count = 23;
const int estimate = 7;
string[] strings = Enumerable.Range(1, count).Select(s => s.ToString()).ToArray();
var list = DivideStrings(estimate, strings);
foreach (var arr in list)
    Console.WriteLine(String.Join(" ", arr));

它打印：

1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23
于 2013-03-20T03:07:39.937 回答
3

您可以使用Enumerable.Range来获取除数，然后使用Linq Skip和Take选择数组来选择项目。

例子：

 public List<string[]> divStrings(int count, string[] array)
 {
    long remainder;
    long divCount = Math.DivRem(array.Count(), count, out remainder);
    int ajustedCount = (int)((divCount > remainder) 
                       ? (divCount / remainder) 
                       : (remainder / divCount)) + count;
    int groupCount = (ajustedCount * divCount) > array.Count() 
        ? (int)divCount
        : (int)divCount++;
    return Enumerable.Range(0, groupCount).Select(g => array.Skip(g * ajustedCount).Take(ajustedCount).ToArray()).ToList();
 }

然而

这可能是一种方便的扩展方法

public static class Extensions
{
    public static List<T[]> SplitEven<T>(this T[] array, int count)
    {
        long remainder;
        long divCount = Math.DivRem(array.Count(), count, out remainder);
        int ajustedCount = (int)((divCount > remainder) 
                           ? (divCount / remainder) 
                           : (remainder / divCount)) + count;
        int groupCount = (ajustedCount * divCount) > array.Count() 
            ? (int)divCount
            : (int)divCount++;
        return Enumerable.Range(0, groupCount).Select(g => array.Skip(g * ajustedCount).Take(ajustedCount).ToArray()).ToList();
    }   
}

用法：

string[] test = new string[]{};
var result = test.Split<string>(7);

int[] test = new int[]{};
var result = test.Split<int>(7);
于 2013-03-20T03:02:04.323 回答
2

干得好。请记住，您可以使用 .ToList() 将列表更改为数组.ToArray()，使用 .ToList() 将数组更改为列表，这就是我将它们全部设为列表的原因。

List<List<string>> divStrings(int ExpectedStringsPerArray, List<string> AllStrings)
{
    //Set what we're currently up to in the array
    var espa = ExpectedStringsPerArray;
    var ListOfLists = new List<List<string>>();

    //Add the first bunch of elements to the list of lists.
    ListOfLists.Add(AllStrings.Take(ExpectedStringsPerArray).ToList());

    //While we still have elements left to get out
    while (AllStrings.Skip(espa).Take(ExpectedStringsPerArray).Count() != 0)
    {
        //Add the list data we're currently up to to the list of lists
        ListOfLists.Add(AllStrings.Skip(espa).Take(ExpectedStringsPerArray).ToList());
        //Offset what we're up to so next time we're getting the next lot of data
        espa += ExpectedStringsPerArray;
    }

    return ListOfLists;
}

调用它：

divStrings(30,testList);

于 2013-03-20T02:37:31.027 回答
1

这个问题得到了回答。我遇到了这个并以我的方式回答。

我不确定你所说的近似是什么意思，我认为不应该这样做。您必须确定您要查找的数组的大小。以下是未经测试的代码示例。

List<List<int>> lists = new List<List<int>>();
const int myLimit = 20;

var numbers = (from n in myArray select n).ToList();

while (numbers.Any())
{
    var list = (from number in numbers select number).Take(myLimit).ToList();
    numbers.RemoveRange(0, list.Count());
    lists.Add(list);
}

// Now lists should have list of equal number if items in each. Last one may be an exception.

希望能帮助到你。

于 2013-07-11T11:18:37.303 回答