Что такое хороший путь к выяснению всех возможных слов данной длины

Всегда существует обязательная реализация LINQ. Наиболее вероятная мусорная производительность, но с тех пор, когда производительность мешала использованию прохладных новых функций?

var letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();

var sequence = from one in letters
               from two in letters
               from three in letters
               from four in letters
               orderby one, two, three, four
               select new string(new[] { one, two, three, four });

'последовательность' теперь будет IQueryable, который содержит AAAA к ZZZZ.

Править:

Хорошо, таким образом, это прослушивало меня, что должно быть возможно сделать последовательность настраиваемой длины с настраиваемым алфавитом с помощью LINQ. Таким образом, здесь это. Снова, абсолютно бессмысленный, но это прослушивало меня.

public void Nonsense()
{
    var letters = new[]{"A","B","C","D","E","F",
                        "G","H","I","J","K","L",
                        "M","N","O","P","Q","R","S",
                        "T","U","V","W","X","Y","Z"};

    foreach (var val in Sequence(letters, 4))
        Console.WriteLine(val);
}

private IQueryable<string> Sequence(string[] alphabet, int size)
{
    // create the first level
    var sequence = alphabet.AsQueryable();

    // add each subsequent level
    for (var i = 1; i < size; i++)
        sequence = AddLevel(sequence, alphabet);

    return from value in sequence
           orderby value
           select value;
}

private IQueryable<string> AddLevel(IQueryable<string> current, string[] characters)
{
    return from one in current
           from character in characters
           select one + character;
}

Вызов к методу Последовательности производит тот же AAAA для списка ZZZZ как прежде, но теперь можно изменить используемый словарь и какой длины произведенные слова будут.

Просто комментарий Garry Shutler, но я хочу код, окрашивающий:

Вы действительно не должны делать это IQuaryable, ни один вид, таким образом, можно удалить второй метод. Один шаг forwad должен использовать Агрегат для векторного произведения, это заканчивается как это:

IEnumerable<string> letters = new[]{
                "A","B","C","D","E","F",                       
                "G","H","I","J","K","L",
                "M","N","O","P","Q","R","S",           
                "T","U","V","W","X","Y","Z"};

var result = Enumerable.Range(0, 4)
                .Aggregate(letters, (curr, i) => curr.SelectMany(s => letters, (s, c) => s + c));

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

Anders должен получить Нобелевскую премию за вещь Linq!

Bash GNU!

{a..z}{a..z}{a..z}{a..z}

Python!

(Это - только взлом,' не относитесь ко мне слишком серьезно :-)

# Convert a number to the base 26 using [A-Z] as the cyphers
def itoa26(n): 
   array = [] 
   while n: 
      lowestDigit = n % 26
      array.append(chr(lowestDigit + ord('A'))) 
      n /= 26 
   array.reverse() 
   return ''.join(array)

def generateSequences(nChars):
   for n in xrange(26**nChars):
      string = itoa26(n)
      yield 'A'*(nChars - len(string)) + string

for string in generateSequences(3):
   print string

Вдохновленный ответом Garry Shutler, я решил повторно кодировать его ответ в T-SQL.

Скажите, что "Буквы" являются таблицей только с одним полем, MyChar, CHAR (1). Это имеет 26 строк, каждый буква алфавита. Таким образом, мы имели бы (Вы можете вставка копии этот код SQL Server и работать как есть для наблюдения его в действии):

DECLARE @Letters TABLE (
    MyChar CHAR(1) PRIMARY KEY
)
DECLARE @N INT
SET @N=0
WHILE @N<26 BEGIN
    INSERT @Letters (MyChar) VALUES ( CHAR( @N + 65) )
    SET @N = @N + 1
END
-- SELECT * FROM @Letters ORDER BY 1

SELECT A.MyChar, B.MyChar, C.MyChar, D.MyChar
FROM @Letters A, Letters B, Letters C, Letters D
ORDER BY 1,2,3,4

Преимущества: это легко расширяемо в использование капитала, или использование неанглийских латинских символов (думайте "Ñ" или cedille, eszets и т.п.), и Вы все еще получили бы упорядоченное множество, только должен добавить сопоставление. Плюс SQL Server выполнит это немного быстрее, чем LINQ на одноядерной машине, на многоядерном (или многопроцессорные системы), выполнение может быть параллельно, получив еще больше повышения.

К сожалению, это застревает для 4 конкретных случаев букв. рекурсивное решение lassevk является более общим, пытаясь сделать, общее решение в T-SQL обязательно подразумевало бы динамический SQL со всеми своими опасностями.

Haskell!

replicateM 4 ['A'..'Z']

Ruby!

('A'*4..'Z'*4).to_a

Более простой Python!

def getWords(length=3):
    if length == 0: raise StopIteration
    for letter in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
        if length == 1: yield letter
        else:
            for partialWord in getWords(length-1):
                yield letter+partialWord

Это - рекурсивная версия тех же функций в C#:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ConsoleApplication1Test
{
    class Program
    {
        static char[] my_func( char[] my_chars, int level)
        {
            if (level > 1)
                my_func(my_chars, level - 1);
            my_chars[(my_chars.Length - level)]++;
            if (my_chars[(my_chars.Length - level)] == ('Z' + 1))
            {
                my_chars[(my_chars.Length - level)] = 'A';
                return my_chars;
            }
            else
            {
                Console.Out.WriteLine(my_chars);
                return my_func(my_chars, level);
            }
        }
        static void Main(string[] args)
        {
            char[] text = { 'A', 'A', 'A', 'A' };
            my_func(text,text.Length);
            Console.ReadKey();
        }
    }
}

Печать из AAAA к ZZZZ

JavaScript!

var chars = 4, abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ", top = 1, fact = [];
for (i = 0; i < chars; i++) { fact.unshift(top); top *= abc.length; }
for (i = 0; i < top; i++)
{
    for (j = 0; j < chars; j++) 
        document.write(abc[Math.floor(i/fact[j]) % abc.length]);
    document.write("<br \>\n");
}

Используйте что-то, что автоматически Гуглит для каждого сочетания букв, затем посмотрите, существует ли больше хитов ".sz" или ".af" затем ".com", нападает на пять первых результатов... ;)

Серьезно, то, что Вы ищете, могло бы быть Попытками (структура данных), хотя все еще необходимо заполнить вещь, которая, вероятно, намного более тверда...