Permutations / Combinations using ABAP

[Former Member]

I had written a code in SCN Discussion started by kiran.premlal to calculate all possible permutations.

The code in this document has certain improvements like:

1. Choose permutation or combination using radio-button
2. Separation of data from logic
3. Minimum and maximum set size can be specified

Why was data separated from logic?

Let us look at some example sets.

SET 1		SET 2		SET 3
54		apple		1
23		orange		2
101		banana		3

As we can see, sets can be of integers, strings, mixed data types and data can be unsorted.

However, for calculation of output, all we need is a set of indexes.

For index combination {2,3}, subset of SET 1 would be {23, 101}, whereas subset of SET 2 would be {orange, banana}

The code first calculates a list of index combinations, which can then be used to build data sets.

Example Explanation

We look at SET 2 and see how output is being calculated.

INDEX	DATA
1	apple
2	orange
3	banana

Permutation of all pairs

We have 2 slots to fill, and first element can reserve a slot for starters.

Data sets are {apple, orange} and {apple, banana}.

Index set equivalents would be {1, 2} and {1, 3}.

Program would calculate index sets as:

1	2
1	3
2	1
2	3
3	1
3	2

When these indexes are replaced by their data equivalents, result would be:

apple	orange
apple	banana
orange	apple
orange	banana
banana	apple
banana	orange

Combinations of all singles and pairs

Keeping above SET 2 as input data, we see how output is calculated.

For calculating singles and pairs, we have minimum set size = 1 and maximum set size = 2.

We first find all sets of size 1, and of size 2.

Output in index as well data form would be:

1			apple
2			orange
3			banana
1	2		apple	orange
1	3		apple	banana
2	3		orange	banana

For same input data, 6 permutation of pairs was calculated, whereas only 3 combination of pairs.

Screenshots from program

The dataset in program is build using characters starting from 'B'.

For dataset of size 3, program would build internal table of characters B, C and D.

INDEX	DATA
1	B
2	C
3	D

We specify in program selection the size of dataset, max/min size of set, and option to find permutation or combination.

Program would store resulting sets in internal table GT_SETS, whose record is capable of storing table of integers.

Although this program prints the resulting sets, minor changes can be done to return the results to another routine.

Code Snippet

1. TYPES: tty TYPE TABLE OF i.
3. * store superset
4. DATA gt_superset_index TYPE TABLE OF i.
5. DATA gt_superset_data TYPE TABLE OF c.
6. * temporarily store set
7. DATA gt_set TYPE TABLE OF i.
8. * gt_sets to store list of sets
9. DATA gt_sets LIKE TABLE OF gt_set.
10. DATA gv_setsize TYPE i.
12. PARAMETERS: p_total TYPE i DEFAULT 5,     "total number of elements in superset
13.       p_perm RADIOBUTTON GROUP r1,  "permutation
14.       p_comb RADIOBUTTON GROUP r1,  "combination
15.       p_max TYPE i DEFAULT 3,       "maximum size of set
16.       p_min TYPE i DEFAULT 1.       "minimum size of set
18. CHECK p_total GT 0 AND
19.     p_max GT 0 AND
20.     p_min GT 0 AND
21.     p_total GE p_max AND
22.     p_max GE p_min.
24. * populate superset index and data
25. DO p_total TIMES.
26.   APPEND sy-index TO gt_superset_index.
27.   APPEND sy-abcde+sy-index(1) TO gt_superset_data.
28. ENDDO.
30. * populate gt_sets table with various combinations of indexes
31. gv_setsize = p_min.
32. WHILE gv_setsize LE p_max.
33.   PERFORM build_sets USING  gt_superset_index
34.               gv_setsize.
35.   gv_setsize = gv_setsize + 1.
36. ENDWHILE.
38. * display sets by using data from gt_superset_data and index from gt_sets
39. PERFORM display.
41. *&---------------------------------------------------------------------*
42. *&      Form  BUILD_SETS
43. *&---------------------------------------------------------------------*
44. FORM build_sets  USING    pt TYPE tty
45.               p_setsize TYPE i.
46.   DATA lv TYPE i.
47.   DATA lv_lines TYPE i.
48.   DATA lt TYPE tty.
49.   DATA lv_tabix TYPE i.
51.   LOOP AT pt INTO lv.
52.   lv_tabix = sy-tabix.
53. * PUSH element to stack and pass remaining to recursive call
54.   APPEND lv TO gt_set.
56. * save set if set size is achieved
57.   DESCRIBE TABLE gt_set LINES lv_lines.
58.   IF lv_lines EQ p_setsize.
59.     APPEND gt_set TO gt_sets.
60.     DELETE gt_set INDEX lv_lines.
61.     CONTINUE.
62.   ENDIF.
64. * recursive call for subset
65.   lt = pt.
66.   CASE 'X'.
67.     WHEN p_perm.
68.     "permutation - calculate for all elements excluding current
69.     DELETE lt INDEX lv_tabix.
70.     WHEN p_comb.
71.     "combination - calculate for all elements following current
72.     DELETE lt TO lv_tabix.
73.   ENDCASE.
75.   IF lt IS NOT INITIAL.
76.     PERFORM build_sets USING  lt
77.                 p_setsize.
78.   ENDIF.
80. * POP the element from stack once all combinations are tried
81.   DESCRIBE TABLE gt_set LINES lv_lines.
82.   DELETE gt_set INDEX lv_lines.
83.   ENDLOOP.
85. ENDFORM.                    " BUILD_SETS
86. *&---------------------------------------------------------------------*
87. *&      Form  DISPLAY
88. *&---------------------------------------------------------------------*
89. FORM display .
91.   FIELD-SYMBOLS: <fs_set> TYPE ANY TABLE,
92.          <fs_index> TYPE i,
93.          <fs_data>  TYPE c.
95.   LOOP AT gt_sets ASSIGNING <fs_set>.
96.   NEW-LINE.
97.   LOOP AT <fs_set> ASSIGNING <fs_index>.
98.     READ TABLE gt_superset_data INDEX <fs_index> ASSIGNING <fs_data>.
99.     IF sy-subrc EQ 0.
100.     WRITE <fs_data>.
101.     ENDIF.
102.   ENDLOOP.
103.   ENDLOOP.
105. ENDFORM.                    " DISPLAY