Question

I found a question online: Given input size print all well formed numbers of that size.

Example: size = 3
Numbers: 123, 234, 125 etc. Condition, say number is abc then a < b < c

I am trying to write a recursive code for this and since I suck at recursion am not able to figure out the base case, or how to come out of the recursion. I had one idea:

1. I start from with lowest well formed number of the given size (just fill array with for loop). Say size = 3, I start with 123. Then I go on till arr[0] == (10 - size)) cause that is the max value of arr[0] for the given size to be a well formed number.

My function would be printNumbers(int arr[], int size)

But am not sure if this would work. Need some pointers on the right direction.

public void findNumbers(int arr[], int size, int pos)
    {
        if(arr[0] == (10 - size))
            return;
        if(arr[pos] == (10 - size + pos))
        {
            pos--;
            findNumbers(arr,size,pos);
        }
        System.out.println(Arrays.toString(arr));
        arr[pos] = arr[pos] + 1;
        findNumbers(arr,size,pos);
    }

    public static void main(String[] args)
    {
        int size = 3;
        int pos = size-1;
        int arr[] = new int[size];
        for(int i = 0; i<size; i++)
        {
            arr[i] = i+1;
        }
        //System.out.println(Arrays.toString(arr));
        WellFormed obj = new WellFormed();
        obj.findNumbers(arr, size, pos);
    }

Answer 1

import java.util.Arrays;

public class WellFormed {

    public static int maxDigit;

    public void findNumbers(int[] digits, int start, int currPos) {
        if (currPos >= digits.length) {
            System.out.println(Arrays.toString(digits));
            return;
        }

        int maxDigitInCurrPos = maxDigit - digits.length + currPos + 1;
        for (int i = start; i <= maxDigitInCurrPos; i++) {
            digits[currPos] = i;
            findNumbers(digits, i+1, currPos + 1);
        }
    }

    public static void main(String[] args)
    {   
        WellFormed obj = new WellFormed();
        maxDigit = 5;
        int inputSize = 3;
        int[] digits = new int[inputSize];
        obj.findNumbers(digits, 1, 0);
    }
}

This works fine:

For inputSize = 3 and maxDigit = 5, output is:

[1, 2, 3]
[1, 2, 4]
[1, 2, 5]
[1, 3, 4]
[1, 3, 5]
[1, 4, 5]
[2, 3, 4]
[2, 3, 5]
[2, 4, 5]
[3, 4, 5]