Fast algorithm for generating

ascending compositions
arXiv:1903.10797v1 [math.CO] 26 Mar 2019

Mircea Merca
Constantin Istrati Technical College
Grivitei 91, 105600 Campina, Romania
mircea.merca@profinfo.edu.ro

Abstract
In this paper we give a fast algorithm to generate all partitions of a
positive integer n. Integer partitions may be encoded as either ascending
or descending compositions for the purposes of systematic generation. It
is known that the ascending composition generation algorithm is substan-
tially more efficient than its descending composition counterpart. Using
tree structures for storing the partitions of integers, we develop a new
ascending composition generation algorithm which is substantially more
efficient than the algorithms from the literature.

Keywords: algorithm, ascending composition, integer partition, genera-

tion.

MSC 2010: 05A17, 05C05, 05C85, 11P84

1 Introduction
Any positive integer n can be written as a sum of one or more positive inte-
gers λi , n = λ1 + λ2 + · · · + λk . If the order of integers λi does not matter,
this representation is known as an integer partition; otherwise, it is know as a
composition. When λ1 ≤ λ2 ≤ · · · ≤ λk , we have an ascending composition.
If λ1 ≥ λ2 ≥ · · · ≥ λk then we have a descending composition. We notice
that more often than not there appears the tendency of defining partitions as
descending composition and this is also the convention used in this paper. In
order to indicate that λ = [λ1 , λ2 , . . . , λk ] is a partition of n, we use the nota-
tion λ ` n introduced by G. E. Andrews [2]. The number of all partitions of a
positive integer n is denoted by p(n) (sequence A000041 in OEIS [8]).
The choice of the way in which the partitions are represented is crucial
for the efficiency of their generating algorithm. Kelleher [4, 5] approaches the
problem of generating partitions through ascending compositions and proves
that the algorithm AccelAsc is more efficient than any other previously known
algorithms for generating integer partitions.

1
 In this study we show that the tree structures presented by Lin [6] can be
used to efficiently generate ascending compositions in standard representation.
The idea of using tree structures to store all partitions of an integer is based
on the fact that two partitions of the same integers could have more common
parts. Lin [6] created the tree structures according to the following rule: the
root of the tree is labeled with (1, n), and (x0 , y 0 ) is a child of the node (x, y) if
and only if
n jyk o
x0 ∈ x, x + 1, . . . , ,y and y 0 = y − x0 .
2
If x0 = y then (x0 , y 0 ) = (y, 0) is a leaf node. It is obvious that any leaf node
has the form (x, 0), 0 < x ≤ n.

Figure 1: A partition tree of integer 6

1,6

1,5 2,4 3,3 6,0

1,4 2,3 5,0 2,2 4,0 3,0

1,3 2,2 4,0 3,0 2,0

1,2 3,0 2,0

1,1 2,0

1,0

Lin [6] proved that [x1 , x2 , . . . , xk ] with x1 ≤ x2 ≤ · · · ≤ xk is an ascending

composition of n if and only if (x0 , y0 ), (x1 , y1 ), . . . , (xk , yk ) is a path from the
root (x0 , y0 ) to a leaf (xk , yk ) and then, basing on this, it is shown that the
total number of nodes needed to store all the partitions of an integer is twice
the number of leaf nodes in its partition tree. Obviously, the number of leaf
nodes in partition tree of n is p(n), namely the number of the partitions of n.
It is well-known that any ordered tree can be converted into a binary tree by
changing the links between the nodes. Converting the tree for storing integer
partitions, we get a binary tree. Deleting then the root of this binary tree we
get a strict binary tree that stores all the partitions of an integer. Applying
these conversions to the tree from figure 1, we obtain the strict binary tree in
figure 2.
In order to generate the ascending compositions we use a depth-first traversal
of partition strict binary tree. When we reach a leaf node we list from the path

2
that connects the root node with the leaf node only the leaf node and the nodes
that are followed by the left child. For instance, (1, 5)(1, 4)(1, 3)(2, 2)(2, 0) is a
path that connects the root node (1, 5) to the leaf node (2, 0). From this path
node (1, 3) is deleted when listing because it is followed by the node (2, 2) which
is its right child. Keeping from every remained pair only the first value, we get
the ascending composition [1, 1, 2, 2].

Figure 2: A partition strict binary tree of integer 6

1,5

1,4 2,4

1,3 2,3 2,2 3,3

1,2 2,2 3,0 5,0 2,0 4,0 3,0 6,0

1,1 3,0 2,0 4,0

1,0 2,0

Considering, on the one hand, the way in which the partition tree of n was
created, and on the other hand, the rule according to which we can convert any
ordered tree into a binary tree, we can deduce the rule according to which we
can directly create the partition strict binary tree of n. The root of partition
strict binary tree of n is labeled with (1, n − 1), the node (xl , yl ) is the left child
of the node (x, y) if and only if
(
x, if 2x ≤ y,
xl = and yl = y − xl ,
y, otherwise

and the node (xr , yr ) is the right child of the node (x, y) if and only if
(
x + 1, if 2 + x ≤ y,
xr = and yr = x + y − xr .
x + y, otherwise

2 A special case of restricted integer partitions

The integer partitions in which the parts are at least as large as m represent
an example of partition with restrictions. We denote by p(n, m) the number of
partitions λ ` n in which the parts are at least as large as m.
A special case of partitions that have parts at least as large as m is the
partition λ ` n with the property λ1 ≥ t · λ2 , where t is a positive integer. We

3
consider that the partition [n] has this property and we denote the number of
these partitions by p(t) (n, m). For instance, p(2) (15, 3) = 7, namely 15 has seven
partitions with parts as least as large as 3 in which the first part is at least twice
the secondjpart:
k [15], [12, 3], [11, 4], [10, 5], [9, 3, 3], [8, 4, 3] and [6, 3, 3, 3].
n
When t+1 < m ≤ n, it is easily seen that p(t) (n, m) = 1.
j k
n
Theorem 2.1. Let n, m and t be positive integers so that m ≤ t+1 . Then

p(t) (n, m) = p(t) (n − m, m) + p(t) (n, m + 1) . (1)

Proof. If λ ` n is a partition in which the parts are at least as large as m and

λ1 ≥ t · λ2 , then the smallest part from λ is m or is at least as large as m + 1.
The number of partitions λ ` n with the smallest part m and λ1 ≥ t · λ2 is
p(t) (n − m, m). Considering that p(t) (n, m + 1) is the number of partitions λ ` n
where the smallest part is at least as large as m + 1 and λ1 ≥ t · λ2 , the theorem
is proved.
For instance,

p(2) (15, 3) = p(2) (12, 3) + p(2) (15, 4) = 4 + 3 = 7 .

The number 12 has four partitions with parts at least as large as 3 in which the
first part is twice the second part: [12], [9, 3], [8, 4] and [6, 3, 3]. The number 15
has three partitions with parts at least as large as 4 in which the first part is
twice the second part: [15], [11, 4] and [10, 5].
j k
n
Theorem 2.2. Let n, m and t be positive integers so that m ≤ t+1 . Then

bX
t+1 c
n

(t)
p (n, m) = 1 + p(t) (n − k, k) .
k=m

(t)
Proof. We expand  the
j term
k p  (n, m + 1) from the relation (1) and take into
(t) n
account that p n, t+1 + 1 = 1.

For example,

p(2) (15, 3) = 1 + p(2) (12, 3) + p(2) (11, 4) + p(2) (10, 5) = 1 + 4 + 1 + 1 = 7 .

The following theorem presents a recurrence relation that, applied consecu-

tively, allows us to write the numbers p(t) (n, m) in terms of p(n, m).
Theorem
j k 2.3. Let n, m and t be positive integers, so that n > t > 1 and
n
m ≤ t+1 . Then

p(t) (n, m) = p(t−1) (n, m) − p(t−1) (n − t, m) .

4
Proof. We are to prove the theorem by induction on n. For n = t + 1 we have
m = 1. Considering that p(t) (t + 1, 1) = 2, p(t−1) (1, 1) = 1 and

p(t−1) (t + 1, 1) = p(t−1) (t, 1) + p(t−1) (t + 1, 2) = 2 + 1 = 3 ,

the base case of induction is finished. We suppose that the relation

p(t) (n0 , m) = p(t−1) (n0 , m) − p(t−1) (n0 − t, m)

is true for any integer n0 , t < n0 < n. By Theorem 2.2 we can write
bn/(t+1)c  
X
p(t) (n, m) = 1+ p(t−1) (n − k, k) − p(t−1) (n − t − k, k)
k=m
bn/(t+1)c bn/(t+1)c
X X
= 1+ p(t−1) (n − k, k) − p(t−1) (n − t − k, k) ,
k=m k=m

and, on considering that

 
(t−1) n jnk
p (n − k, k) = 1 , for <k≤ ,
t+1 t

and    
(t−1) n n−t
p (n − t − k, k) = 1 , for <k≤ ,
t+1 t
we get
bn/tc b(n−t)/tc
X X
p(t) (n, m) = p(t−1) (n − k, k) − p(t−1) (n − t − k, k) .
k=m k=m

According to Theorem 2.2, the proof is finished.

For instance,

p(3) (15, 3) = p(2) (15, 3) − p(2) (12, 3) = 7 − 4 = 3 .

The number 15 has three partitions with parts at least as large as 3 in which
the first part is thrice the second part: [15], [12, 3] and [9, 3, 3].
The p(t) (n, m) numbers are then also a direct generalization of the terminal
compositions developed by Kelleher [4, section 5.4.1].
We denote by p(t) (n) the number of partitions λ ` n that have the property
λ1 ≥ t · λ2 . It is clear that p(t) (n) = p(t) (n, 1). We then immediately have the
following result.
Corollary 2.4. Let n and t be positive integers, so that n > t > 1. Then

p(t) (n) = p(t−1) (n) − p(t−1) (n − t) .

5
 The following two corollaries then follows easily from Corollary 2.4.
Corollary 2.5. Let n be a positive integer. Then, the number of partitions of
n, that have the first part at least twice larger than the second part is

p(2) (n) = p(n) − p(n − 2) .

For instance, p(2) (5) = p(5) − p(3) = 7 − 3 = 4, that means that number 5
has four partitions that have the first part at least twice larger than the second
part: [5], [4, 1], [3, 1, 1] and [2, 1, 1, 1]. The sequence p(2) (n) appears in OEIS [8]
as A027336. Corollary 2.5 is known and can be found in Kelleher [5, Corollary
4.1].

Corollary 2.6. Let n be a positive integer. Then, the number of partitions of

n, that have the first part at least thrice larger than the second part is

p(3) (n) = p(n) − p(n − 2) − p(n − 3) + p(n − 5) .

Proof. For n ∈ {1, 2, 3} the formula is immediately proved. For n > 3 we apply
Corollary 2.4 and Corollary 2.5.
For example, p(3) (5) = p(2) (5) − p(2) (2) = 4 − 1 = 3, which means that
number 5 has three partitions that have the first part at least thrice larger than
the second part: [5], [4, 1] and [3, 1, 1]. The sequence p(3) (n) appears in OEIS
[8] as A121659.
The next theorem allows us to deduce an upper bound for p(3) (n).
Theorem 2.7. Let n be a positive integer. Then

p(n) ≤ p(n − 1) + p(n − 2) − p(n − 5) .

Proof. (G. E. Andrews, Personal Communication) To prove the theorem we use

Euler’s formula [1]
∞
X zn 1
= ,
n=0
(q; q)n (z; q)∞
where
(A; q)n = (1 − A) (1 − Aq) · · · (1 − Aq n−1 ) .
We need to show that, except for the constant term, all the coefficients in

1 − q − q2 + q5
(q; q)∞

are non-positive.

6
 We have
1 − q − q2 + q5 (1 − q)(1 − q 2 ) − q 3 (1 − q 2 )
=
(q; q)∞ (q; q)∞
1 q3
= −
(q 3 ; q)∞ (1 − q) (q 3 ; q)∞
∞
X q 3n ∞
X q 3n+3
= −
n=0
(q; q)n n=0 (1 − q) (q; q)n
∞ ∞
X q 3n X q 3n (1 − q n )
= 1+ −
n=1
(q; q)n n=1 (1 − q) (q; q)n
∞
q 3n 1 − qn
X  
= 1+ 1−
n=1
(q; q)n 1−q
∞
X q 3n
−q − q 2 − · · · − q n−1


= 1+
n=2
(q; q)n

and clearly the coefficient of q 0 is 1, the coefficients of q k for 1 ≤ k ≤ 6 are all

0, and for k > 6 all the coefficients are negative.
We can then present the following corollary of Theorem 2.7.

Corollary 2.8. Let n be a positive integer. Then

p(3) (n) ≤ p(2) (n − 1) .

Proof. To prove this inequality we apply Corollary 2.4 and Theorem 2.8.

3 Traversal of partition tree

To generate all the integer partitions of n we can traverse in depth-first order
the partition tree. To do this we need efficient traversal algorithms. Gener-
ally, for inorder traversing a binary tree we can efficiently use a stack. Strict
binary trees are particular cases of binary trees and for their inorder traversal
we can use Algorithm 1, built as algorithm INORD12 presented by Livovschi
and Georgescu [7, pp. 66].
Analyzing Algorithm 1, we note that in the stack S there are pushed only
those nodes that are not leaf nodes in the strict binary tree for storing integer
partition of n. As this strict binary tree has 2p(n) − 1 nodes, we deduce that
algorithm 1 executes p(n) − 1 operations of pushing in the stack S (line 6) and
the same number of operations of popping from the stack S (line 11). The leaf
nodes are visited in the line 9, and the inner nodes are visited in the line 12.
Thus, we deduce that the total number of iterations of the internal while loop
from the lines 4-17 is p(n).

7
Algorithm 1 Inorder traversal of strict binary tree
Require: root
1: initialize an empty stack S
2: v ← root
3: c ← true
4: while c do
5: while node v has left child do
6: push node v onto stack S
7: v ← left child of node v
8: end while
9: visit v
10: if stack S is not empty then
11: pop node v from stack S
12: visit v
13: v ← right child of node v
14: else
15: c ← false
16: end if
17: end while

Strict binary trees for storing integer partitions are special cases of strict
binary trees, while Algorithm 1 is a general algorithm for inorder traversal of
the strict binary trees. Adapting Algorithm 1 to the special case of partition
strict binary trees leads to more efficient algorithms for inorder traversal of these
trees. Next we are to show how these algorithms can be obtained.
Let (x, y) be a node from partition strict binary tree, so that 2x ≤ y. If
(xl , yl ) is the left child of the node (x, y) and has the property 2xl > yl then,
(xl , yl ) is the root of a strict binary subtree with exactly three nodes: (x, y − x),
(y − x, 0) and (y, 0). If (xr , yr ) is the right child of the node (x, y) and has the
property 2xr > yr then (xr , yr ) is the root of a strict binary subtree where all
the left descendents are leaf nodes. This note allows us to inorder traverse the
partition strict binary tree by the help of a stack in which we push only those
nodes (x, y) that have the property 2x ≤ y. In this way, we get the Algorithm
2 for inorder traversal of the partition strict binary tree of n.
The number of the inner nodes that have the form (x, y) with the property
2x ≤ y is equal to the number of the partition of n that have at least two parts
where the first part is at least twice larger than the second part. Algorithm 2
executes p(2) (n) − 1 operations of pushing in the stack S (line 6) and as many
operations of popping from the stack S (line 15). Any inner nodes that has the
form (x, y) with the property 2x > y has only a left child which is leaf node. A
leaf node that has a left child is always visited in the line 10 and, by the help of
Corollary 2.5, we deduce that the number of these nodes is p(n − 2). A leaf node
that is a right child is visited in the line 13. It results that the total number of
iterations of the internal while loop from the lines 4-21 is p(2) (n).

8
Algorithm 2 Inorder traversal of partition strict binary tree - version 1
Require: n
1: initialize an empty stack S
2: (x, y) ← (1, n − 1)
3: c ← true
4: while c do
5: while 2x ≤ y do
6: push node (x, y) onto stack S
7: (x, y) ← left child of node (x, y)
8: end while
9: while x ≤ y do
10: visit (y, 0), (x, y)
11: (x, y) ← right child of node (x, y)
12: end while
13: visit (x + y, 0)
14: if stack S is not empty then
15: pop node (x, y) from stack S
16: visit (x, y)
17: (x, y) ← right child of node (x, y)
18: else
19: c ← false
20: end if
21: end while

Thus, the reducing of the number of operations executed upon the stack
allows to get a more efficient algorithm for traversing the partition strict binary
tree. But the number of operations executed upon the stack could be reduced
even more.
Let (x, y) be a node from the partition strict binary tree, so that 3x ≤ y. If
(xl , yl ) is the left child of the node (x, y) and has the property 3xl > yl , then
2xl ≤ yl and (xl , yl ) is the root of a strict binary tree in which the left subtree is
a strict binary tree in which all the left children are leaf nodes. This note allows
us to modify Algorithm 2 in order to get a new algorithm for inorder traversing
the partition strict binary trees. Thus, in Algorithm 3 we push in the stack S
only those inner nodes (x, y) that have the property 3x ≤ y.
The number of the nodes (x, y) with the property 3x ≤ y from the partition
strict binary tree of positive integer n is equal to the number of partitions of
n that have at least two parts where the first one is at least three times larger
than the second one. In this way, Algorithm 3 executes p(3) (n) − 1 operations
of pushing in the stack S (line 6) and as many operations of popping from the
stack S (line 25). In other words, the lines 6-7 are executed p(3) (n) − 1 times, in
the same way as the lines 25-27. The total number of iterations of the internal
while loop from the lines 9-18 is p(2) (n) − p(3) (n), namely p(2) (n − 3). The leaf
nodes that are right children are visited in the lines 16 and 23. The number
of these nodes is p(2) (n). Considering that the line 16 is executed p(2) (n − 3)

9
times, we deduce that the total number of iterations of the internal while loop
from the lines 4-31 is p(3) (n).

Algorithm 3 Inorder traversal of partition strict binary tree - version 2

Require: n
1: initialize an empty stack S
2: (x, y) ← (1, n − 1)
3: c ← true
4: while c do
5: while 3x ≤ y do
6: push node (x, y) onto stack S
7: (x, y) ← left child of node (x, y)
8: end while
9: while 2x ≤ y do
10: visit (y − x, 0), (x, y − x)
11: (p, q) ← right child of node (x, y − x)
12: while p ≤ q do
13: visit (q, 0), (p, q)
14: (p, q) ← right child of node (p, q)
15: end while
16: visit (p + q, 0), (x, y)
17: (x, y) ← right child of node (x, y)
18: end while
19: while x ≤ y do
20: visit (y, 0), (x, y)
21: (x, y) ← right child of node (x, y)
22: end while
23: visit (x + y, 0)
24: if stack S is not empty then
25: pop node (x, y) from stack S
26: visit (x, y)
27: (x, y) ← right child of node (x, y)
28: else
29: c ← false
30: end if
31: end while

4 Algorithms for generating ascending compo-

sitions
We showed above how we can use a stack for an efficient traversal of partition
strict binary trees. In Algorithm 1, when visiting a node, the stack contains a
part from the nodes that are on the path which connects that node to the root.
Which are the nodes stored in the stack? A node is in a stack when another

10
node is visited if and only if the visited node is the left child of the node from
the stack. Taking into account the fact that partition strict binary trees have
been obtained by converting partition trees, it is clear that, when visiting a leaf
node, the content of the stack together with the leaf node represents a partition.

Algorithm 4 Generating ascending compositions - version 1

Require: n
1: k ← 0
2: x ← 1
3: y ← n − 1
4: c ← true
5: while c do
6: while 2x ≤ y do
7: k ←k+1
8: ak ← x
9: y ←y−x
10: end while
11: while x ≤ y do
12: k ←k+1
13: ak ← x
14: k ←k+1
15: ak ← y
16: visit a1 , a2 , . . . , ak
17: k ←k−2
18: x←x+1
19: y ←y−1
20: end while
21: k ←k+1
22: ak ← x + y
23: visit a1 , a2 , . . . , ak
24: k ←k−1
25: if k > 0 then
26: y ←x+y
27: x ← ak
28: k ←k−1
29: x←x+1
30: y ←y−1
31: else
32: c ← false
33: end if
34: end while

To get an efficient algorithm for generating ascending compositions, we can

replace the stack from Algorithm 2 with an array that has nonnegative integer
components (a1 , a2 , . . . , ak ), where a1 represents the bottom of the stack and

11
ak represents the top of the stack. If we give up visiting the inner nodes from
Algorithm 2 and the visit of a leaf node is preceded by the visit of the array
(a1 , a2 , . . . , ak ) we get Algorithm 4 for generating ascending compositions in
lexicographic order.
Algorithm 4 is presented in a form that allows fast identification both of the
correlation between the operations executed in the stack S and the operations
executed with the array (a1 , a2 , . . . , ak ), and the movement operations in the
tree. Thus, the lines 7-9 are responsible with the pushing of the nodes in the
stack and the movement in the left subtree. The extraction of the nodes of the
stack is realized in the lines 26-28, and the movement in the right subtree is
realized in the lines 18-19 and 29-30. A slightly optimized version of Algorithm
4 is presented in Algorithm 5.

Algorithm 5 Generating ascending compositions - version 2

Require: n
1: k ← 1
2: x ← 1
3: y ← n − 1
4: while k > 0 do
5: while 2x ≤ y do
6: ak ← x
7: y ←y−x
8: k ←k+1
9: end while
10: t←k+1
11: while x ≤ y do
12: ak ← x
13: at ← y
14: visit a1 , a2 , . . . , at
15: x←x+1
16: y ←y−1
17: end while
18: y ←x+y−1
19: ak ← y + 1
20: visit a1 , a2 , . . . , ak
21: k ←k−1
22: x ← ak + 1
23: end while

We note that Algorithm 5 was rewritten without using the if statement and
the boolean variable c. It is obvious that the statements from the first branch of
the if statement could not be eliminated, but they were rearranged around the
visit statement (line 20). This was possible because the initializing statement of
the variable k was changed. As Algorithm 5 executes less assignment statements
and does not contain the if statement, the time required to execute Algorithm

12
5 is less than the time required to execute Algorithm 4.
Comparing the algorithm AccelAsc described and analyzed by Kelleher
[4, 5] with Algorithm 5, we note that Algorithm 5 is a slightly modified version
of the algorithm AccelAsc. In fact we have two presentations of the same
algorithm. The differences are determined by the different methods of getting
them.
The notes made upon the number of operations executed in Algorithm 2
allow us to determine how many times the assignment statement are executed
and how many times the boolean expressions are evaluated in Algorithm 5.
Theorem 4.1. Algorithm 5 executes 4p(n) + 4p(2) (n) assignment statements
and evaluates p(n) + 3p(2) (n) boolean expressions.
Proof. The total number of iterations of the internal while loop from the lines
4-23 is p(2) (n), and the while loop contains 5 assignment statements. The total
number of iterations of the internal while loop from the lines 5-9 is p(2) (n) − 1,
and the while loop contains 3 assignment statements. The total number of
iterations of the internal while loop from the lines 11-17 is p(n − 2), and the
while loop contains 4 assignment statements. Taking into account the first 3
assignment statements from the algorithm, we get the relation with which we
determine the number of executions of assignment statements: 8p(2) (n)+4p(n−
2). The boolean expression from the line 4 is evaluated p(2) (n) + 1 times, the
boolean expression from the line 5 is evaluated p(2) (n) + p(2) (n) − 1 times, and
the boolean expression from the line 11 is evaluated p(2) (n) + p(n − 2) times.
Thus, it results that the boolean expressions from the algorithm are evaluated
4p(2) (n) + p(n − 2) times. According to Corollary 2.5, the proof is finished.
If in Algorithm 3 we execute the conversions made in Algorithm 2, we get
Algorithm 6 for generating ascending composition in lexicographic order.

Algorithm 6 Generating ascending compositions - version 3

Require: n
1: k ← 1
2: x ← 1
3: y ← n − 1
4: while k > 0 do
5: while 3x ≤ y do
6: ak ← x
7: y ←y−x
8: k ←k+1
9: end while
10: t←k+1
11: u←k+2
12: while 2x ≤ y do
13: ak ← x
14: at ← x
15: au ← y − x

13
16: visit a1 , a2 , . . . , au
17: p←x+1
18: q ←y−p
19: while p ≤ q do
20: at ← p
21: au ← q
22: visit a1 , a2 , . . . , au
23: p←p+1
24: q ←q−1
25: end while
26: at ← y
27: visit a1 , a2 , . . . , at
28: x←x+1
29: y ←y−1
30: end while
31: while x ≤ y do
32: ak ← x
33: at ← y
34: visit a1 , a2 , . . . , at
35: x←x+1
36: y ←y−1
37: end while
38: y ←x+y−1
39: ak ← y + 1
40: visit a1 , a2 , . . . , ak
41: k ←k−1
42: x ← ak + 1
43: end while

The notes made upon the number of operations executed in Algorithm 3

allow us to determine how many times the assignment statements are executed
and how many times the boolean expressions are evaluated in Algorithm 6.
Theorem 4.2. Algorithm 6 executes 4p(n) + 5p(3) (n) assignment statements
and evaluates p(n) + 4p(3) (n) boolean expressions.
Proof. The total number of iterations of the internal while loop from the lines
4-43 is p(3) (n), and the while loop contains 6 assignment statements. The total
number of iterations of the internal while loop from the lines 5-9 is p(3) (n) − 1,
and the while loop contains 3 assignment statements. The total number of
iterations of the internal while loop from the lines 12-30 is p(2) (n) − p(3) (n),
and the while loop contains 8 assignment statements. The total number of

while loops from the lines 19-25 and 31-37 are p(n −
iterations of the internal
2) − p(2) (n) − p(3) (n) , and each of them contains 4 assignment statements.
Taking into account the first 3 assignment statements from the algorithm, we
get the relation with which we determine the number of executions of assignment

14
statements: 5p(3) (n) + 4p(2) (n) + 4p(n − 2). The boolean expression from the
line 4 is evaluated p(3) (n) + 1 times, the boolean expression from the line 5 is
evaluated p(3) (n) + p(3) (n) − 1 times, the boolean expression from the line 12 is
evaluated p(2) (n) times, and the boolean expressions from the lines 19 and 31
are evaluated p(3) (n) + p(n − 2). It results that the boolean expressions from
the algorithm are evaluated 4p(3) (n) + p(2) (n) + p(n − 2) times. By Corollary
2.5 and Corollary 2.6 the proof is finished.
Theorem 4.3. Algorithm 6 is more efficient than Algorithm 5.
Proof. According to Theorem 4.1 and Theorem 4.2, it is sufficient to show that

4p(3) (n) ≤ 3p(2) (n) .

By Corollary 2.4, we can rewrite this inequality as p(2) (n) ≤ 4p(2) (n − 3). Using
Corollary 2.4 and Corollary 2.8, we obtain

p(2) (n) ≤ 2p(2) (n − 3) + p(2) (n − 4) + p(2) (n − 5) .

Taking into account p(2) (n − 1) ≤ p(2) (n), the theorem is proved.

5 Experimental results and conclusions

We denote by r1 (n) the ratio of the number of assignment statements executed
by Algorithm 6 and the number of assignment statements executed by Algorithm
5,
p(n) + 1.25 · p(3) (n)
r1 (n) = ,
p(n) + p(2) (n)
and by r2 (n) the ratio of the number of boolean expressions evaluated by Algo-
rithm 6 and the number of boolean expressions evaluated by Algorithm 5,

p(n) + 4p(3) (n)

r2 (n) = .
p(n) + 3p(2) (n)

We can see the evolution of the ratios r1 (n) and r2 (n), for 1 < n ≤ 1500.
The graph is realized in Maple [3] and allows to note that the best performances
of Algorithm 6 compared to Algorithm 5 appears for 50 ≤ n ≤ 150.
Now let us measure CPU time for few values of n. To do this we encode the
algorithms in C++ and the programs obtained with Visual C++ 2010 Express
Edition will be run on three computers in similar conditions. The processor of
the first computer is Intel Pentium Dual T3200 2.00 GHz, the processor of the
second computer is Intel Celeron M 520 1.60GHz, and the the processor of third
one is Intel Atom N270 1.60GHZ.
CPU time is measured when the program runs without printing out ascend-
ing compositions. We denote by t1 (n) the average time for Algorithm 6 obtained

15
Figure 3: Evolution of performances of Algorithm 6 compared to Algorithm 5

after ten measurements, by t2 (n) the average time for Algorithm 5 obtained after
ten measurements, and by r(n) the ratio of t1 (n) and t2 (n),
t1 (n)
r(n) = .
t2 (n)
In Table 1 we present the results obtained after the measurements made and
also the ratios r1 (n) and r2 (n).

Table 1: Experimental results on few Intel CPU

Theoretical Experimental r(n)
n r1 (n) r2 (n) Pentium Dual Intel Celeron Intel Atom
20 0.89556 0.82113 0.82257 0.78651 0.93977
30 0.88738 0.79381 0.74365 0.75669 0.92693
40 0.88467 0.77992 0.74621 0.75323 0.93712
50 0.88403 0.77197 0.74905 0.76713 0.83457
60 0.88438 0.76731 0.76146 0.76397 0.89760
70 0.88525 0.76465 0.76036 0.76893 0.89812
80 0.88639 0.76326 0.75739 0.77172 0.90994
90 0.88766 0.76271 0.75549 0.77064 0.88617
100 0.88901 0.76274 0.75464 0.76323 0.89064
110 0.89037 0.76319 0.75352 0.77381 0.88936
120 0.89174 0.76392 0.75358 0.77326 0.89617
130 0.89308 0.76485 0.75445 0.77012 0.89004

Analyzing the data presented in Table 1, we realize that the ratio r2 (n) is

16
a good approximation of the ratio r(n), obtained experimentally on computers
with Intel Pentium Dual or Intel Celeron processors. We note that the ratio
r(n) obtained on the computer with Intel Atom processors is well approximated
by the ratio r1 (n).
Algorithm 6 is the fastest algorithm for generating ascending compositions
in lexicographic order in standard representation and can be considered an ac-
celerated version of the algorithm AccelAsc that Kelleher [4, 5] presented.

Acknowledgements. The author is greatly indebted to Professor George E.

Andrews from the Department of Mathematics of The Pennsylvania State Uni-
versity who offered us the proof for Theorem 4 in a private context. The author
would like to express his gratitude for the careful reading and helpful remarks to
Oana Merca, which have resulted in what is hopefully a clearer paper. Moreover,
the author wishes to thank the referee for his/her useful suggestions.

References
[1] G. E. Andrews, Enumerative proofs of certain q-identities, Glasgow Math.
J. 8(1), 33-40, (1967)

[2] G. E. Andrews, The Theory of Partitions, Addison-Wesley Publishing,

(1976).
[3] F. Garvan, The Maple Book, Chapman & Hall/CRC, Boca Raton, Florida,
(2001).

[4] J. Kelleher, Encoding Partitions as Ascending Compositions, PhD thesis,

University College Cork, (2006).
[5] J. Kelleher, and B. O’Sullivan, Generating All Partitions: A Comparison
Of Two Encodings, Published electronically at arXiv:0909.2331, (2009).

[6] R. B. Lin, Efficient Data Structures for Storing the Partitions of Integers,
The 22nd Workshop on Combinatorics and Computation Theory. Taiwan,
(2005).
[7] L. Livovschi, and H. Georgescu, Sinteza şi analiza algoritmilor. Editura
Ştiinţifică şi Enciclopedică, Bucureşti, (1986)

[8] N. J. A. Sloane, The On-Line Encyclopedia of Integer Sequences. Published

electronically at http://oeis.org, (2011).

17