Generowanie wszystkie odrębne permutacji listy w R

Question

Próbuję utworzyć listę permutacji listy, tak, że na przykład perms(list("a", "b", "c")) powraca

list(list("a", "b", "c"), list("a", "c", "b"), list("b", "a", "c"), 
    list("b", "c", "a"), list("c", "a", "b"), list("c", "b", "a")) 

Nie jestem pewien, jak postępować, jakakolwiek pomoc byłaby bardzo doceniana.

Answer 1

combinat::permn zrobi, że praca:

> library(combinat) 
> permn(letters[1:3]) 
[[1]] 
[1] "a" "b" "c" 

[[2]] 
[1] "a" "c" "b" 

[[3]] 
[1] "c" "a" "b" 

[[4]] 
[1] "c" "b" "a" 

[[5]] 
[1] "b" "c" "a" 

[[6]] 
[1] "b" "a" "c" 

Należy pamiętać, że kalkulacja jest ogromny, jeśli element jest duża.

Answer 2

Można spróbować permutations() z pakietu gtools, ale w odróżnieniu od combinatpermn(), że nie emituje listę:

> library(gtools) 
> permutations(3, 3, letters[1:3]) 
    [,1] [,2] [,3] 
[1,] "a" "b" "c" 
[2,] "a" "c" "b" 
[3,] "b" "a" "c" 
[4,] "b" "c" "a" 
[5,] "c" "a" "b" 
[6,] "c" "b" "a" 

Answer 3

baza R może również stanowić odpowiedź:

all <- expand.grid(p1 = letters[1:3], p2 = letters[1:3], p3 = letters[1:3], stringsAsFactors = FALSE) 
perms <- all[apply(all, 1, function(x) {length(unique(x)) == 3}),] 

Answer 4

A gdy wracałem, musiałem to zrobić w bazie R bez ładowania żadnych pakietów.

permutations <- function(n){ 
    if(n==1){ 
     return(matrix(1)) 
    } else { 
     sp <- permutations(n-1) 
     p <- nrow(sp) 
     A <- matrix(nrow=n*p,ncol=n) 
     for(i in 1:n){ 
      A[(i-1)*p+1:p,] <- cbind(i,sp+(sp>=i)) 
     } 
     return(A) 
    } 
} 

Zastosowanie:

> matrix(letters[permutations(3)],ncol=3) 
    [,1] [,2] [,3] 
[1,] "a" "b" "c" 
[2,] "a" "c" "b" 
[3,] "b" "a" "c" 
[4,] "b" "c" "a" 
[5,] "c" "a" "b" 
[6,] "c" "b" "a" 

Answer 5

Spróbuj:

> a = letters[1:3] 
> eg = expand.grid(a,a,a) 
> eg[!(eg$Var1==eg$Var2 | eg$Var2==eg$Var3 | eg$Var1==eg$Var3),] 
    Var1 Var2 Var3 
6  c b a 
8  b c a 
12 c a b 
16 a c b 
20 b a c 
22 a b c 

Jak sugeruje @Adrian w komentarzach, ostatnia linia może być zastąpiony przez:

eg[apply(eg, 1, anyDuplicated) == 0, ] 

Answer 6

# Another recursive implementation  
# for those who like to roll their own, no package required 
    permutations <- function(x, prefix = c()) 
    { 
     if(length(x) == 0) return(prefix) 
     do.call(rbind, sapply(1:length(x), FUN = function(idx) permutations(x[-idx], c(prefix, x[idx])), simplify = FALSE)) 
    } 

    permutations(letters[1:3]) 
    # [,1] [,2] [,3] 
    #[1,] "a" "b" "c" 
    #[2,] "a" "c" "b" 
    #[3,] "b" "a" "c" 
    #[4,] "b" "c" "a" 
    #[5,] "c" "a" "b" 
    #[6,] "c" "b" "a" 

Answer 7

zabawy rozwiązanie „probabilistyczny” za pomocą próbki do bazy R:

elements <- c("a", "b", "c") 
k <- length(elements) 
res=unique(t(sapply(1:200, function(x) sample(elements, k)))) 
# below, check you have all the permutations you need (if not, try again) 
nrow(res) == factorial(k) 
res 

zasadzie można nazwać wiele losowych próbek, chcąc dostać je wszystkie, a ich wyjątkowy.

Answer 8

roztworu w podstawowej R, brak uzależnienia od innych pakietów:

> getPerms <- function(x) { 
    if (length(x) == 1) { 
     return(x) 
    } 
    else { 
     res <- matrix(nrow = 0, ncol = length(x)) 
     for (i in seq_along(x)) { 
      res <- rbind(res, cbind(x[i], Recall(x[-i]))) 
     } 
     return(res) 
    } 
} 

> getPerms(letters[1:3]) 
    [,1] [,2] [,3] 
[1,] "a" "b" "c" 
[2,] "a" "c" "b" 
[3,] "b" "a" "c" 
[4,] "b" "c" "a" 
[5,] "c" "a" "b" 
[6,] "c" "b" "a" 

Mam nadzieję, że to pomaga.

Answer 9

Co

pmsa <- function(l) { pms <- function(n) if(n==1) return(list(1)) else unlist(lapply(pms(n-1),function(v) lapply(0:(n-1),function(k) append(v,n,k))),recursive = F) lapply(pms(length(l)),function(.) l[.]) }

Daje listę. Następnie

pmsa(letters[1:3])