1

我将输入作为int并根据该输入我想要两个字符的组合， 例如我将输入作为 2 并且我有两个字符 x 和 y 所以我想要像这样的组合

    xx,yy,xy,yx

如果输入是 3，我想要

    xxx,xyy,xxy,xyx,yxx,yyy,yxy.yyx

依此类推，我尝试使用以下代码，

     int input1 = 4;
        Double totalpossibilities = Math.Pow(2, input1);
        string[] PArray = new string[Convert.ToInt16(totalpossibilities)];
        char[] chars = new char[] { 'x', 'y'};

        for (int i = 0; i < totalpossibilities; i++)
        {
            string possibility = "" ;
            for (int j = 0; j < input1; j++)
            {
                Random random = new Random();
                int r = random.Next(chars.Length);
                char randomChar = chars[r];
                possibility = possibility + randomChar;

            }
            if (PArray.Contains(possibility))
            {
                i--;
            }
            else
                PArray[i] = possibility;
        }

但是你可以看到我使用的是随机函数所以我完成的时间太长了，有什么不同的逻辑吗？

4

5 回答 5

4

使用从这里逐字复制的笛卡尔积扩展方法的副本：

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})); 
}

然后在您的代码中，您可以拥有：

IEnumerable<char> possibleCharacters = "xy";//change to whatever
int numberOfDigits = 3;

var result = Enumerable.Repeat(possibleCharacters, numberOfDigits)
     .CartesianProduct()
     .Select(chars => new string(chars.ToArray()));

//display (or do whatever with) the results
foreach (var item in result)
{
    Console.WriteLine(item);
}
于 2012-05-15T18:05:31.417 回答
3

您可以运行从 0 到全部可能性的 for 循环。将 i 转换为二进制，例如，在第 20 次迭代中，这将导致“10100”。将结果填充到 input1 个字符，例如（8 个位置）：00010100 然后转换为字符串并将所有零替换为“x”，所有替换为“y”。

        int places = 4;
        Double totalpossibilities = Math.Pow(2, places);

        for (int i = 0; i < totalpossibilities; i++)
        {
            string CurrentNumberBinary = Convert.ToString(i, 2).PadLeft(places, '0');

            CurrentNumberBinary = CurrentNumberBinary.Replace('0', 'x');
            CurrentNumberBinary = CurrentNumberBinary.Replace('1', 'y');
            Debug.WriteLine(CurrentNumberBinary);
        }
于 2012-05-15T18:04:03.100 回答
0

如果你总是有 2 个字符，那么最简单的方法是使用整数组合性质。如果您采用从 2^n 到 2^(n+1) - 1 的所有数字的二进制形式，您会注意到它表示长度为 n 的“0”和“1”的所有可能组合：)。

对于超过 2 个字符，我将使用类似的方法，但基数不同。

于 2012-05-15T18:13:35.577 回答
0

这是一个解决方案List<>。泛化到任意数量的字母。

static List<string> letters = new List<string> { "x", "y", };

static List<string> MakeList(int input)
{
  if (input < 0)
    throw new ArgumentOutOfRangeException();

  var li = new List<string> { "", };

  for (int i = 0; i < input; ++i)
    li = Multiply(li);

  return li;
}

static List<string> Multiply(List<string> origList)
{
  var resultList = new List<string>(origList.Count * letters.Count);
  foreach (var letter in letters)
    resultList.AddRange(origList.Select(s => letter + s));
  return resultList;
}
于 2012-05-15T19:26:23.287 回答
0

svenv 答案是对这个问题的正确（而且非常聪明）的答案，但我想我会提供一个通用的解决方案来生成一组标记的所有排列，这可能对可能有类似问题的其他人有用。

public class Permutations
{
    public static string[][] GenerateAllPermutations(string[] tokens, int depth)
    {
        string[][] permutations = new string[depth][];

        permutations[0] = tokens;

        for (int i = 1; i < depth; i++)
        {
            string[] parent = permutations[i - 1];
            string[] current = new string[parent.Length * tokens.Length];

            for (int parentNdx = 0; parentNdx < parent.Length; parentNdx++)
                for (int tokenNdx = 0; tokenNdx < tokens.Length; tokenNdx++)
                    current[parentNdx * tokens.Length + tokenNdx] = parent[parentNdx] + tokens[tokenNdx];

            permutations[i] = current;
        }

        return permutations;
    }

    public static void Test()
    {
        string[] tokens = new string[] { "x", "y", "z" };
        int depth = 4;

        string[][] permutations = GenerateAllPermutations(tokens, depth);

        for (int i = 0; i < depth; i++)
        {
            foreach (string s in permutations[i])
                Console.WriteLine(s);

            Console.WriteLine(string.Format("Total permutations:  {0}", permutations[i].Length));
            Console.ReadKey();
        }
    }
}

干杯，

于 2012-05-15T19:26:58.327 回答