Berechnungsreihenfolge von SubLists

[Secretdeadlyallo]

Hey,
Ich suche irgendwie eine kluge Idee, wenn ich eine List<Integer> habe davon alle SubLists zu berechnen, aber angefangen bei der grössten und dann immer kleiner.
Um bei Aufgaben wie z.b. finde die grösste(n) SubLists, welche xy erfüllen.

public static void main(String[] args) {
  List<Integer> test = new ArrayList<Integer>();
  test.add(1);
  test.add(13);
  test.add(4);
  subSequences(test); // [1][13][1, 13][13][4][13, 4][1, 13, 4]
  System.out.println();
  System.out.println(subSequencesIt(test)); //[[1], [4], [1, 13, 4], [13, 4], [13], [1, 13]]
 }
 public static void subSequences(List<Integer> test) {
  if (test.size() == 1) {
   System.out.print(test);
   return;
  } else {
   subSequences(test.subList(0, test.size() - 1));
   subSequences(test.subList(1, test.size()));
   System.out.print(test);
  }
 }
 public static Set<List<Integer>> subSequencesIt(List<Integer> test) {
  List<Integer> out = new ArrayList<Integer>();
  Set<List<Integer>> back = new HashSet<List<Integer>>();
  for (int j = 0; j < test.size(); j++) {
   for (int i = j + 1; i <= test.size(); i++) {
    out = test.subList(j, i);
    back.add(out);
   }
  }
  return back;
 }
}

Bisher hab ich nur einmal rekursiv eine Methode um die Sublists zu finden du eine Iterative.
Aber ich weiss nun nicht, wie ichs richtig ändern sollte, um die SubLists der Grösse nach zu finden, angefangen bei der grössten.
Meine Versuche die for Schleife zu ändern haben nicht funktioniert.

Hoffe jemand kann mir helfen.

 

[httpdigest]

Hab etwas dran geknabbert, aber das geht auch schön mit Streams:

import static java.util.Arrays.asList;
import static java.util.stream.IntStream.*;
import static java.util.stream.Collectors.toList;
import static java.util.function.Function.identity;
import java.util.List;

public static void main(String[] args) {
  List<String> list = asList("a", "b", "c", "d", "e", "f");
  List<List<String>> sublists = 
      range(0, list.size())
      .mapToObj(i -> rangeClosed(0, i)
                    .mapToObj(j -> list
                        .subList(j, j + list.size() - i)))
      .flatMap(identity())
      .collect(toList());
  System.out.println(sublists);
}

Die Idee hierbei ist, quasi zwei Schleifen zu haben. Eine, die die Länge der produzierten Teillisten repräsentiert und eine, die den Offset innerhalb der Teillisten selber Länge hochzählt.

 

[Secretdeadlyallo]

phu danke erstmal für eine funktionierende Lösung. Dreiviertel der Sachen die du da benutzt hast, kannte ich bisher gar nicht

Könnte man die von mir vorgeschlagenen Methoden ändern, dass diese auch gehen würden oder wäre dies gar nicht möglich?

 

[httpdigest]

Klar:

private static <T> List<List<T>> subSequencesIt(List<T> test) {
  List<List<T>> back = new ArrayList<>();
  /* Schleife über die Länge der Teillisten (test.size() - j): */
  for (int j = 0; j < test.size(); j++)
    /* Schleife über den Offset innerhalb Teillisten gleicher Länge: */
    for (int i = 0; i <= j; i++)
      back.add(test.subList(i, i + test.size() - j));
  return back;
}

 

[Secretdeadlyallo]

Besten Dank!