# Permutations of Selections

<< Previous Article

In the previous article on permutations, the special case of arrangements of all the “n” distinct items, was dealt with. Now, with that and the logic of combinations (different ways of selecting “k” items from “n” distinct items), we are all set for the general permutations of first selecting “k” items from “n” distinct items, and then arranging those “k” items (in different permutations or possible ways). In mathematical terms, it is denoted by nPk (read n P k), permutations of “k” items from “n” (distinct) items.

As mentioned in the previous article, the total number of such different permutations or arrangements possible can be readily computed using the following recursive relation and the terminating condition:
nPk = k * n-1Pk-1 + n-1Pk, n > k > 0 (recursive relation)
nPk = k * n-1Pk-1, n = k > 0 (recursive relation)
nPk = 1, for k = 0 (terminating condition)
Note that, the implicit condition on which nPk is defined is n >= k >= 0.

A straight away functional recursive implementation would look like this:

```permutations(n, k)
{
if (k == 0)
return 1;
else if (k == n)
return k * permutations(n - 1, k - 1);
else
return k * permutations(n - 1, k - 1) + permutations(n - 1, k);
}```

And now with the earlier two logics of printing (different possible selections of “k” items from “n” (distinct) items, and all different possible arrangements of “n” (distinct) items), it is just a matter of few tweaks to be able to invoke the above two logics to solve the general permutations printing logic.

Note that the general permutations is a two step process of first selecting “k” items from “n” distinct items, and then arranging those “k” items (in different permutations or possible ways). Hence, it can be implemented recursively, using a recursive logic similar to that of the selection logic, and then applying the arrangement logic, once selected.

Assuming the print_arrangements(n, basket[]) available from the previous article, and invoking & renaming the selections() logic from its previous article, we have the following:

```selections_arrangements(n, k, basket[], plen, prefix[])
{
if (k == 0)
{
print_arrangements(plen, prefix);
}
else if (k == n)
{
for (i = 1; i < k; i++)
{
}
print_arrangements(plen + k, prefix);
}
else
{
// Following two recursive calls of selections_arrangements
// have been swapped, compared to the original recursive calls
// of selections, to print them from left to right
selections_arrangements(n - 1, k - 1, basket + 1, plen+1, prefix);
selections_arrangements(n - 1, k, basket + 1, plen, prefix);
}
}```

Note the change to the invocation of print_arrangements() logic, instead of just the print() logic, in the cases of k == 0 and k == n, where the selecting of “k” items from “n” distinct items is already complete and now their arrangements need to be printed.

Moreover, as the cases k == 0 and k == n, take similar action, they can be further merged as follows:

```selections_arrangements(n, k, basket[], plen, prefix[])
{
if ((k == 0) || (k == n))
{
for (i = 1; i < k; i++)
{
}
print_arrangements(plen + k, prefix);
}
else
{
selections_arrangements(n - 1, k - 1, basket + 1, plen+1, prefix);
selections_arrangements(n - 1, k, basket + 1, plen, prefix);
}
}```

And again, as in the previous articles, to make the toplevel call look beautiful, a wrapper print_selections_arrangements() can be provided as follows:

```print_selections_arrangements(n, k, basket[])
{
plen = 0;
prefix[] = {}; // prefix being capable of supporting max "k" items

}
```

Next Article >>

Anil Kumar Pugalia (122 Posts)

The author is a hobbyist in open source hardware and software, with a passion for mathematics, and philosopher in thoughts. A gold medallist from the Indian Institute of Science, Linux, mathematics and knowledge sharing are few of his passions. He experiments with Linux and embedded systems to share his learnings through his weekend workshops. Learn more about him and his experiments at https://sysplay.in.

Send article as PDF

## 2 thoughts on “Permutations of Selections”

1. Pingback: Permutations | Playing with Systems