Генерация всех комбинаций произвольного алфавита до произвольной длины - PullRequest
7 голосов
/ 04 марта 2010

Скажем, у меня есть массив произвольного размера, содержащий отдельные символы. Я хочу вычислить все возможные комбинации этих символов до произвольной длины.

Допустим, мой массив [1, 2, 3]. Заданная пользователем длина равна 2. Тогда возможные комбинации: [11, 22, 33, 12, 13, 23, 21, 31, 32].

У меня реальная проблема с поиском подходящего алгоритма, который допускает произвольные длины, а не только переставляет массив. Да, и хотя скорость не является абсолютно критичной, она также должна быть достаточно высокой.

Ответы [ 7 ]

9 голосов
/ 04 марта 2010

Просто сделайте сложение с переносом.

Скажем, ваш массив содержал 4 символа, а вы хотите, чтобы они были длиной 3.

Начните с 000 (то есть каждый символ в вашем слове = алфавит [0])

Затем сложите:

000 001 002 003 010 011 ...

Алгоритм (с учетом этих индексов) состоит просто в увеличении наименьшего числа. Если он достигает количества символов в вашем алфавите, увеличьте предыдущее число (следуя тому же правилу) и установите значение тока равным 0.

C ++ код:

int N_LETTERS = 4;
char alphabet[] = {'a', 'b', 'c', 'd'};

std::vector<std::string> get_all_words(int length)
{
  std::vector<int> index(length, 0);
  std::vector<std::string> words;

  while(true)
  {
    std::string word(length);
    for (int i = 0; i < length; ++i)
      word[i] = alphabet[index[i]];
    words.push_back(word);

    for (int i = length-1; ; --i)
    { 
      if (i < 0) return words;
      index[i]++;
      if (index[i] == N_LETTERS)
        index[i] = 0;
      else
        break;
    }
  }
}

Код не проверен, но он должен помочь.

2 голосов
/ 04 марта 2010

Кнут подробно описывает комбинации и перестановки в Искусство компьютерного программирования , том 1. Вот реализация одного из его алгоритмов, которые я написал несколько лет назад (не ненавижу стиль,его древний код):

#include <algorithm>
#include <vector>
#include <functional>
#include <iostream>
using namespace std;

template<class BidirectionalIterator, class Function, class Size>
Function _permute(BidirectionalIterator first, BidirectionalIterator last, Size k, Function f, Size n, Size level)
{
    // This algorithm is adapted from Donald Knuth, 
    //      "The Art of Computer Programming, vol. 1, p. 45, Method 1"
    // Thanks, Donald.
    for( Size x = 0; x < (n-level); ++x )   // rotate every possible value in to this level's slot
    {
        if( (level+1) < k ) 
            // if not at max level, recurse down to twirl higher levels first
            f = _permute(first,last,k,f,n,level+1);
        else
        {
            // we are at highest level, this is a unique permutation
            BidirectionalIterator permEnd = first;
            advance(permEnd, k);
            f(first,permEnd);
        }
        // rotate next element in to this level's position & continue
        BidirectionalIterator rotbegin(first);
        advance(rotbegin,level);
        BidirectionalIterator rotmid(rotbegin);
        rotmid++;
        rotate(rotbegin,rotmid,last);
    }
    return f;
}

template<class BidirectionalIterator, class Function, class Size>
Function for_each_permutation(BidirectionalIterator first, BidirectionalIterator last, Size k, Function fn)
{
    return _permute<BidirectionalIterator,Function,Size>(first, last, k, fn, distance(first,last), 0);
}   





template<class Elem>
struct DumpPermutation : public std::binary_function<bool, Elem* , Elem*>
{
    bool operator()(Elem* begin, Elem* end) const
    {
        cout << "[";
        copy(begin, end, ostream_iterator<Elem>(cout, " "));
        cout << "]" << endl;
        return true;
    }
};

int main()
{

    int ary[] = {1, 2, 3};
    const size_t arySize = sizeof(ary)/sizeof(ary[0]);

    for_each_permutation(&ary[0], &ary[arySize], 2, DumpPermutation<int>());

    return 0;
}

Вывод этой программы:

[1 2 ]
[1 3 ]
[2 3 ]
[2 1 ]
[3 1 ]
[3 2 ]

Если вы хотите, чтобы ваши комбинации включали повторяющиеся элементы, такие как [11] [22] и [33],Вы можете сгенерировать свой список комбинаций, используя алгоритм, приведенный выше, а затем добавить к сгенерированному списку новые элементы, выполнив что-то вроде этого:

for( size_t i = 0; i < arySize; ++i )
{
    cout << "[";
    for( int j = 0; j < k; ++j )
        cout << ary[i] << " ";
    cout << "]" << endl;
}

... и вывод программы теперь станет:

[1 2 ]
[1 3 ]
[2 3 ]
[2 1 ]
[3 1 ]
[3 2 ]
[1 1 ]
[2 2 ]
[3 3 ]
2 голосов
/ 04 марта 2010

Один из способов сделать это - использовать простой счетчик, который вы внутренне интерпретируете как основание N, где N - количество элементов в массиве. Затем вы извлекаете каждую цифру из основного счетчика N и используете ее в качестве индекса в вашем массиве. Так что, если ваш массив [1,2] и заданная пользователем длина равна 2, у вас есть

Counter = 0, indexes are 0, 0
Counter = 1, indexes are 0, 1
Counter = 2, indexes are 1, 0
Counter = 3, indexes are 1, 1

Хитрость здесь будет в том, что вы будете преобразовывать код из базы в 10 в базу N, что не так уж сложно.

1 голос
/ 04 марта 2010

Если вы знаете длину перед рукой, все, что вам нужно, это немного для циклов. Скажем, для длины = 3:

for ( i = 0; i < N; i++ )
   for ( j = 0; j < N; j++ )
      for ( k = 0; k < N; k++ )
         you now have ( i, j, k ), or a_i, a_j, a_k

Теперь, чтобы обобщить это, просто сделайте это рекурсивно, каждый шаг рекурсии с одним из циклов for:

recurse( int[] a, int[] result, int index)
    if ( index == N ) base case, process result
    else
        for ( i = 0; i < N; i++ ) {
           result[index] = a[i]
           recurse( a, result, index + 1 )
        }

Конечно, если вы просто хотите получить все комбинации, вы можете просто думать о каждом шаге как о N, от 1 до k^N - 1, где k - длина.

По сути, вы получите в базе N (для k = 4):

0000 // take the first element four times
0001 // take the first element three times, then the second element
0002 
...
000(N-1) // take the first element three times, then take the N-th element
1000 // take the second element, then the first element three times
1001 
..
(N-1)(N-1)(N-1)(N-1) // take the last element four times
0 голосов
/ 17 марта 2013

Это написано мной.может быть полезным для тебя ...

#include<stdio.h>
#include <unistd.h>
void main()
{
FILE *file;
int i=0,f,l1,l2,l3=0;
char set[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890!@#$%&*.!@#$%^&*()";
int size=sizeof(set)-1;
char per[]="000";
//check urs all entered details here//
printf("Setlength=%d Comination are genrating\n",size);

// writing permutation here for length of 3//
for(l1=0;l1<size;l1++)
//first for loop which control left most char printed in file//
{ 
per[0]=set[l1];
// second for loop which control all intermediate char printed in file//
for(l2=0;l2<size;l2++)
{
per[1]=set[l2];
//third for loop which control right most char printed in file//
for(l3=0;l3<size;l3++)
{
per[2]=set[l3];
//apend file (add text to a file or create a file if it does not exist.//
file = fopen("file.txt","a+");
//writes array per to file named file.txt// 
fprintf(file,"%s\n",per); 
///Writing to file is completed//
fclose(file); 
i++;
printf("Genrating Combination  %d\r",i);
fflush(stdout);``
usleep(1);
}
}
}
printf("\n%d combination has been genrate out of entered data of length %d \n",i,size);
puts("No combination is left :) ");
puts("Press any butoon to exit");
getchar();
}
0 голосов
/ 02 октября 2012

Вот моя реализация в Haskell:

g :: [a] -> [[a]] -> [[a]]
g alphabet = concat . map (\xs -> [ xs ++ [s] | s <- alphabet])

allwords :: [a] -> [[a]]
allwords alphabet = concat $ iterate (g alphabet) [[]]

Загрузить этот скрипт в GHCi . Предположим, что мы хотим найти все строки, длина которых меньше или равна 2 в алфавите {'a', 'b', 'c'}. Следующая сессия GHCi делает это:

*Main> take 13 $ allwords ['a','b','c']
["","a","b","c","aa","ab","ac","ba","bb","bc","ca","cb","cc"]

Или, если вы хотите просто строки длиной, равной 2:

*Main> filter (\xs -> length xs == 2) $ take 13 $ allwords ['a','b','c']
["aa","ab","ac","ba","bb","bc","ca","cb","cc"]

Будьте осторожны с allwords ['a','b','c'], потому что это бесконечный список!

0 голосов
/ 19 июля 2011

Использование алгоритма Питера прекрасно работает; однако, если ваш набор букв слишком велик или размер строки слишком длинный, попытка поместить все перестановки в массив и вернуть массив не будет работать. Размер массива будет равен размеру алфавита, поднятого до длины строки.

Я создал это в perl для решения проблемы:

package Combiner;
#package used to grab all possible combinations of a set of letters. Gets one every call, allowing reduced memory usage and faster processing.
use strict;
use warnings;

#initiate to use nextWord
#arguments are an array reference for the list of letters and the number of characters to be in the generated strings.
sub new {
    my ($class, $phoneList,$length) = @_;
    my $self = bless {
        phoneList => $phoneList,
        length => $length,
        N_LETTERS => scalar @$phoneList,
    }, $class;
    $self->init;
    $self;
}

sub init {
    my ($self) = shift;
    $self->{lindex} = [(0) x $self->{length}];
    $self->{end} = 0;
    $self;
}

#returns all possible combinations of N phonemes, one at a time. 
sub nextWord {
    my $self = shift;
    return 0 if $self->{end} == 1;
    my $word = [('-') x $self->{length}];

    $$word[$_] = ${$self->{phoneList}}[${$self->{lindex}}[$_]]
        for(0..$self->{length}-1);

    #treat the string like addition; loop through 000, 001, 002, 010, 020, etc.
    for(my $i = $self->{length}-1;;$i--){
         if($i < 0){
            $self->{end} = 1;
            return $word;
         }
         ${$self->{lindex}}[$i]++;
         if (${$self->{lindex}}[$i] == $self->{N_LETTERS}){
            ${$self->{lindex}}[$i] = 0;
         }
         else{
            return $word;
         }
    }
}

Назовите это так: my $c = Combiner->new(['a','b','c','d'],20);. Затем позвоните nextWord, чтобы получить следующее слово; если nextWord возвращает 0, значит, это сделано.

...