C# 如何获得所有可能的3个字母排列？

可能重复：

比如说,

aaa .. aaz .. aba .. abz .. aca .. acz .. azz .. baa .. baz .. bba .. bbz .. zzz

基本上，想象一下计算二进制数，但不是从0到1，而是从a到z

我一直试图让这个工作没有任何效果，公式变得相当复杂。我不确定是否有更简单的方法

编辑 目前我有类似的东西，但还不完全存在，我不确定是否有更好的方法：

private IEnumerable<string> GetWordsOfLength(int length)
{
    char letterA = 'a', letterZ = 'z';

    StringBuilder currentLetters = new StringBuilder(new string(letterA, length));
    StringBuilder endingLetters = new StringBuilder(new string(letterZ, length));

    int currentIndex = length - 1;

    while (currentLetters.ToString() != endingLetters.ToString())
    {
        yield return currentLetters.ToString();

        for (int i = length - 1; i > 0; i--)
        {
            if (currentLetters[i] == letterZ)
            {
                for (int j = i; j < length; j++)
                {
                    currentLetters[j] = letterA;
                }

                if (currentLetters[i - 1] != letterZ)
                {
                    currentLetters[i - 1]++;
                }
            }
            else
            {
                currentLetters[i]++;

                break;
            }
        }
    }
}

private IEnumerable GetWordsOfLength（int-length）
{
字符字母a='a'，字母z='z'；
StringBuilder currentLetters=新StringBuilder（新字符串（字母A，长度））；
StringBuilder endingLetters=新StringBuilder（新字符串（字母Z，长度））；
int currentIndex=长度-1；
while（currentLetters.ToString（）！=endingLetters.ToString（））
{
返回currentLetters.ToString（）；
对于（int i=长度-1；i>0；i--）
{
if（当前字母[i]==字母Z）
{
对于（int j=i；j

编辑

对于一般解决方案，可以使用

---

//Eric Lippert的博客
//用LINQ计算笛卡尔积
// http://blogs.msdn.com/b/ericlippert/archive/2010/06/28/computing-a-cartesian-product-with-linq.aspx
公共静态IEnumerable CartesianProduct（此IEnumerable序列）
{
//基本情况：
IEnumerable result=new[]{Enumerable.Empty（）}；
foreach（序列中的var序列）
{
var s=sequence；//不要关闭循环变量
//递归案例：使用SelectMany在旧产品的基础上构建新产品
结果=
从结果中的seq
从s中的项目
选择seq.Concat（新[]{item}）；
}
返回结果；
}

您有26^3个计数表示3个“数字”。只需在三个循环中从“a”迭代到“z”。

这里有一个非常简单的解决方案：

for(char first = 'a'; first <= (int)'z'; first++)
    for(char second = 'a'; second <= (int)'z'; second++)
        for(char third = 'a'; third <= (int)'z'; third++)
            Console.WriteLine(first.ToString() + second + third);

---

对于（char first='a'；first对于数量可变的字母组合，可以执行以下操作：

var alphabet = "abcdefghijklmnopqrstuvwxyz";
var q = alphabet.Select(x => x.ToString());
int size = 4;
for (int i = 0; i < size - 1; i++)
    q = q.SelectMany(x => alphabet, (x, y) => x + y);

foreach (var item in q)
    Console.WriteLine(item);

var alphabet=“abcdefghijklmnopqrstuvwxyz”；
var q=alphabet.Select（x=>x.ToString（））；
int size=4；
对于（int i=0；ialphabet，（x，y）=>x+y）；
foreach（q中的var项目）
控制台写入线（项目）；
看一看也看一看这个问题我很惊讶，但是是的，这是有效的。我想到了类似的东西，但是如果我有可变数量的可能字母组合呢？我只是以3为例。可能需要4或更多5@RyanPeschel我知道这已经很老了，但你可以用LINQ来做公关对数组进行整型。
q.ForEach（x=>Console.WriteLine（x））；
@JasonHeddle IEnumerable没有ForEach扩展。然后，您需要做的就是在
.ForEach
之前添加
.ToArray（）
，例如：
q.ToArray（）.ForEach（Console.WriteLine）；
@JasonHeddle-
ForEach
方法特定于列表。此ForEach有什么问题？
// Eric Lippert’s Blog
// Computing a Cartesian Product with LINQ
// http://blogs.msdn.com/b/ericlippert/archive/2010/06/28/computing-a-cartesian-product-with-linq.aspx
public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
{
    // base case: 
    IEnumerable<IEnumerable<T>> result = new[] { Enumerable.Empty<T>() };
    foreach (var sequence in sequences)
    {
        var s = sequence; // don't close over the loop variable 
        // recursive case: use SelectMany to build the new product out of the old one 
        result =
            from seq in result
            from item in s
            select seq.Concat(new[] { item });
    }
    return result;
}

for(char first = 'a'; first <= (int)'z'; first++)
    for(char second = 'a'; second <= (int)'z'; second++)
        for(char third = 'a'; third <= (int)'z'; third++)
            Console.WriteLine(first.ToString() + second + third);

var alphabet = "abcdefghijklmnopqrstuvwxyz";
var q = alphabet.Select(x => x.ToString());
int size = 4;
for (int i = 0; i < size - 1; i++)
    q = q.SelectMany(x => alphabet, (x, y) => x + y);

foreach (var item in q)
    Console.WriteLine(item);