Конкретный порядок в R

Question

Я делаю все возможные комбинации для конкретного ввода, но его также нужно заказывать в соответствии с порядком ввода. Так как комбинации разных размеров, им бороться с ответами ранее вывешенные ..

Я хотел бы знать, если это возможно ..

Вход:

D N A 3 

Это означает, что мне нужно для вывода это во всех комбинациях до 3-х символьных строк:

D 
DD 
DDD 
DDN 
DDA 
DND 
DNA 
. 
. 

Который в основном порядке возрастания, если мы рассмотрим D<N<A

Пока мой результат выглядит следующим образом:

A 
AA 
AAA 
AAD 
AAN 
AD 
ADA 
ADD 
ADN 
AN 
. 
. 

Я попытался преобразования входа в качестве множителя с («D», «N», «А») и сортирует мой выход, но потом исчезает любая строка размером более 1 символа.

Любое понимание?

Answer 1

Вот один из возможных решений:

generateCombs <- function(x, n){ 
    if (n == 1) return(x[1]) # Base case 
    # Create a grid with all possible permutations of 0:n. 0 == "", and 1:n correspond to elements of x 
    permutations = expand.grid(replicate(n, 0:n, simplify = F)) 
    # Order permutations 
    orderedPermutations = permutations[do.call(order, as.list(permutations)),] 
    # Map permutations now such that 0 == "", and 1:n correspond to elements of x 
    mappedPermutations = sapply(orderedPermutations, function(y) c("", x)[y + 1]) 
    # Collapse each row into a single string 
    collapsedPermutations = apply(mappedPermutations, 1, function(x) paste0(x, collapse = "")) 
    # Due to the 0's, there will be duplicates. We remove the duplicates in reverse order 
    collapsedPermutations = rev(unique(rev(collapsedPermutations)))[-1] # -1 removes blank 
    # Return as data frame 
    return (as.data.frame(collapsedPermutations)) 
} 

x = c("D", "N", "A") 
n = 3 
generateCombs(x, n) 

Выход:

collapsedPermutations 
1      D 
2      DD 
3     DDD 
4     DDN 
5     DDA 
6      DN 
7     DND 
8     DNN 
9     DNA 
10     DA 
11     DAD 
... 

Answer 2

Решение, использующее случайную библиотеку, которую я только что нашел (так что я могу использовать ее неправильно) под названием iterpc.

Сгенерировать все комбинации, разделить элементы, отсортировать, а затем взломать строку.

ordered_combn = function(elems) { 
    require(data.table) 
    require(iterpc) 

    I = lapply(seq_along(elems), function(i) iterpc::iterpc(table(elems), i, replace=TRUE, ordered=TRUE)) 
    I = lapply(I, iterpc::getall) 
    I = lapply(I, as.data.table) 

    dt = rbindlist(I, fill = TRUE) 
    dt[is.na(dt)] = "" 

    cols = paste0("V", 1:length(elems)) 
    dt[, (cols) := lapply(.SD, factor, levels = c("", elems)), .SDcols = cols] 

    setkey(dt) 
    dt[, ID := 1:.N] 
    dt[, (cols) := lapply(.SD, as.character), .SDcols = cols] 
    dt[, ord := paste0(.SD, collapse = ""), ID, .SDcols = cols] 

    # return dt[, ord] as an ordered factor for neatness 
    dt 
} 

elems = c("D", "N", "A") 
combs = ordered_combn(elems) 
combs 

Выход

V1 V2 V3 ID ord 
1: D  1 D 
2: D D  2 DD 
3: D D D 3 DDD 
4: D D N 4 DDN 
5: D D A 5 DDA 
6: D N  6 DN 
7: D N D 7 DND 
8: D N N 8 DNN 
...