C# 如何获取字母数组的所有可能模式

可能重复：

假设我有这些信

a、b、c、d

我想得到这些字母的每一个可能的模式/组合，在一个4个字母长的字符串中

aaaa

巴阿

民航局

达拉

阿巴

acaa

阿卡德

阿巴

等等

我可以使用什么循环或模式列出所有可能的组合

<>我在C语言中写这个，但是C++和JavaScript中的例子也是受欢迎的。 我目前的想法是每一个字母只能增加一个字母。然后向右移动一次并重复。这不包括像这样的图案

阿巴

---

这是一个只有一个for循环的

var one = ['a','b','c','d'];
var length = one.length;
var total = Math.pow(length, length);
var pow3 = Math.pow(length,3);
var pow2 = Math.pow(length,2);

for(var i = 0; i<total; i++)
    console.log(one[Math.floor(i/pow3)], 
        one[Math.floor(i/pow2)%length], 
        one[Math.floor(i/length)%length], 
        one[i%length]);

varone=['a'，'b'，'c'，'d']；
变量长度=1.5倍长度；
var total=数学功率（长度、长度）；
var pow3=数学功率（长度，3）；
var pow2=数学功率（长度，2）；
对于（var i=0；i我使用递归实现了这个javascript解决方案。无论如何，使用这些约束并不太昂贵（只有4^4个调用）

输出是

["aaaa", "aaab", "aaac", "aaad",...., "dddc", "dddd"]

这是一个针对javascript中任意数量字母的通用解决方案


有趣的是，google chrome希望翻译“马来语”的输出

var字母=['a'，'b'，'c'，'d']；
var letterCount=字母长度；
var迭代=Math.pow（字母计数，字母计数）；
对于（var i=0；i”）；
}
递归C#实现：

public IEnumerable<string> CreateCombinations(IEnumerable<char> input, int length)
{
    foreach (var c in input)
    {
        if (length == 1)
            yield return c.ToString();
        else 
        {
            foreach (var s in CreateCombinations(input, length - 1))
                yield return c.ToString() + s;
        }
    }
}

结果：

aaaa
aaab
aaac
aaad
aaba
aabb
aabc
aabd
aaca
...
dddd

一个简单、直接的javascript解决方案（根据口味搭配大括号）：

使用LINQ，您可以非常轻松地做到这一点：

string[] items = {"a", "b", "c", "d"};
var query = from i1 in items
            from i2 in items
            from i3 in items
            from i4 in items
            select i1 + i2 + i3 + i4;

foreach(var result in query)
    Console.WriteLine(result);

如果你事先不知道你想要四个的组合，你可以用更多的工作来计算任意的笛卡尔积：

使用递归、动作委托和Lambdas！！！（只是为了好玩）

使用系统；
使用System.Collections.Generic；
使用System.Linq；
命名空间控制台应用程序4
{
班级计划
{
静态void Main（字符串[]参数）
{
列表字母=新列表（）{a'，b'，c'，d'}；
列表单词=新列表（）；
Action recursiveLetter=null；
递归字母=（可用字母、单词、新词）=>
{
if（word.Length
recursiveLetter（可用者，
单词+字母，
新词）；
}
其他的
{
添加（单词）；
}
};
recursiveLetter（字母，字符串。空，单词）；//所有的魔术都开始了！
words.ForEach（word=>Console.WriteLine（word））；
Console.ReadKey（）；
}
}
}
C语言中的一个实现

#include <stdio.h>
#define WORD_LEN 5
#define ALPHA_LEN 4

char alphabet[ALPHA_LEN] = {'a', 'b', 'c', 'd'};
int w[WORD_LEN] = {};

void print_word() {
    int i;
    char s[WORD_LEN + 1];
    for(i = 0; i < WORD_LEN; i++) {
        s[i] = alphabet[w[i]];
    }
    s[WORD_LEN] = '\0';
    puts(s);
}

int increment_word() {
    int i;
    for(i = 0; i < WORD_LEN; i++) {
        if(w[i] < ALPHA_LEN - 1) {
            w[i]++;
            return 1;
        } else {
            w[i] = 0;
        }
    }
    return 0;
}

int main() {
    int i;
    do {
        print_word();
    } while (increment_word());
}

#包括
#定义单词_LEN 5
#定义ALPHA_LEN 4
字符字母[ALPHA_LEN]={'a'，'b'，'c'，'d'}；
int w[单词_LEN]={}；
无效打印字（）{
int i；
字符s[WORD_LEN+1]；
对于（i=0；i
这可能也会起作用；）

var-letters=new[]{'a'，'b'，'c'，'d'}；
随机=新随机（）；
HashSet results=新的HashSet（）；
而（results.Count<256）{
结果。添加（字母[random.Next（4）]+字母[random.Next（4）]
+字母[random.Next（4）]+字母[random.Next（4）]；
}
results.ToList（）.ForEach（Console.WriteLine）；
对于任何给定的n，LINQ中有一个衬里：

        var letters = new[] { "a", "b", "c", "d" };
        int n = 4;

        var z = Enumerable.Range(1, n)
            .Select(x => letters.AsEnumerable())
            .Aggregate((g,h) => g.Join(h, _ => true, _ => true, (a, b) => a + b));

另一个基于Linq的答案：

List<string> items = new List<string>() {"a", "b", "c", "d"};
items.ForEach(i1 => 
  items.ForEach(i2 =>
    items.ForEach(i3 =>
      items.ForEach(i4 =>
        Console.WriteLine(i1 + i2 + i3 + i4)
      )
    )
  )
);

List items=newlist（）{“a”、“b”、“c”、“d”}；
items.ForEach（i1=>
items.ForEach（i2=>
items.ForEach（i3=>
items.ForEach（i4=>
控制台写入线（i1+i2+i3+i4）
)
)
)
);
Haskell可能在这里有最短的程序：

sequence (replicate 4 "abcd")

复制4“abcd”
创建一个重复四次的列表
sequence
是一种非常通用、多态的moadic操作，有许多用途，其中之一就是生成列表的笛卡尔乘积

可以在C#或其他.NET语言中复制此解决方案。Eric Lippert的LINQ解决方案对应于此Haskell解决方案：

items = ["a", "b", "c", "d"]

query = do i1 <- items
           i2 <- items
           i3 <- items
           i4 <- items
           return (i1 ++ i2 ++ i3 ++ i4)

在LINQ术语中，
sequence
函数允许您将items

中的ix中重复的

语句替换为一个列表，从中选择每个项

编辑：一位朋友刚刚在这一行中击败了我（好吧，除了导入
之外还有一行）：

在Python中：

项目=[“a”、“b”、“c”、“d”]

打印[a+b+c+d]
对于项目中的
项目中的b
对于项目中的c
对于项目中的d，你有一个22个字母的字母表，因此每个字母正好表示两位，因此字母表示八位。现在只需列举所有值。在pCeudocode中：

static const char alphabet[4] = { 'a', 'b', 'c', 'd' };

for (unsigned int i = 0; i != 256; ++i)
{
    for (unsigned int k = 0; k != 4; ++k)
    {
        print(alphabet[(i >> (2*k)) % 4]);
    }
}

这里256=22×4，因此您可以轻松地推广此方案。
必须有一个erlang列表

差不多

Value = "abcd".
[ [A] ++ [B] ++ [C] ++ [D] || A <- Value, B <- Value, C <- Value, D <- Value ].

Value=“abcd”。
[[A]++[B]++[C]+[D]| | A总是4个字母吗？如果是这样，那就很简单了。@liho1eye发布两个for循环是没有意义的，因为这不是正确的解决方案
#include <stdio.h>
#define WORD_LEN 5
#define ALPHA_LEN 4

char alphabet[ALPHA_LEN] = {'a', 'b', 'c', 'd'};
int w[WORD_LEN] = {};

void print_word() {
    int i;
    char s[WORD_LEN + 1];
    for(i = 0; i < WORD_LEN; i++) {
        s[i] = alphabet[w[i]];
    }
    s[WORD_LEN] = '\0';
    puts(s);
}

int increment_word() {
    int i;
    for(i = 0; i < WORD_LEN; i++) {
        if(w[i] < ALPHA_LEN - 1) {
            w[i]++;
            return 1;
        } else {
            w[i] = 0;
        }
    }
    return 0;
}

int main() {
    int i;
    do {
        print_word();
    } while (increment_word());
}

var letters = new[] {'a','b','c','d'};
Random random = new Random();
HashSet<string> results = new HashSet<string>();

while(results.Count < 256) {
    results.Add(letters[random.Next(4)] + letters[random.Next(4)]
              + letters[random.Next(4)] + letters[random.Next(4)]);
}

results.ToList().ForEach(Console.WriteLine);

        var letters = new[] { "a", "b", "c", "d" };
        int n = 4;

        var z = Enumerable.Range(1, n)
            .Select(x => letters.AsEnumerable())
            .Aggregate((g,h) => g.Join(h, _ => true, _ => true, (a, b) => a + b));

List<string> items = new List<string>() {"a", "b", "c", "d"};
items.ForEach(i1 => 
  items.ForEach(i2 =>
    items.ForEach(i3 =>
      items.ForEach(i4 =>
        Console.WriteLine(i1 + i2 + i3 + i4)
      )
    )
  )
);

sequence (replicate 4 "abcd")

items = ["a", "b", "c", "d"]

query = do i1 <- items
           i2 <- items
           i3 <- items
           i4 <- items
           return (i1 ++ i2 ++ i3 ++ i4)

sequence' [] = return []
sequence' (m:ms) = do x <- m
                      xs <- sequence' ms
                      return (x:xs)

import Control.Monad

replicateM 4 "abcd"

static const char alphabet[4] = { 'a', 'b', 'c', 'd' };

for (unsigned int i = 0; i != 256; ++i)
{
    for (unsigned int k = 0; k != 4; ++k)
    {
        print(alphabet[(i >> (2*k)) % 4]);
    }
}

Value = "abcd".
[ [A] ++ [B] ++ [C] ++ [D] || A <- Value, B <- Value, C <- Value, D <- Value ].