5
votes

Générez toutes les combinaisons uniques à partir d'un vecteur avec des éléments répétitifs

Cette question a été posée précédemment mais uniquement pour les vecteurs avec des éléments non répétitifs. Je n'ai pas pu trouver une solution simple pour obtenir toutes les combinaisons d'un vecteur avec des éléments répétitifs. Pour illustrer, j'ai énuméré un exemple ci-dessous.

# unique combinations with one element
'red'
'blue'
'green'
# unique combination with two elements
'red', 'blue' # same as 'blue','red'
'red', 'green' 
'red', 'red'
'blue', 'green'
'green', 'green'
# unique combination with three elements
'red', 'blue', 'green'
'red', 'red', 'blue'
'red', 'red', 'green'
'red', 'red', 'red' # This is valid because there are three 'red's
'green', 'green', 'red'
'green', 'green', 'blue'
# more unique combinations with four, five, and six elements

Le vecteur x a 3 éléments répétitifs pour «rouge» et 2 pour «vert». Le résultat attendu pour toutes les combinaisons uniques serait le suivant.

x <- c('red', 'blue', 'green', 'red', 'green', 'red')

r permutation combinations combn

0 commentaires

3 Réponses :

5
votes

Utilisez combn () avec lapply () devrait faire l'affaire.

lapply(cc, function(y)
  y[,!duplicated(apply(y, 2, function(z) paste(sort(z), collapse=".")))]
)

# [[1]]
# [1] "red"   "blue"  "green"

# [[2]]
     # [,1]   [,2]    [,3]  [,4]    [,5]   
# [1,] "red"  "red"   "red" "blue"  "green"
# [2,] "blue" "green" "red" "green" "green"

# [[3]]
     # [,1]    [,2]   [,3]    [,4]    [,5]  [,6]   
# [1,] "red"   "red"  "red"   "red"   "red" "blue" 
# [2,] "blue"  "blue" "green" "green" "red" "green"
# [3,] "green" "red"  "red"   "green" "red" "green"

Toutes les combinaisons uniques

lapply(cc, function(y)
  y[,!duplicated(apply(y, 2, paste, collapse="."))]
)

[[1]]
[1] "red"   "blue"  "green"

[[2]]
     [,1]   [,2]    [,3]  [,4]    [,5]   [,6]    [,7]   
[1,] "red"  "red"   "red" "blue"  "blue" "green" "green"
[2,] "blue" "green" "red" "green" "red"  "red"   "green"

[[3]]
     [,1]    [,2]   [,3]    [,4]    [,5]    [,6]  [,7]    ...
[1,] "red"   "red"  "red"   "red"   "red"   "red" "blue"  ...
[2,] "blue"  "blue" "green" "green" "red"   "red" "green" ...
[3,] "green" "red"  "red"   "green" "green" "red" "red"   ...

Bien qu'à proprement parler, ce ne sont pas toutes des combinaisons uniques, car certaines d'entre elles sont des permutations les unes des autres.

Des combinaisons proprement uniques

x <- c('red', 'blue', 'green', 'red', 'green', 'red')

lapply(1:3, function(y) combn(x, y))

# [[1]]
     # [,1]  [,2]   [,3]    [,4]  [,5]    [,6] 
# [1,] "red" "blue" "green" "red" "green" "red"

# [[2]]
     # [,1]   [,2]    [,3]  [,4]    [,5]  [,6]    ...
# [1,] "red"  "red"   "red" "red"   "red" "blue"  ...
# [2,] "blue" "green" "red" "green" "red" "green" ...

# [[3]]
     # [,1]    [,2]   [,3]    [,4]   [,5]    [,6]    ...
# [1,] "red"   "red"  "red"   "red"  "red"   "red"   ...
# [2,] "blue"  "blue" "blue"  "blue" "green" "green" ...
# [3,] "green" "red"  "green" "red"  "red"   "green" ...

4 commentaires

Ou lapply (1: 3, function (k) matrix (x [combn (i, k)], nrow = k)) . L'OP souhaite également les combinaisons de 1 et de 2. Ensuite, appliquez unique .

@RuiBarradas: Ah, je vois. On dirait que je n'ai pas fait le tour d'index après tout.

Cette solution génère toutes les combinaisons possibles mais pas toutes les combinaisons uniques.

@Jian: Je pense que je l'ai maintenant.

4
votes

library(DescTools)
x <- c('red', 'blue', 'green', 'red', 'green', 'red')

allSets <- lapply(1:length(x), function(i){
      unique(t(apply(CombSet(x,i,repl = F),1,sort)))
    })


#[1]]
#[,1]  [,2]   [,3]    [,4]  [,5]    [,6] 
#[1,] "red" "blue" "green" "red" "green" "red"

##[[2]]
#[,1]    [,2]   
#[1,] "blue"  "red"  
#[2,] "green" "red"  
#[3,] "red"   "red"  
#[4,] "blue"  "green"
#[5,] "green" "green"

#[[3]]
#[,1]    [,2]    [,3]   
#[1,] "blue"  "green" "red"  
#[2,] "blue"  "red"   "red"  
#[3,] "green" "red"   "red"  
#[4,] "green" "green" "red"  
#[5,] "red"   "red"   "red"  
#[6,] "blue"  "green" "green"

#[[4]]
#[,1]    [,2]    [,3]    [,4] 
#[1,] "blue"  "green" "red"   "red"
#[2,] "blue"  "green" "green" "red"
#[3,] "blue"  "red"   "red"   "red"
#[4,] "green" "green" "red"   "red"
#[5,] "green" "red"   "red"   "red"

#[[5]]
#[,1]    [,2]    [,3]    [,4]  [,5] 
#[1,] "blue"  "green" "green" "red" "red"
#[2,] "blue"  "green" "red"   "red" "red"
#[3,] "green" "green" "red"   "red" "red"

#[[6]]
#[,1]   [,2]    [,3]    [,4]  [,5]  [,6] 
#[1,] "blue" "green" "green" "red" "red" "red"

4 commentaires

OP a dit "des combinaisons plus uniques avec quatre, cinq et six éléments" à la fin de la question. J'ai supposé qu'il voulait les six. Est-ce que je comprends mal la question?

En fait, je pense que vous avez raison. Ma faute. Je n'ai pas vu cette dernière phrase. :)

Merci, cette solution fonctionne sauf dans le cas d'un composant [[1]].

Puis-je quand même enregistrer ceci en tant que dataframe ou concaténer chacun d'entre eux dans une colonne?

4
votes

library(RcppAlgos)
comboGeneral(names(tx), m=2, freqs = tx)
#       [,1]    [,2]   
# [1,] "blue"  "green"
# [2,] "blue"  "red"  
# [3,] "green" "green"
# [4,] "green" "red"  
# [5,] "red"   "red"

1 commentaires

Merci, cela fonctionne si vous itérez m 1: 6 dans le comboGeneral. Appréciez votre réponse.