contributed to open source

Java/iterative-combination-algorithm.java

@@ -0,0 +1,143 @@
+import java.util.LinkedList;
+import java.util.List;
+
+public class Main {
+
+    public static void main(String[] args) {
+        /**
+         * Iterative Combination Algorithm solution for finding all possible combination of k
+         * sized sublist of elements for a given array or list of size n ===> 2<=k<=n
+         */
+        int n = 7;
+        int k = 4;
+
+        iterativeCombinationAlgorithm(n, k);
+    }
+
+    private static void iterativeCombinationAlgorithm(int n, int k) {
+        if (n >= k && k >= 2) {
+            /** taking index 0 for "for loop that iterates n-k times" to be implemented as current starting index
+             * as index 0 thereby populating possible combinations in otherIndexesOfUnitList array.
+             */
+            for (int currentStartingIndex = 0; currentStartingIndex <= n - k; ++currentStartingIndex) {
+
+                /** dummy array of indexes of smallest pair of k-1 elements where the first index of the list is
+                 *  currentStartingIndex
+                 */
+                int[] otherIndexesOfUnitList = new int[k - 1];
+
+                /**populating the first pair of k-1 elements setting index 0 which is position 1 of
+                 * starting pair of k pair integers
+                 */
+                for (int index = 0; index < otherIndexesOfUnitList.length; ++index) {
+                    if (index == 0)
+                        otherIndexesOfUnitList[index] = currentStartingIndex + 1;
+                    else
+                        otherIndexesOfUnitList[index] = otherIndexesOfUnitList[index - 1] + 1;
+                }
+
+                /** list of all pairs of possible combination k integer pairs from 0 to n-1
+                 * for currentStartingIndex iteration
+                 */
+                List<List<Integer>> listOfPairs = new LinkedList<>();
+
+                /**
+                 * Brute force while loop to find all k integer pairs and store in nested list
+                 */
+                while (true) {
+
+                    /**
+                     * list that stores integer of current k pairs of integers consisting
+                     * of the starting index and @otherIndexesUnitList array of size k-1
+                     */
+                    List<Integer> currentPair = new LinkedList<>();
+
+                    /**
+                     * adding currentStartingIndex to current pair
+                     */
+                    currentPair.add(currentStartingIndex);
+
+                    /**
+                     * adding index position 1 to k - 2 to current pair list from otherIndexesUnitList array
+                     */
+                    for (int middleIndex = 0; middleIndex < otherIndexesOfUnitList.length - 1; ++middleIndex)
+                        currentPair.add(otherIndexesOfUnitList[middleIndex]);
+
+                    /**
+                     * for loop that add increasing values of currentLastIndexes up to n-1
+                     */
+                    for (int currentLastIndex = otherIndexesOfUnitList[k - 2]; currentLastIndex < n; ++currentLastIndex) {
+                        /**
+                         * adding last of element otherIndexesOfUnitList
+                         */
+                        currentPair.add(currentLastIndex);
+                        /**
+                         * adding generated pair of k integers to list
+                         */
+                        listOfPairs.add(new LinkedList<>(currentPair));
+                        /**
+                         * removing last index of current to add incremented value of currentLastIndex
+                         * in the kth position
+                         */
+                        currentPair.remove(currentPair.size() - 1);
+                        /**
+                         * condition checking if currentLastIndex has reached the last index of for loop and updating
+                         * last element otherIndexesOfUnitList array
+                         */
+                        if (currentLastIndex == n - 1)
+                            otherIndexesOfUnitList[k - 2] = currentLastIndex;
+                    }
+                    System.out.println(listOfPairs); // line that prints listOfPairs
+                    /**
+                     * offset variable for checking if an index of an array has attained
+                     * its maximum possible value for k pair of integers
+                     */
+                    int j = 0;
+
+                    /**
+                     * this variable is used to track the index of the array element that has not
+                     * attained its maximum possible value
+                     */
+                    int targetIndex = -1;
+
+                    /**
+                     * for loop that iterates through the array backwards to find first element's index that has not
+                     * attained its maximum value
+                     */
+                    for (int index = otherIndexesOfUnitList.length - 1; index >= 0; --index) {
+                        /**
+                         * condition that checks if current
+                         * element of array has has attained its possible max
+                         */
+                        if (otherIndexesOfUnitList[index] != n - j - 1) {
+                            targetIndex = index;
+                            break;
+                        }
+                        ++j;
+                    }
+                    /** condition checking if there was an element in the array that
+                     * has not attained its possible max
+                     * for loop increases all elements of the array by 1 starting from the element at target index
+                     */
+                    if (targetIndex != -1) {
+                        for (int currentIndex = targetIndex; currentIndex < otherIndexesOfUnitList.length; ++currentIndex) {
+                            if (currentIndex == targetIndex)
+                                ++otherIndexesOfUnitList[currentIndex];
+                            else
+                                otherIndexesOfUnitList[currentIndex] = otherIndexesOfUnitList[currentIndex - 1] + 1;
+                        }
+                    }
+                    /**
+                     * if condition is false all possible k integer pairs for that currentStartingIndex
+                     * value have been found and stored to list
+                     */
+                    else
+                        break;
+                }
+                /**
+                 * program continues for next currentStartingIndex
+                 */
+            }
+        }
+    }
+}