given multiple ranges select combination of numbers to reach the given sum

Given the ranges i.e (1-6), (3-6), (2-5) and sum to be reached is 13. I should be able to pick numbers from each range so that their sum is 13.

Example Output : (3,5,5) , (4,4,5) etc

I am trying this out with java code and not able to figure out the exact implementation. I need to generate random number within this range and check for the sum of those numbers. Here there is danger of infinite loop. Could you please help me with this.

public static void main(String[] args) {
    int rangeStart1 = 1;
    int rangeEnd1 = 6;

    int rangeStart2 = 3;
    int rangeEnd2 = 6;

    int rangeStart3 = 2;
    int rangeEnd3 = 5;

    int sum = 13;
    int obtainedSum = 0;
    int randomNum1 = 0;
    int randomNum2 = 0;
    int randomNum3 = 0;
    while (obtainedSum != sum) {
        randomNum1 = (int)((Math.random() * (rangeEnd1 - rangeStart1)) + rangeStart1);
        randomNum2 = (int)((Math.random() * (rangeEnd2 - rangeStart2)) + rangeStart2);
        randomNum3 = (int)((Math.random() * (rangeEnd3 - rangeStart3)) + rangeStart3);
        obtainedSum = obtainedSum + randomNum1 + randomNum2 + randomNum3;
    }

    System.out.println(obtainedSum);
    System.out.println(randomNum1);
    System.out.println(randomNum2);
    System.out.println(randomNum3);
}

To find given permutations of numbers from numeric arrays that match a given sum, you can use a brute-force algorithm to find possible combinations. To achieve that, you can use a depth-first-search in a build by picking one number from each array at a time to construct a path.

For your example input { [1-6], [3-6], [2-5] } (end inclusive), a valid path could be 1 > 3 > 2 (first number from each array). With recursion, you can evaluate all possible paths and find the ones that match the given sum.

First, some definitions using Java record syntax to avoid unneccessary boilerplate code. You can backport the classes to lower Java versions if needed.

// input range to pick numbers from
public record Range(int startInclusive, int endInclusive) {

    @Override
    public String toString() {
        return "[" + startInclusive + "," + endInclusive + "]";
    }
}

// a node in the graph contains the picked number and the range
// that this number has been picked from
public record Node(Range range, int number) {
    
    @Override
    public String toString() {
        return number + " from " + range.toString();
    }
}

// connection of multiple nodes in a graph
public record Path(Collection<Node> nodes) {

    public static Path EMPTY = new Path(Collections.emptyList());

    // sum of all current nodes
    public int sum() {
        int sum = 0;
        for (Node s : nodes()) {
            sum += s.number;
        }
        return sum;
    }

    // copy of this path with the node added
    public Path with(Node node) {
        List<Node> nodes = new ArrayList<>(nodes());
        nodes.add(node);
        return new Path(nodes);
    }
}

Now, a PathContext that stores neccessary information used during recursion.

public class PathContext {

    private final Range[] ranges;
    private final int sum;

    // resulting paths that match the sum
    private final Collection<Path> paths = new ArrayList<>();
    // find all matches or just one (latter is faster)
    private final boolean skipAfterMatch = false;

    public PathContext(Collection<Range> ranges, int sum) {
        this.ranges = ranges.toArray(new Range[0]);
        this.sum = sum;
    }

    // if the path a valid solution, add it the the results
    public void validatePath(Path path) {
        if (path.sum() == sum) {
            paths.add(path);
        }
    }

    public Range[] getRanges() {
        return ranges;
    }

    public Collection<Path> getPaths() {
        return Collections.unmodifiableCollection(paths);
    }

    public int getSum() {
        return sum;
    }
    
    public boolean abortSearch() {
        return skipAfterMatch && !paths.isEmpty();
    }
}

Now finally, the dfs (depth-first-search):

public static void dfs(PathContext ctx, int rangeIdx, Path path) {
    // if we have no more ranges to pick from, validate if the sum matches
    if (rangeIdx >= ctx.getRanges().length) {
        ctx.validatePath(path);
    } else {
        // get the next range
        Range next = ctx.getRanges()[rangeIdx];

        // traverse trough all numbers in the range, end inclusive
        for (int i = next.startInclusive; i <= next.endInclusive; i++) {
            // generate a new node and path
            Node node = new Node(next, i);
            Path newPath = path.with(node);

            // recurse with the next range
            dfs(ctx, rangeIdx + 1, newPath);

            // check if the search can be aborted (if only one match is needed)
            if (ctx.abortSearch()) {
                break;
            }
        }
    }
}

You can then call dfs using your example data:

public static void main(String[] args) {
    Range range1 = new Range(1, 6);
    Range range2 = new Range(3, 6);
    Range range3 = new Range(2, 5);
    List<Range> ranges = List.of(range1, range2, range3);

    PathContext ctx = new PathContext(ranges, 13);
    // start from index 0 (the first range)
    dfs(ctx, 0, Path.EMPTY);

    // output logging
    System.out.println("total sum: " + ctx.getSum());
    for (Path path : ctx.getPaths()) {

        for (Node node : path.nodes()) {
            System.out.println(node);
        }
        System.out.println();
    }
}

Resulting output is:

total sum: 13
2 from [1,6]
6 from [3,6]
5 from [2,5]

3 from [1,6]
5 from [3,6]
5 from [2,5]

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

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

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

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

5 from [1,6]
3 from [3,6]
5 from [2,5]

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

5 from [1,6]
5 from [3,6]
3 from [2,5]

5 from [1,6]
6 from [3,6]
2 from [2,5]

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

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

6 from [1,6]
5 from [3,6]
2 from [2,5]