La combinatoria es un aspecto importante del análisis de datos y las estadísticas. Se utiliza para resolver muchos problemas basados en aptitudes y de la vida real. Mientras que las permutaciones tienen en cuenta el orden, las combinaciones son independientes de él. Por lo tanto, la permutación se considera una combinación ordenada. El lenguaje R nos permite la capacidad de invocar muchos paquetes para calcular combinaciones y permutaciones.
Método 1: paquete combinado
El paquete Combinat en el lenguaje de programación R se puede utilizar para calcular permutaciones y combinaciones de números. Proporciona rutinas y métodos para realizar combinatoria.
El método combn() en lenguaje R perteneciente a este paquete se usa para generar todas las combinaciones de los elementos de x tomados m a la vez. Si x es un entero positivo, devuelve todas las combinaciones de los elementos de seq(x) tomadas m a la vez.
Sintaxis:
combn(x, m, fun=NULL, simplificar=VERDADERO, …)
Parámetros:
- x – fuente vectorial para combinaciones
- m – número de elementos a tomar
- fun – función que se aplicará a cada combinación (puede ser nula)
- simplificar: lógico, si es FALSO, devuelve una lista; de lo contrario, devuelve un vector o una array
Ejemplo 1:
R
# using required libraries
library(combinat)
# generating combinations of the
# alphabets taking 2 at a time
print ("Combination of letters two at a time")
combn(letters[1:4], 2)
Producción
[1] "Combination of letters two at a time"
> combn(letters[1:4], 2)
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] "a" "a" "a" "b" "b" "c"
[2,] "b" "c" "d" "c" "d" "d"
Ejemplo 2:
R
# using required libraries
library(combinat)
# generating combinations of the
# alphabets taking 2 at a time
print ("Combination where x=m")
# selecting 8 items out of 8
combn(8,8)
Producción
[1] "Combination where x=m" > #selecting 8 items out of 8 > combn(8,8) [1] 1 2 3 4 5 6 7 8
El siguiente código ilustra el método donde m=1, es decir, el número de elementos elegidos es equivalente a 1. El número de formas de realizar esta operación es equivalente al número total de elementos, ya que cada elemento se puede seleccionar una vez.
Ejemplo 3:
R
# using required libraries
library(combinat)
# generating combinations of
# the alphabets taking 2 at a time
print ("Combination where m=1")
# selecting 1 items out of 10
combn(10,1)
Producción
[1] “Combinación donde m=1”
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,] 1 2 3 4 5 6 7 8 9 10
El método combn() también proporciona un recuento del número de combinaciones que se generarán como salida. Dado que la salida se obtiene en forma de array, el resultado final es el número de columnas de la array, dado por ncol(res), donde res es el resultado de la aplicación del método combn().
Ejemplo 4:
R
# using required libraries
library(combinat)
# generating combinations of the
# alphabets taking 2 at a time
print ("Combination of letters two at a time")
res <- combn(letters[1:4], 2)
# calculate number of columns in
# the result
print ("Number of combinations : ")
print (ncol(res))
Producción
[1] "Number of combinations : " > print (ncol(res)) [1] 6
El método permn() en R genera todas las permutaciones de los elementos de x. Si x es un entero positivo, devuelve todas las permutaciones de los elementos de seq(x). La permutación del número 0 es 1.
Sintaxis:
permanente(x, divertido=NULL, …)
Parámetros:
- x – fuente vectorial para combinaciones
- fun – función que se aplicará a cada permutación (puede ser nula)
Ejemplo 1:
R
# using required libraries
library(combinat)
# generating permutations
# of the numbers 3
print ("Permutations of 3")
permn(3)
Producción
[1] "Permutations of 3" [[1]] [1] 1 2 3 [[2]] [1] 1 3 2 [[3]] [1] 3 1 2 [[4]] [1] 3 2 1 [[5]] [1] 2 3 1 [[6]] [1] 2 1 3
También podemos calcular las permutaciones de un vector o una lista.
Ejemplo 2:
R
# using required libraries
library(combinat)
# declaring a list
x <- c('red', 'blue', 'green', 'violet')
print ("Permutations of vector x")
permn(x)
Producción:
[1] "Permutations of vector x" > permn(x) [[1]] [1] "red" "blue" "green" "violet" [[2]] [1] "red" "blue" "violet" "green" [[3]] [1] "red" "violet" "blue" "green" [[4]] [1] "violet" "red" "blue" "green" [[5]] [1] "violet" "red" "green" "blue" [[6]] [1] "red" "violet" "green" "blue" [[7]] [1] "red" "green" "violet" "blue" [[8]] [1] "red" "green" "blue" "violet" [[9]] [1] "green" "red" "blue" "violet" [[10]] [1] "green" "red" "violet" "blue" [[11]] [1] "green" "violet" "red" "blue" [[12]] [1] "violet" "green" "red" "blue" [[13]] [1] "violet" "green" "blue" "red" [[14]] [1] "green" "violet" "blue" "red" [[15]] [1] "green" "blue" "violet" "red" [[16]] [1] "green" "blue" "red" "violet" [[17]] [1] "blue" "green" "red" "violet" [[18]] [1] "blue" "green" "violet" "red" [[19]] [1] "blue" "violet" "green" "red" [[20]] [1] "violet" "blue" "green" "red" [[21]] [1] "violet" "blue" "red" "green" [[22]] [1] "blue" "violet" "red" "green" [[23]] [1] "blue" "red" "violet" "green" [[24]] [1] "blue" "red" "green" "violet"
Similar al método combn(), el número de permutaciones también se puede determinar usando el método length() sobre el vector de salida generado por el método permn().
Ejemplo 3:
R
# using required libraries
library(combinat)
# declaring a list
x <- c('red', 'blue', 'green', 'violet')
print ("Permutations of vector x")
res <- permn(x)
print ("Number of possible permutations : ")
print (length(res))
Producción
[1] “Número de permutaciones posibles:”
> imprimir (longitud(res))
[1] 24
Método 2: paquete gtools
El uso del paquete gtools en el lenguaje de programación R también se puede usar para calcular fácilmente las permutaciones y combinaciones tanto sin como con repetición. La combinatoria se puede llevar a cabo fácilmente usando el paquete gtools en R.
El método permutations() en R se puede usar para calcular fácilmente las permutaciones con y sin reemplazo. Devuelve un marco de datos o una array de las posibles permutaciones formadas al mezclar los elementos del vector especificado sujeto a las restricciones. El número de tales permutaciones posibles se puede capturar utilizando el método nrow(), que devuelve el número de filas en el marco de datos de salida obtenido.
Sintaxis:
permutaciones(n, r, vec, repeticiones.permitido=F)
Parámetros:
- n-no. de objetos para elegir
- r- no. de objetos a elegir
- vec – el vector atómico o array para barajar
- repite.permitido – Por defecto: falso. Si es verdadero, las permutaciones se generan con repetición permitida
Devolver :
Un marco de datos o array con permutaciones plausibles. El número de filas en el marco de datos es equivalente al valor de r.
Ejemplo 1:
R
library(gtools)
# describing the input vector
vec<- LETTERS[4:7]
# getting permutations on choose 2
# letters out of 4 letters without
# replacement
res <- permutations(n=4,r=2,v=vec)
print ("Permutations without replacement")
print (res)
print ("Number of permutations without replacement")
print (nrow(res))
# calculating permutations with replacement
res1 <- permutations(n=4,r=2,v=vec,repeats.allowed=T)
print ("Permutations with replacement")
print (res1)
print ("Number of permutations with replacement")
print (nrow(res1))
Producción
[1] "Permutations without replacement"
[,1] [,2]
[1,] "D" "E"
[2,] "D" "F"
[3,] "D" "G"
[4,] "E" "D"
[5,] "E" "F"
[6,] "E" "G"
[7,] "F" "D"
[8,] "F" "E"
[9,] "F" "G"
[10,] "G" "D"
[11,] "G" "E"
[12,] "G" "F"
[1] "Number of permutations without replacement"
[1] 12
[1] "Permutations with replacement"
[,1] [,2]
[1,] "D" "D"
[2,] "D" "E"
[3,] "D" "F"
[4,] "D" "G"
[5,] "E" "D"
[6,] "E" "E"
[7,] "E" "F"
[8,] "E" "G"
[9,] "F" "D"
[10,] "F" "E"
[11,] "F" "F"
[12,] "F" "G"
[13,] "G" "D"
[14,] "G" "E"
[15,] "G" "F"
[16,] "G" "G"
[1] "Number of permutations with replacement"
[1] 16
De manera similar, el método de combinaciones se puede utilizar para generar posibles combinaciones a partir del vector fuente especificado. Todos los argumentos son similares al método permutations().
Sintaxis:
combinaciones(n, r, vec, repeticiones.permitido=F)
No es obligatorio especificar el vector de entrada.
Ejemplo 2:
R
library(gtools)
# generating combinations of the
# alphabets taking 2 at a time
print ("Combination of five objects taken two at a time")
combinations(5, 2)
Producción
[1] "Combination of five objects taken two at a time"
[,1] [,2]
[1,] 1 2
[2,] 1 3
[3,] 1 4
[4,] 1 5
[5,] 2 3
[6,] 2 4
[7,] 2 5
[8,] 3 4
[9,] 3 5
[10,] 4 5
Ejemplo 3:
R
library(gtools)
vec <- c(1:4)
# generating combinations of the
# digits taking 2 at a time
print ("Combination of four objects taken two at\
a time without repetition")
res<- combinations(n= 4, r = 2, v = vec)
print (res)
print ("Number of combinations without repetition")
print (nrow(res))
print ("Combination of four objects taken two at a \
time with repetition")
res1 <- combinations(n= 4, r = 2, v = vec, repeats.allowed=T)
print (res1)
print ("Number of combinations with repetition")
print (nrow(res1))
Producción
[1] "Combination of four objects taken two at a time without repetition"
[,1] [,2]
[1,] 1 2
[2,] 1 3
[3,] 1 4
[4,] 2 3
[5,] 2 4
[6,] 3 4
[1] "Number of combinations without repetition"
[1] 6
[1] "Combination of four objects taken two at a time with repetition"
[,1] [,2]
[1,] 1 1
[2,] 1 2
[3,] 1 3
[4,] 1 4
[5,] 2 2
[6,] 2 3
[7,] 2 4
[8,] 3 3
[9,] 3 4
[10,] 4 4
[1] "Number of combinations with repetition"
[1] 10