Question

• I’ve edited original text to save potential readers some time and health. Maybe someone will actually use this.

I know it’s basic stuff. Probably like very, very basic.
How to get all possible combinations of given set.
E.g.
string set = “abc”;
I expect to get:
a b c aa ab ac aaa aab aac aba abb abc aca acb acc baa bab …
and the list goes on (if no limit for length is set).

I’m looking for a very clean code for that – all that I’ve found was kind of dirty and not working correctly. The same I can say about code I wrote.

I need such code because I’m writing brute force (md5) implementation working on multiple threads. The pattern is that there’s Parent process that feeds threads with chunks of their very own combinations, so they would work on these on their own.
Example: first thread gets package of 100 permutations, second gets next 100 etc.
Let me know if I should post the final program anywhere.

EDIT #2
Once again thank you guys.
Thanks to you I’ve finished my Slave/Master Brute-Force application implemented with MPICH2 (yep, can work under linux and windows across for example network) and since the day is almost over here, and I’ve already wasted a lot of time (and sun) I’ll proceed with my next task … 🙂
You shown me that StackOverflow community is awesome – thanks!

Answer 1

Here’s some C++ code that generates permutations of a power set up to a given length.

The function getPowPerms takes a set of characters (as a vector of strings) and a maximum length, and returns a vector of permuted strings:

#include <iostream>
using std::cout;
#include <string>
using std::string;
#include <vector>
using std::vector;

vector<string> getPowPerms( const vector<string>& set, unsigned length ) {
  if( length == 0 ) return vector<string>();
  if( length == 1 ) return set;

  vector<string> substrs = getPowPerms(set,length-1);
  vector<string> result = substrs;
  for( unsigned i = 0; i < substrs.size(); ++i ) {
    for( unsigned j = 0; j < set.size(); ++j ) {
      result.push_back( set[j] + substrs[i] );
    }
  }

  return result;
}

int main() {
  const int MAX_SIZE = 3;
  string str = "abc";

  vector<string> set;     // use vector for ease-of-access            
  for( unsigned i = 0; i < str.size(); ++i ) set.push_back( str.substr(i,1) );

  vector<string> perms = getPowPerms( set, MAX_SIZE );
  for( unsigned i = 0; i < perms.size(); ++i ) cout << perms[i] << '\n';
}

When run, this example prints

a b c aa ba ca ab bb cb ... acc bcc ccc

Update: I’m not sure if this is useful, but here is a “generator” function called next that creates the next item in the list given the current item.

Perhaps you could generate the first N items and send them somewhere, then generate the next N items and send them somewhere else.

string next( const string& cur, const string& set ) {
  string result = cur;
  bool carry = true;
  int loc = cur.size() - 1;
  char last = *set.rbegin(), first = *set.begin();
  while( loc >= 0 && carry ) {
    if( result[loc] != last ) {             // increment              
      int found = set.find(result[loc]); 
      if( found != string::npos && found < set.size()-1 ) {
        result[loc] = set.at(found+1); 
      }
      carry = false;
    } else {                                // reset and carry        
      result[loc] = first;
    }
    --loc;
  }
  if( carry ) {                             // overflow               
    result.insert( result.begin(), first );
  }
  return result;
}

int main() {
  string set = "abc";
  string cur = "a";
  for( int i = 0; i < 20; ++i ) {
    cout << cur << '\n';        // displays a b c aa ab ac ba bb bc ...
    cur = next( cur, set );
  }
}