Question

Consider number 194 declared as type int
Is it possible to obtain it’s digits permutations like other ints efficiently?
Number: 194
419 int
491 int
914 int
941 int

I am using the next_permutation however it only works with arrays. So I thought it wouldn’t be wise to convert int to an int array (?!) then obtain the permutation as an array and convert it to it.

Any suggestions?

Answer 1

Permuting the digits is basically a string-operation, not a (simple) mathematical operation. Converting to an array (string) and then using next_permutation() sounds more sensible than trying to do it mathematically.

Here’s the mathematical version – without intermediate values saved:

int a = 194;
int b = (a / 100)       * 100 + (a % 10)        * 10 + ((a / 10) % 10) * 1; // 149
int c = (a % 10)        * 100 + ((a / 10) % 10) * 10 + (a / 100)       * 1; // 491
int d = (a % 10)        * 100 + (a / 100)       * 10 + ((a / 10) % 10) * 1; // 419
int e = ((a / 10) % 10) * 100 + (a / 100)       * 10 + (a % 10)        * 1; // 914
int f = ((a / 10) % 10) * 100 + (a % 10)        * 10 + (a / 100)       * 1; // 941

With intermediate values, it’s a little easier to see what’s going on (except that I generated different assignments for b through f this time).

int a = 194;
int d1 = a / 100;
int d2 = (a / 10) % 10;
int d3 = a % 10;

int a = d1 * 100 + d2 * 10 + d3 * 1; // 194
int b = d1 * 100 + d3 * 10 + d2 * 1; // 149
int c = d2 * 100 + d1 * 10 + d3 * 1; // 914
int d = d2 * 100 + d3 * 10 + d1 * 1; // 941
int e = d3 * 100 + d1 * 10 + d2 * 1; // 419
int f = d3 * 100 + d2 * 10 + d1 * 1; // 491

Use the next_permutation() mechanism; it will generalize to 4-digit and 5-digit and N-digit numbers where this will not.