Объединение массивов строк вместе

Я хочу совместить содержимое двух строковых массивов, в новый список, в котором есть содержимое обоих элементов.

string[] days = { "Mon", "Tue", "Wed" };
string[] months = { "Jan", "Feb", "Mar" };

// I want the output to be a list with the contents
// "Mon Jan", "Mon Feb", "Mon Mar", "Tue Jan", "Tue Feb" etc...

Как я могу это сделать? Ибо, когда это только два массива, следующие работы и достаточно легки:

List<string> CombineWords(string[] wordsOne, string[] wordsTwo)
{
    var combinedWords = new List<string>();
    foreach (var wordOne in wordsOne)
    {
        foreach (string wordTwo in wordsTwo)
        {
            combinedWords.Add(wordOne + " " + wordTwo);
        }
    }
    return combinedWords;
}

Но я хотел бы иметь возможность передавать различное количество массивов (например, иметь метод с подписями ниже) и работать с ним.

List<string> CombineWords(params string[][] arraysOfWords)
{
    // what needs to go here ?
}

Или какое-то другое решение было бы здорово. Если это возможно сделать просто с Linq, еще лучше!

Ответ 1

Код ниже работает для любого количества массивов (и в некоторой степени использует linq):

List<string> CombineWords(params string[][] wordsToCombine)
{
     if (wordsToCombine.Length == 0)
         return new List<string>();

     IEnumerable<string> combinedWords = wordsToCombine[0].ToList();
     for (int i = 1; i < wordsToCombine.Length; ++i)
     {
         var temp = i;
         combinedWords = (from x in combinedWords from y in wordsToCombine[temp]
                       select x + " " + y);
     }
     return combinedWords.ToList();
 }

Ответ 2

То, что вы хотите сделать, на самом деле является декартовым произведением всех массивов слов, а затем присоединяется к словам с пробелами. Эрик Липперт имеет простую реализацию декартова продукта Linq здесь. Вы можете использовать его для реализации CombineWords:

List<string> CombineWords(params string[][] arraysOfWords)
{
    return CartesianProduct(arraysOfWords)
            .Select(x => string.Join(" ", x))
            .ToList();
}

Ответ 3

Для перекрестного соединения на любом количестве массивов строк:

// Define other methods and classes here
List<string> CombineWords(params string[][] arraysOfWords)
{
    if (arraysOfWords.Length == 0)
        return new List<string>();

    IEnumerable<string> result = arraysOfWords[0];

    foreach( string[] words in arraysOfWords.Skip(1) )
    {
        var tempWords = words;

        result = from r in result
                 from w in tempWords 
                 select string.Concat(r, " ", w);
    }

    return result.ToList();
}

Ответ 4

public static List<string> CombineWords(params string[][] arraysOfWords)
{
    var strings = new List<string>();

    if (arraysOfWords.Length == 0)
    {
        return strings;
    }

    Action<string, int> combineWordsInternal = null;

    combineWordsInternal = (baseString, index) =>
    {
        foreach (var str in arraysOfWords[index])
        {
            string str2 = baseString + " " + str;

            if (index + 1 < arraysOfWords.Length)
            {
                combineWordsInternal(str2, index + 1);
            }
            else
            {
                strings.Add(str2);
            }
        }
    };

    combineWordsInternal(string.Empty, 0);

    return strings;
}

Вторая попытка... Я не могу сделать это в LINQ... Немного сложнее, чем правильно выполнить linquize: -)

Я использую локальную анонимную функцию (и показываю, что она довольно сложна для обработки анонимных функций, потому что вы должны объявлять их отдельно)

Ответ 5

Это нерекурсивное решение, которое буферизует строки по мере их продвижения, чтобы уменьшить количество конкатенаций. Поэтому он также должен использоваться для большего количества массивов. Он также сохраняет желаемый порядок - элементы в первом массиве всегда будут в начале результирующей строки.

  var s1 = new string[] { "A", "B", "C" };
  var s2 = new string[] { "1", "2", "3", "4" };
  var s3 = new string[] { "-", "!", "?" };
  var res = Combine(s1, s2, s3);

И функция, о которой идет речь:

private List<string> Combine(params string[][] arrays)
{
    if (arrays.Length == 1)
    {
        // The trivial case - exit.
        return new List<string>(arrays[0]);
    }
    IEnumerable<string> last = arrays[arrays.Length - 1];
    // Build from the last array, progress forward
    for (int i = arrays.Length - 2; i >= 0; i--)
    {
        var buffer = new List<string>();
        var current = arrays[i];
        foreach (var head in current)
        {
            foreach (var tail in last)
            {
                // Concatenate with the desired space.
                buffer.Add(head + " " + tail);
            }
        }
        last = buffer;
    }
    return (List<string>)last;
}

Ответ 6

Не могли бы вы попробовать этот метод?

static List<string> CombineWords(string[] wordsOne, string[] wordsTwo)
{
    var combinedWords = new List<string>();
    for(int x = 0; (x <= wordsOne.Length - 1); ++x)
    {
        for(int y = 0; (x <= wordsTwo.Length - 1); ++y)
        {
            combinedWords.Add(string.Format("{0} {1}", wordsOne[x], wordsTwo[y]));
        }
    }
    return combinedWords;
}

Kris