Étant donné un tableau d'entiers (de longueur n), trouver et retourner tous les sous-ensembles du tableau d'entrée en utilisant la récursivité en Java

Voici.

[15]
[15, 20]
[15, 20, 12]
[15, 12]
[20]
[20, 12]
[12]

Comme chaque appel de récursivité représentera un sous-ensemble ici, ajoutez resultList (voir le code de récursivité ci-dessus) à la liste des sous-ensembles de chaque appel. 2.Itérer sur les éléments d'un ensemble. À chaque itération, ajoutez des éléments à la liste explore (récursivité) et faites start = i + 1 pour parcourir les éléments restants du tableau. Supprimer l'élément de la liste

Production:

public static void main(String[] args) {

    int[] nums= {15, 20, 12};
    int[][] subsets = subsets(nums);
    for (int i = 1; i < subsets.length; i++) {
        System.out.println(Arrays.toString(subsets[i]));
    }
}

public static int[][] subsets(int input[]) {
    List<List<Integer>> list = new ArrayList<>();
    subsetsHelper(list, new ArrayList<>(), input, 0);
    return convertListToArray(list);
}

private static void subsetsHelper(List<List<Integer>> list , List<Integer> resultList, int [] nums, int start){
    list.add(new ArrayList<>(resultList));
    for(int i = start; i < nums.length; i++){
       // add element
        resultList.add(nums[i]);
       // Explore
        subsetsHelper(list, resultList, nums, i + 1);
       // remove
        resultList.remove(resultList.size() - 1);
    }
}

private static int[][] convertListToArray(List<List<Integer>> list) {
    int[][] array = new int[list.size()][];
    for (int i = 0; i < array.length; i++) {
        array[i] = new int[list.get(i).size()];
    }
    for(int i=0; i<list.size(); i++){
        for (int j = 0; j < list.get(i).size(); j++) {
            array[i][j] = list.get(i).get(j);
        }
    }
    return array;

}

Pas clair s'il s'agit de devoirs ou d'un cas pratique. Voici comment le résoudre en utilisant Guava PowerSet:

public static void main(String[] args) {
    Integer input[] = {15,20,12};
    List<Integer> rev = Lists.reverse(Arrays.asList(input));
    Set<Integer> indices = IntStream.range(0, input.length).boxed().collect(ImmutableSet.toImmutableSet());
    Object output[] = Sets.powerSet(indices).stream()
            .filter(indexset -> !indexset.isEmpty())
            .map(indexset -> indexset.stream().map(i -> rev.get(i)).collect(Collectors.collectingAndThen(toList(), Lists::reverse)))
            .map(List::toArray)
            .toArray();
    System.out.println(Arrays.deepToString(output));
}

Avertissement:

1. Ceci est mon travail original. Aucune partie de la solution n'a été copiée de n'importe où.
2. Ma solution fonctionne parfaitement pour 3 éléments. Cependant, cela doit être amélioré pour fonctionner avec des tableaux d'autres tailles. Malgré cela, je le publie pour qu'OP ou n'importe qui d'autre puisse étendre cette solution pour qu'elle fonctionne pour un tableau de n'importe quelle taille.
3. Cette question est proche de l'ensemble de puissance sauf pour le fait qu'un ensemble de puissance ne peut pas avoir d'éléments dupliqués. Si cette exception est supprimée de cette question, il existe de nombreuses solutions disponibles par exemple en 1 , 2 , 3 etc.

 [[15], [15, 20], [15, 12], [20], [20, 12], [12], [15, 20, 12]]

Production:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = { 15, 20, 12 };
        System.out.println(Arrays.deepToString(subsets(arr)));
    }

    public static int[][] subsets(int input[]) {
        int[][] subarrs = new int[(int) Math.pow(2, input.length) - 1][input.length];
        int[] indices = { 0 };
        subsetsHelper(input, subarrs, 0, 0, 0, indices);
        return subarrs;
    }

    private static void subsetsHelper(int input[], int[][] subarrs, int index, int i, int j, int[] indices) {
        if (i == input.length) {
            subarrs[index] = input;
            return;
        }
        int[] subarr = new int[indices.length];
        for (int x = 0; x < subarr.length; x++) {
            subarr[x] = input[indices[x]];
        }
        subarrs[index] = subarr;
        if (j == input.length - 1) {
            subsetsHelper(input, subarrs, index + 1, i + 1, i + 1, new int[] { i + 1 });
        } else {
            subsetsHelper(input, subarrs, index + 1, i, j + 1, new int[] { i, j + 1 });
        }
    }
}

public static int [] [] returnallsub (int arr [], int si) {

    if(si==arr.length)
    {int[][]ret=new int [1][0];
return ret;
    }
    
    
    int [][]rss =returnallsub(arr,si+1);
    int [][]tss=new int[rss.length*2][];
    
    int i=0;
for(;i<rss.length;i++) {
tss[i]=new int [rss[i].length];

}
       int k=0;
    for(;k<rss.length;k++) {
tss[i]=new int [rss[k].length+1];
  i++;
}
    
    
        int j=0;
   for(i=0;i<rss.length;i++) {
  for(j=0;j<rss[i].length;j++){
      
      tss[i][j]=rss[i][j];
  }
}
    
     for(k=i;k<tss.length;k++)  {
      tss[k][0]=arr[si];
  }
    
      int r=i;
      for(i=0;i<rss.length;i++) {
  for(j=0;j<rss[i].length;j++){
      
      tss[r][j+1]=rss[i][j];
      
  }
          r++;
} 
 return tss; 
    
    
}



public static int[][] subsets(int arr[]) {
   
     int start=0;
  return  returnallsub( arr,0);
    
    


}

}