从给定的字符串数组创建多个 arrays

Question

I have an array of unique strings from which i need to create all possible arrays with the same length.

String[] str = {"Belgium", "France", "Germany"};

The goal is to create a list of arrays which have every possible value from above array at each index,

[Belgium, Belgium, Belgium]
[Belgium, Belgium, France]
[Belgium, Belgium, Germany]
[Belgium, France, Belgium]
[Belgium, France, France]
[Belgium, France, Germany]
[Belgium, Germany, Belgium]
[Belgium, Germany, France]
[Belgium, Germany, Germany]
[France, Belgium, Belgium]

....

[Germany, Germany, France]
[Germany, Germany, Germany]

My code to create this looks like

static List<String[]> getAllAllocations(String[] input){
    List<String[]> result = new ArrayList<>();
    if(input.length == 2){
        for(int i = 0; i < 2; i++){
            for(int j = 0; j < 2; j++){
                result.add(new String[]{input[i], input[j]});
            } 
        }
    }
    else if(input.length == 3){
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 3; j++){
                for(int k = 0; k < 3; k++){
                    result.add(new String[]{input[i], input[j], input[k]});
                }
            } 
        }
    }
    else if(input.length == 4){
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                for(int k = 0; k < 4; k++){
                    for(int m = 0; m < 4; m++){
                        result.add(new String[]{input[i], input[j], input[k], input[m]});
                    }
                }
            } 
        }
    }
    //else if(input.length == 5) similar code with 5 for loops
    //else if(input.length == 6) similar code with 6 for loops
    //else if(input.length == 7) similar code with 7 for loops
    //else if(input.length == 8) similar code with 8 for loops
    return result;
}

The array will have a variable length between 2 and 8. How can I dynamicaly create the for loops instead of chaining the if-else checks or any other way to do this in an elganter way than I did above?

Answer 1

Recursive solution

public static List<String[]> getAllAllocations(String[] input) {
    List<String[]> result=new ArrayList<String[]>();
    getAllAllocations(result, input, new String[input.length], 0);
    return result;
}

public static void getAllAllocations(List<String[]> result, String[] input, String[] current, int depth) {
    if (depth>=input.length) {
        result.add(current.clone());
    } else {
        for (int i=0;i<input.length;i++) {
            current[depth]=input[i];
            getAllAllocations(result, input, current, depth+1);
        }
    }
}

Iterative solution

public static List<String[]> getAllAllocations2(String[] input) {
    List<String[]> result=new ArrayList<String[]>();
    
    int[] counters=new int[input.length];
    
    boolean done=false;
    while (!done) {
        
        String[] comb=new String[input.length];
        for (int i=0;i<comb.length;i++) {
            comb[i]=input[counters[i]];
        }
        result.add(comb);

        done=true;
        for (int i=0;i<counters.length;i++) {
            counters[i]++;
            if (counters[i]>=input.length) {
                counters[i]=0;
            } else {
                done=false;
                break;
            }
        }
    }
    
    return result;
}

Answer 2

You can use map and reduce approach:

1. map - first prepare the lists of arrays List<String[]> . An array of three elements becomes three lists of singleton arrays:

    list1: [[Belgium], [France], [Germany]] list2: [[Belgium], [France], [Germany]] list3: [[Belgium], [France], [Germany]]

2. reduce - then multiply these lists sequentially one by one and get the Cartesian product . Two steps of reduction for three lists:

    list1: [[Belgium], [France], [Germany]] list2: [[Belgium], [France], [Germany]] ------ sum1: [[Belgium, Belgium], [Belgium, France], ..., [Germany, Germany]]

    sum1: [[Belgium, Belgium], [Belgium, France], ..., [Germany, Germany]] list3: [[Belgium], [France], [Germany]] ------ total: [[Belgium, Belgium, Belgium], [Belgium, Belgium, France], ...]

Try it online!

public static void main(String[] args) {
    String[] str = {"Belgium", "France", "Germany"};
    cartesianProduct(str).forEach(arr->System.out.println(Arrays.toString(arr)));
}

static List<String[]> cartesianProduct(String[] input) {
    return IntStream.range(0, input.length)
            // Stream<List<String[]>>
            .mapToObj(i -> Arrays.stream(input)
                    .map(str -> new String[]{str})
                    .collect(Collectors.toList()))
            // stream of lists to a single list
            .reduce((list1, list2) -> list1.stream()
                    .flatMap(arr1 -> list2.stream()
                            .map(arr2 -> Stream.of(arr1, arr2)
                                    .flatMap(Arrays::stream)
                                    .toArray(String[]::new)))
                    .collect(Collectors.toList()))
            .orElse(Collections.emptyList());
}