Question

我需要结合Stings＆＃34; a＆＃34; ＆＃34; B＆＃34; ＆＃34; C＆＃34; ＆＃34; d＆＃34 ;. 我已经尝试将它们放在一个列表中，然后通过它们解析一个foreach方法，但无济于事。

我还能做什么？

Answer 1

将字符串放在数组中，您可以使用下面的函数打印所有排列，以便输出：abcd，abdc，adbc等。

递归排列（来自MSDN）：

public static void Permute(string[] strings, int start, int finish)
  {
    if (start == finish)
    {
      for (int i = 0; i <= finish; ++i)
      {
        Console.Write(strings[i] + " " );
      }
        Console.WriteLine("");
    }
    else
    {
      for (int i = start; i <= finish; ++i)
      {
        string temp = strings[start];
        strings[start] = strings[i];
        strings[i] = temp;

        Permute(strings, start+1, finish);

        temp = strings[start];
        strings[start] = strings[i];
        strings[i] = temp;
      }
    }

  }  // Permute()

Answer 2

你会列出一个名单吗？

List<String>myStrings = new List<String>();

myStrings.Add("a");
...
myStrings.Add("d");

你应该能够遍历那个

Answer 3

我会给你逻辑。

创建一个List<String>，然后继续添加每个字符串。

List<String> s = new List<String>();  

s.add("a");
s.add("b");
s.add("c");
s.add("d");

添加完所有字符串后，在最小和最大索引之间生成一个随机数，如下所示：

private int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max); 
}

然后，在使用此编号在List上的循环中打印每个字符串时，确保检查nex迭代不会重复相同的随机数。

Answer 4

如果您有一定数量的字符串可以使用

var s = String.Format("{0}{1}{2}{3}", stringA, stringB, stringC, stringD);

否则for / foreach循环将成为前进之路，

var sb = new StringBuilder();
var strings = new List<string>();

// Add strings to list

for (var i = 0; i < strings.Count; i++)
{
    sb.Append(strings[i]);
}

var s = sb.ToString();

我不会使用字符串+字符串+字符串样式连接，因为这是不好的做法，因为字符串在内存中的工作方式。

编辑：我还没有测试它在浏览器中编写的代码！如果您有任何问题，请告诉我。

刚看到上面的评论，我发布的代码将始终以相同的顺序输出字符串，因此可能不是您想要的。

HTH

单次

Answer 5

List<String>stringList = new List<String>();

stringList.Add("a");
stringList.Add("b");
...
...

foreach(string item in stringList)
 {
   string text=item;
}

Answer 6

此示例执行所有组合（正确）：

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

public static class Program
{
    public static void Main(string[] args)
    {
        var list = new [] { "a", "b", "c", "d" };
        foreach (var combi in Enumerable.Repeat(list, list.Length).CartesianProduct())
            Console.WriteLine(string.Join(" ", combi));
    }

    static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences) 
    { 
        IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() }; 
        return sequences.Aggregate( 
                emptyProduct, 
                (accumulator, sequence) =>  
                from accseq in accumulator  
                from item in sequence  
                select accseq.Concat(new[] {item}));                
    }
}

输出：

a a a a
a a a b
a a a c
a a a d
a a b a
a a b b
a a b c
a a b d
a a c a
a a c b
....
d d b c
d d b d
d d c a
d d c b
d d c c
d d c d
d d d a
d d d b
d d d c
d d d d

如果您需要排列，可以从

中输入算法

MoreLinq
CodeProject http://www.codeproject.com/KB/recipes/Combinatorics.aspx

如何在C＃中组合字符串？

6 个答案: