Guava Kolekcje: limit rozmiaru permutacji

Question

Korzystanie z guawy 12 Collections2.permutations(), zastanawiam się, czy to możliwe, aby ograniczyć rozmiar permutacji?

Dokładniej, chciałbym uzyskać listę permutacji k-size na liście n elementów, zamiast otrzymać listę wszystkich permutacji n-size.

Obecnie, jeśli mijam listę 4 owoców, permutacji() będzie obecnie zwróci listę 24 4 wielkości permutacji chociaż jestem zainteresowany tylko pobieranie, powiedzmy, 4 unikalne rozmiar 3 permutacje .

Powiedz, mam listę 4 owoców:

["Banana", "Apple", "Orange", "Peach"] 

Jeśli jestem zainteresowany tylko w rozmiarach 3 permutacji, chciałbym powrócił następuje:

["Banana", "Apple", "Orange"] 
["Banana", "Apple", "Peach"] 
["Banana", "Orange", "Peach"] 
["Apple", "Orange", "Peach"] 

Czy ktoś proszę podać wszelkie wskazówki dotyczące rozwiązania? Dzięki !

Answer 1

Ten kod wyprowadza zmiany, a następnie uruchamia permutacje dla każdego unikalnego zestawu 3.

tj. Dla "A", "B", "C", "D" możliwościami są [[A, B, C], [A, B, D], [A, C, D], [B, PŁYTA CD]]. Następnie obliczamy permutacje na każdym trójkącie (lub n-tym) i dołączamy możliwości do listy.

PermutationsOfN.processSubsets (listę zestawu int k) zwrócone: [[A, B, C], [A, B, D], [A, C, D], [B, C, D ]]

Trochę dalej PermutationsOfN.permutacje (lista list, rozmiar int) zwraca:
[[A, B, C], [A, C, B], [C, A, B], [C, B, A], [B, C , A], [B, A, C], [A, B, D], [A, D, B], [D, A, B], [D, B, A], [B, D, A ], [B, A, D], [A, C, D], [A, D, C], [D, A, C], [D, C, A], [C, D, A], [C, A, D], [B, C, D], [B, D, C], [D, B, C], [D, C, B], [C, D, B], [C , B, D]]

import java.util.Collection; 
import java.util.List; 

import com.google.common.collect.Collections2; 
import com.google.common.collect.ImmutableList; 
import com.google.common.collect.Lists; 

public class PermutationsOfN<T> { 
    public static void main(String[] args) { 
    List<String> f = Lists.newArrayList("A", "B", "C", "D"); 
    PermutationsOfN<String> g = new PermutationsOfN<String>(); 
    System.out.println(String.format("n=1 subsets %s", g.processSubsets(f, 1))); 
    System.out.println(String.format("n=1 permutations %s", g.permutations(f, 1))); 
    System.out.println(String.format("n=2 subsets %s", g.processSubsets(f, 2))); 
    System.out.println(String.format("n=2 permutations %s", g.permutations(f, 2))); 
    System.out.println(String.format("n=3 subsets %s", g.processSubsets(f, 3))); 
    System.out.println(String.format("n=3 permutations %s", g.permutations(f, 3))); 
    System.out.println(String.format("n=4 subsets %s", g.processSubsets(f, 4))); 
    System.out.println(String.format("n=4 permutations %s", g.permutations(f, 4))); 
    System.out.println(String.format("n=5 subsets %s", g.processSubsets(f, 5))); 
    System.out.println(String.format("n=5 permutations %s", g.permutations(f, 5))); 
    } 

    public List<List<T>> processSubsets(List<T> set, int k) { 
    if (k > set.size()) { 
     k = set.size(); 
    } 
    List<List<T>> result = Lists.newArrayList(); 
    List<T> subset = Lists.newArrayListWithCapacity(k); 
    for (int i = 0; i < k; i++) { 
     subset.add(null); 
    } 
    return processLargerSubsets(result, set, subset, 0, 0); 
    } 

    private List<List<T>> processLargerSubsets(List<List<T>> result, List<T> set, List<T> subset, int subsetSize, int nextIndex) { 
    if (subsetSize == subset.size()) { 
     result.add(ImmutableList.copyOf(subset)); 
    } else { 
     for (int j = nextIndex; j < set.size(); j++) { 
     subset.set(subsetSize, set.get(j)); 
     processLargerSubsets(result, set, subset, subsetSize + 1, j + 1); 
     } 
    } 
    return result; 
    } 

    public Collection<List<T>> permutations(List<T> list, int size) { 
    Collection<List<T>> all = Lists.newArrayList(); 
    if (list.size() < size) { 
     size = list.size(); 
    } 
    if (list.size() == size) { 
     all.addAll(Collections2.permutations(list)); 
    } else { 
     for (List<T> p : processSubsets(list, size)) { 
     all.addAll(Collections2.permutations(p)); 
     } 
    } 
    return all; 
    } 
} 

wyróżnienie trafia do meriton którego odpowiedź here pomógł mi się dogadać.

Answer 2

Nie ma wbudowanej funkcji Guava, która to robi, ale można submit a feature request.

Gdybym pisanie implementację, myślę najprostszym sposobem byłoby iterację kombinacji (z Gosper's hack), a następnie permutacje tych z Collections2.permutations.

Wystarczająco, wygląda na to, że wystarczają drobne modyfikacje normalnego algorytmu generacji permutacji, oparte na this Python code.

Answer 3

bezpośredniej odpowiedzi na pytanie byłoby to:

public static <X> List<List<X>> test(List<X> input, final int n, final int m) { 
    int x = 0; 

    List<List<X>> newPerm = Lists.newArrayList(); 
    Collection<List<X>> perm = Collections2.permutations(input); 
    for (Iterator<List<X>> it = perm.iterator(); it.hasNext(); x++) { 
     if (x >= n) { 
      break; 
     } 

     List<X> list = it.next(); 
     newPerm.add(Lists.partition(list, m).get(0)); 
    } 

    return newPerm; 
} 

, a następnie:

List<String> list = Lists.newArrayList("Banana", "Apple", "Orange", "Peach"); 
    List<List<String>> answer = test(list, 4, 3); 
    for (List<String> list1 : answer) { 
     System.out.println(list1); 
    } 

Ale to trwa tylko pierwsze z nich i nie specjalnie zdefiniowanego zestawu, twój prawdopodobnie lepiej po Rada Louisa: