固定サイズを作成する要素リストから反復しない順列のリスト

Question

オブジェクトリストM := [A, B, C, ... Z]があります。これらのオブジェクトの順列を反復しない固定サイズ "f"を含む新しいリストNを作成します。

Nは(for f = 2) [[A, B], [A, C], ...]ですが、[A, A]のような繰り返しを含めることはできません。[A, B]を設定した場合は、[B, A]を無視する必要があります。

私はGuavas "PowerSet"のようなものを見つけましたが、固定サイズに「切り取られ」ないので、これは助けになりません。

私は正しく私の問題を述べたと思います。

private Set<List<Object>> combineObjects(List<Object> M) { 
    boolean[] used = new boolean[M.size()]; 
    return generateObjectCombinations(M, 0, 0, used); 
} 

private Set<List<Object>> generateObjectCombinations(
    List<Object> M, 
    int start, 
    int curLen, 
    boolean[] used 
) { 
    Set<List<Object>> returnSet = new HashSet<>(); 
    if (curLen == 2) { 
     List<Object> data = newArrayList(); 
     for (int i = 0; i < M.size(); i++) { 
      if (used[i]) { 
       data.add(M.get(i)); 
      } 
     } 
     returnSet.add(data); 
     return returnSet; 
    } 
    if (start == M.size()) { 
     return Collections.emptySet(); 
    } 
    used[start] = true; 
    returnSet.addAll(generateObjectCombinations(M, start + 1, curLen + 1, used)); 
    used[start] = false; 
    returnSet.addAll(generateObjectCombinations(M, start + 1, curLen, used)); 
    return returnSet; 
} 

それが機能していますが、「クリーンな」解決策があるかどうか、私は疑問に思う：

fは常に私は次のことをやったhttp://algorithms.tutorialhorizon.com/print-all-combinations-of-subset-of-size-k-from-given-array/に基づいて2

でなければなりません。私はブール配列を排除したい。

いいえ、それは私の宿題ではありません。多分私は疲れて休暇を取るべきです。

List<List<Object>> combinations = new ArrayList<>(); 
List<Object> M = new ArrayList<>(); 

for (int i = 0; i < M.size(); i++) { 
    Object outerM = M.get(i); 

    for (int j = i; j < M.size(); j++) { 
     Object innerM = M.get(j); 
     if (innerM.equals(outerM)) { 
      continue; 
     } 
     combinations.add(Lists.newArrayList(outerM, innerM)); 
    } 
} 

または私は本当にloooong休暇を取る必要があります

List<List<Object>> combinations = new ArrayList<>(); 
List<Object> M = new ArrayList<>(); 

for (int i = 0; i < M.size(); i++) { 
    Object outerM = M.get(i); 

    for (int j = (i + 1); j < M.size(); j++) { 
     Object innerM = M.get(j); 
     combinations.add(Lists.newArrayList(outerM, innerM)); 
    } 
} 

さらに良い：@のazroの回答に基づいて

EDIT は、私はこのようなコードを再構築しました。ありがとう@アズロ!!

Answer 1

あなたが書いていなかったとして、私はので、ここで、f>=1のために働く方法であり、それを使用する方法ソリューションを書いた始まりと「fは常に2にしてください」：

public static void main(String[] args) { 
     List<String> letter = Arrays.asList("A", "B", "C", "D", "E"); 
     List<String> res = new ArrayList<>(); 
     res.addAll(letter); 
     int size = 2; 

     for (int i = 1; i < size ; i++) { 
      res = addLetter(res, letter); //add a letter to all 
     } 

     res.forEach(p -> System.out.println(p)); 
} 

public static List<String> addLetter(List<String> already, List<String> letters) { 
    List<String> res = new ArrayList<>(); 

    for (String al : already) { 
     for (String let : letters) { 
      if (!al.contains(let)) { 
       res.add(al + let); 
      } 
     } 
    } 
    return res; 
} 

---

「fは常に2でなければならない」場合にのみ必要です

public static void main(String[] args) { 
    List<String> letters = Arrays.asList("A", "B", "C", "D", "E"); 
    List<String> res = new ArrayList<>(); 

    for (String al : letters) { 
     for (String let : letters) { 
      if (!al.contains(let)) { 
       res.add(al + let); 
      } 
     } 
    } 
    res.forEach(p -> System.out.println(p)); 
} 

Answer 2

私はそれが最善の解決策だかはわからないが、ここであなたは：

static HashSet<HashSet<String>> getCombinations(HashSet<HashSet<String>> s, int f) 
{ 
    if(f == 1) 
     return s; 
    HashSet<HashSet<String>> newSet = new HashSet<HashSet<String>>(); 
    for (HashSet<String> ss : s) 
    { 
     for(String elm : A) 
     { 
      if(ss.contains(elm)) 
       continue; 
      HashSet<String> sss = (HashSet<String>)ss.clone(); 
      sss.add(elm); 
      newSet.add(sss); 
     } 
    } 
    return getCombinations(newSet, f-1); 
} 

使用法：

String[] A = {"A", "B", "C", "D", "E"}; 
public static void main(String[] args) 
{ 
    int f = 3; 
    HashSet<HashSet<String>> set = new HashSet<>(); 
    for(String s : A) 
    { 
     HashSet<String> ss = new HashSet<>(); 
     ss.add(s); 
     set.add(ss); 
    } 
    System.out.println(getCombinations(set, f)); 
}