Algorithm::Combinatorics provides these subroutines:
permutations(\@data)
circular_permutations(\@data)
derangements(\@data)
complete_permutations(\@data)
variations(\@data, $k)
variations_with_repetition(\@data, $k)
tuples(\@data, $k)
tuples_with_repetition(\@data, $k)
combinations(\@data, $k)
combinations_with_repetition(\@data, $k)
partitions(\@data[, $k])
subsets(\@data[, $k])
All of them are context-sensitive:
• In scalar context subroutines return an iterator that responds to the next() method. Using this
object you can iterate over the sequence of tuples one by one this way:
my $iter = combinations(\@data, $k);
while (my $c = $iter->next) {
# ...
}
The next() method returns an arrayref to the next tuple, if any, or "undef" if the sequence is
exhausted.
Memory usage is minimal, no recursion and no stacks are involved.
• In list context subroutines slurp the entire set of tuples. This behaviour is offered for
convenience, but take into account that the resulting array may be really huge:
my @all_combinations = combinations(\@data, $k);
permutations(\@data)
The permutations of @data are all its reorderings. For example, the permutations of "@data = (1, 2, 3)"
are:
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
The number of permutations of "n" elements is:
n! = 1, if n = 0
n! = n*(n-1)*...*1, if n > 0
See some values at <http://www.research.att.com/~njas/sequences/A000142>.
circular_permutations(\@data)
The circular permutations of @data are its arrangements around a circle, where only relative order of
elements matter, rather than their actual position. Think possible arrangements of people around a
circular table for dinner according to whom they have to their right and left, no matter the actual chair
they sit on.
For example the circular permutations of "@data = (1, 2, 3, 4)" are:
(1, 2, 3, 4)
(1, 2, 4, 3)
(1, 3, 2, 4)
(1, 3, 4, 2)
(1, 4, 2, 3)
(1, 4, 3, 2)
The number of circular permutations of "n" elements is:
n! = 1, if 0 <= n <= 1
(n-1)! = (n-1)*(n-2)*...*1, if n > 1
See a few numbers in a comment of <http://www.research.att.com/~njas/sequences/A000142>.
derangements(\@data)
The derangements of @data are those reorderings that have no element in its original place. In jargon
those are the permutations of @data with no fixed points. For example, the derangements of "@data = (1,
2, 3)" are:
(2, 3, 1)
(3, 1, 2)
The number of derangements of "n" elements is:
d(n) = 1, if n = 0
d(n) = n*d(n-1) + (-1)**n, if n > 0
See some values at <http://www.research.att.com/~njas/sequences/A000166>.
complete_permutations(\@data)
This is an alias for "derangements", documented above.
variations(\@data,$k)
The variations of length $k of @data are all the tuples of length $k consisting of elements of @data. For
example, for "@data = (1, 2, 3)" and "$k = 2":
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)
For this to make sense, $k has to be less than or equal to the length of @data.
Note that
permutations(\@data);
is equivalent to
variations(\@data, scalar @data);
The number of variations of "n" elements taken in groups of "k" is:
v(n, k) = 1, if k = 0
v(n, k) = n*(n-1)*...*(n-k+1), if 0 < k <= n
variations_with_repetition(\@data,$k)
The variations with repetition of length $k of @data are all the tuples of length $k consisting of
elements of @data, including repetitions. For example, for "@data = (1, 2, 3)" and "$k = 2":
(1, 1)
(1, 2)
(1, 3)
(2, 1)
(2, 2)
(2, 3)
(3, 1)
(3, 2)
(3, 3)
Note that $k can be greater than the length of @data. For example, for "@data = (1, 2)" and "$k = 3":
(1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 2, 2)
(2, 1, 1)
(2, 1, 2)
(2, 2, 1)
(2, 2, 2)
The number of variations with repetition of "n" elements taken in groups of "k >= 0" is:
vr(n, k) = n**k
tuples(\@data,$k)
This is an alias for "variations", documented above.
tuples_with_repetition(\@data,$k)
This is an alias for "variations_with_repetition", documented above.
combinations(\@data,$k)
The combinations of length $k of @data are all the sets of size $k consisting of elements of @data. For
example, for "@data = (1, 2, 3, 4)" and "$k = 3":
(1, 2, 3)
(1, 2, 4)
(1, 3, 4)
(2, 3, 4)
For this to make sense, $k has to be less than or equal to the length of @data.
The number of combinations of "n" elements taken in groups of "0 <= k <= n" is:
n choose k = n!/(k!*(n-k)!)
combinations_with_repetition(\@data,$k);
The combinations of length $k of an array @data are all the bags of size $k consisting of elements of
@data, with repetitions. For example, for "@data = (1, 2, 3)" and "$k = 2":
(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)
Note that $k can be greater than the length of @data. For example, for "@data = (1, 2, 3)" and "$k = 4":
(1, 1, 1, 1)
(1, 1, 1, 2)
(1, 1, 1, 3)
(1, 1, 2, 2)
(1, 1, 2, 3)
(1, 1, 3, 3)
(1, 2, 2, 2)
(1, 2, 2, 3)
(1, 2, 3, 3)
(1, 3, 3, 3)
(2, 2, 2, 2)
(2, 2, 2, 3)
(2, 2, 3, 3)
(2, 3, 3, 3)
(3, 3, 3, 3)
The number of combinations with repetition of "n" elements taken in groups of "k >= 0" is:
n+k-1 over k = (n+k-1)!/(k!*(n-1)!)
partitions(\@data[,$k])
A partition of @data is a division of @data in separate pieces. Technically that's a set of subsets of
@data which are non-empty, disjoint, and whose union is @data. For example, the partitions of "@data =
(1, 2, 3)" are:
((1, 2, 3))
((1, 2), (3))
((1, 3), (2))
((1), (2, 3))
((1), (2), (3))
This subroutine returns in consequence tuples of tuples. The top-level tuple (an arrayref) represents the
partition itself, whose elements are tuples (arrayrefs) in turn, each one representing a subset of @data.
The number of partitions of a set of "n" elements are known as Bell numbers, and satisfy the recursion:
B(0) = 1
B(n+1) = (n over 0)B(0) + (n over 1)B(1) + ... + (n over n)B(n)
See some values at <http://www.research.att.com/~njas/sequences/A000110>.
If you pass the optional parameter $k, the subroutine generates only partitions of size $k. This uses an
specific algorithm for partitions of known size, which is more efficient than generating all partitions
and filtering them by size.
Note that in that case the subsets themselves may have several sizes, it is the number of elements ofthepartition which is $k. For instance if @data has 5 elements there are partitions of size 2 that consist
of a subset of size 2 and its complement of size 3; and partitions of size 2 that consist of a subset of
size 1 and its complement of size 4. In both cases the partitions have the same size, they have two
elements.
The number of partitions of size "k" of a set of "n" elements are known as Stirling numbers of the second
kind, and satisfy the recursion:
S(0, 0) = 1
S(n, 0) = 0 if n > 0
S(n, 1) = S(n, n) = 1
S(n, k) = S(n-1, k-1) + kS(n-1, k)
subsets(\@data[,$k])
This subroutine iterates over the subsets of data, which is assumed to represent a set. If you pass the
optional parameter $k the iteration runs over subsets of data of size $k.
The number of subsets of a set of "n" elements is
2**n
See some values at <http://www.research.att.com/~njas/sequences/A000079>.
Install Now
PNG Icons
