Je me demandais s'il existe un package R qui pourrait m'aider à obtenir toutes les combinaisons possibles de fusion. En d'autres termes, j'ai un ensemble de (1,2,3,4,5,6,7,8,9,10) et je voudrais obtenir un ensemble de 5 sous-ensembles, par exemple (1,2,3 , 4,5,6), (7), (8), (9), (10) ou (2,3,4,5,6), (1,7), (8), (9), (10) ou (3,4,6) (1,5) (2,7) (9,10) (8) ... etc J'ai réussi à coder un exemple de test mais c'est très lent:

library(partitions)
set = seq(1,10)
possibleCombinations = restrictedparts(10,5,include.zero = F)
fusionCombinations(set,possibleCombinations[,1],1,list())

fusionCombinations= function(set,setSize,i,prefix){
       o=combn(predicted,setSize[i])
       for(t in seq(1,ncol(o))){
        prefixtemp = prefix
        remaining = setdiff(predicted,o[,t])
        if(i+1<=length(setSize)){
          if(setSize[i+1]>1){
            prefixtemp=append(prefixtemp,list(o[,t]))
                result=append(result,fusionCombinations(remaining,setSize,i+1,prefixtemp))
          }else{
            prefixtemp=prefix
            prefixtemp=append(prefixtemp,list(o[,t]))
            prefixtemp=apply(t(remaining),1,append,prefixtemp)
            result=append(result,list(prefixtemp))
          }
        }
      }
      return(result)
    }

Des idées?

2
wymeka 28 déc. 2015 à 14:53

3 réponses

Meilleure réponse

Mon idée est d'utiliser setparts et split:

library(partitions)

f <- function(n,m)
{
  apply( setparts(restrictedparts(n,m,include.zero=FALSE)),
         2,
         function(k){split(1:n,k)})
}

Exemples:

> X <- f(4,3)
> X
[[1]]
[[1]]$`1`
[1] 1 4

[[1]]$`2`
[1] 2

[[1]]$`3`
[1] 3


[[2]]
[[2]]$`1`
[1] 1 2

[[2]]$`2`
[1] 3

[[2]]$`3`
[1] 4


[[3]]
[[3]]$`1`
[1] 1 3

[[3]]$`2`
[1] 2

[[3]]$`3`
[1] 4


[[4]]
[[4]]$`1`
[1] 2 4

[[4]]$`2`
[1] 1

[[4]]$`3`
[1] 3


[[5]]
[[5]]$`1`
[1] 2 3

[[5]]$`2`
[1] 1

[[5]]$`3`
[1] 4


[[6]]
[[6]]$`1`
[1] 3 4

[[6]]$`2`
[1] 1

[[6]]$`3`
[1] 2


> for ( i in 1:length(X) ) { prettyPrint(X[[i]]) }
[1] "(1, 4)( 2 )( 3 )"
[1] "( 1:2 )( 3 )( 4 )"
[1] "(1, 3)( 2 )( 4 )"
[1] "(2, 4)( 1 )( 3 )"
[1] "( 2:3 )( 1 )( 4 )"
[1] "( 3:4 )( 1 )( 2 )"
> 

.

> X <- f(5,2)
> X
[[1]]
[[1]]$`1`
[1] 1 2 4 5

[[1]]$`2`
[1] 3


[[2]]
[[2]]$`1`
[1] 1 2 3 5

[[2]]$`2`
[1] 4


[[3]]
[[3]]$`1`
[1] 1 2 3 4

[[3]]$`2`
[1] 5


[[4]]
[[4]]$`1`
[1] 1 3 4 5

[[4]]$`2`
[1] 2


[[5]]
[[5]]$`1`
[1] 2 3 4 5

[[5]]$`2`
[1] 1


[[6]]
[[6]]$`1`
[1] 1 2 5

[[6]]$`2`
[1] 3 4


[[7]]
[[7]]$`1`
[1] 1 2 4

[[7]]$`2`
[1] 3 5


[[8]]
[[8]]$`1`
[1] 1 2 3

[[8]]$`2`
[1] 4 5


[[9]]
[[9]]$`1`
[1] 1 3 5

[[9]]$`2`
[1] 2 4


[[10]]
[[10]]$`1`
[1] 1 3 4

[[10]]$`2`
[1] 2 5


[[11]]
[[11]]$`1`
[1] 1 4 5

[[11]]$`2`
[1] 2 3


[[12]]
[[12]]$`1`
[1] 2 3 5

[[12]]$`2`
[1] 1 4


[[13]]
[[13]]$`1`
[1] 2 3 4

[[13]]$`2`
[1] 1 5


[[14]]
[[14]]$`1`
[1] 2 4 5

[[14]]$`2`
[1] 1 3


[[15]]
[[15]]$`1`
[1] 3 4 5

[[15]]$`2`
[1] 1 2


> for ( i in 1:length(X) ) { prettyPrint(X[[i]]) }
[1] "(1, 2, 4, 5)( 3 )"
[1] "(1, 2, 3, 5)( 4 )"
[1] "( 1:4 )( 5 )"
[1] "(1, 3, 4, 5)( 2 )"
[1] "( 2:5 )( 1 )"
[1] "(1, 2, 5)( 3:4 )"
[1] "(1, 2, 4)(3, 5)"
[1] "( 1:3 )( 4:5 )"
[1] "(1, 3, 5)(2, 4)"
[1] "(1, 3, 4)(2, 5)"
[1] "(1, 4, 5)( 2:3 )"
[1] "(2, 3, 5)(1, 4)"
[1] "( 2:4 )(1, 5)"
[1] "(2, 4, 5)(1, 3)"
[1] "( 3:5 )( 1:2 )"
> 

La fonction prettyPrint:

prettyPrint <- function(x)
{
  s <- ""

  for ( i in 1:length(x) )
  {
    p <- as.character(x[i])

    if ((nchar(p)==1) || (length(grep(":",p)>0)) )
    { s <- paste0(s,"( ",p," )")} else
    { s <- paste0(s,substr(p,2,nchar(p))) }

  }

  print(s)
}

.

1
mra68 28 déc. 2015 à 16:35

Cette fonction prend le vecteur et le nombre d'échantillons en entrée, puis trouve nSets-1 coupes aléatoires (forçant le dernier au dernier élément du vecteur), puis imprime séquentiellement les sous-ensembles du vecteur.

subsets <- function(vector, nSets) {
    cuts <- sample(1:(length(vector)-1), nSets-1, replace = F)
    cuts <- c(0,sort(cuts),length(vector))
    for (i in 1:nSets) {
        print(vector[(cuts[i]+1):cuts[i+1]])
    }
}

Il peut également être utilisé avec des vecteurs non numériques.

1
Matteo Felici 28 déc. 2015 à 13:05

Cette fonction ci-dessous est basée sur une méthode publiée par Petr Savicky le 20 juillet 2012 sur R-help [lien].

allcombs <- function(num, from=0, to=num) {
    m <- as.matrix(expand.grid(rep(list(0:1), times = num)))
    n.items <- rowSums(m)
    m[n.items >= from & n.items <= to, ]
}

Dans votre exemple, vous utiliseriez l'instruction

allcombs(10, from=1, to=5)

Pour obtenir les 637 sous-ensembles possibles de taille 1 à 5. La valeur renvoyée est une matrice avec des lignes correspondant à chaque combinaison possible et des colonnes correspondant au numéro d'article.

0
Jean V. Adams 28 déc. 2015 à 14:45