Why does next_permutation skip some permutations? - c++

Question

Why doesn't this simple function output all permutations of the inputted 5 letter string? I think there should be 120 and it only outputs 90.
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
// Creates permutation lists for strings
vector<string> createdcombos2(string letters)
{
vector<string> lettercombos;
cout << "Letters are: " << letters << endl; //input string
do
lettercombos.push_back(letters);
while(next_permutation(letters.begin(), letters.end()));
cout <<"Letter combos: " << endl; //print out permutations
for (auto i : lettercombos)
cout << i << endl;
cout << endl << lettercombos.size() << endl; //number of permutations
return lettercombos;
}
int main()
{
string letters = "gnary";
vector<string> lettercombos;
lettercombos = createdcombos2(letters);
}

Answer 1

To return all permutations in a loop until next_permutation returns false, the vector must be sorted before the start of the loop. next_permutation returns the permutations in ascending order. So if you start off with an unsorted vector, it will begin part way through the series of permutations.
std::sort(letters.begin(), letters.end());
do
lettercombos.push_back(letters);
while(next_permutation(letters.begin(), letters.end()));

Answer 2

You need to sort the input, next_permutation will return the next permutation in lexicographical order. Because the input permutation: "gnary" is lexicographically "larger" than a permutation such as "angry", those "smaller" permutations will never be reached.
You can sort the string using std::sort()

Answer 3

As some of the previously made answers state, if you want to use the bool return value of std::next_permutation to stop the iterations, you have to make sure that you start from a "sorted" permutation. Otherwise, your cycle will terminate prematurely.
This is not absolutely necessary though.
Permutations enumerated through std::next_permutation form a cyclic sequence without a beginning or an end, which means that you can call std::next_permutation indefinitely and it will cycle through the same sequence of 120 permutations again, again and again. This means that you can start from absolutely any permutation in that cycle. You just have to remember your starting permutation and watch for the moment this permutation appears again. The very moment you arrive at your original permutation the iteration is over. In your case it will expectedly take 120 calls to std::next_permutation.
For example, the following code prints all 5-letter permutations for "abcde" set even though it starts from a completely arbitrary one
std::string start = "cadeb", current = start;
do
std::cout << current << std::endl;
while (std::next_permutation(current.begin(), current.end()), current != start);
One can note though that comparing permutations at each iteration of the cycle is more expensive than using the return value of std::next_permutation (which comes "for free" from the innards of the algorithm), so if you are happy with the solution that pre-sorts the starting permutation, then it is indeed a more efficient way to do it.
Alternatively, if you know the exact number of permutations in the cycle (120 in this case), you can simply call std::next_permutation exactly that number of times (as suggested in #Potatoswatter's answer).

Answer 4

The return bool value of next_permutation is like an overflow condition or a carry bit. It's false when it advances from the last permutation back to the first, in lexicographical order. But it still does advance, unconditionally.
If you know there are exactly 120 permutations, you can ignore the return value and just loop blindly:
for ( int i = 0; i != 120; ++ i ) {
lettercombos.push_back(letters);
next_permutation(letters.begin(), letters.end());
}