Crear combinaciones y permutaciones de vectores en R

1. el coeficiente binomial y las combinaciones
2. el factorial y las permutaciones
3. Combinaciones de elementos de un vector
4. Combinaciones de Elementos de Muchos Vectores
5. Permutaciones de Elementos de un Vector
6. Tratar con elementos no únicos
7. Conclusión

Base R proporciona funciones para ayudarnos a calcular coeficientes binomiales y encontrar el número de permutaciones. Sin embargo, a veces queremos encontrar todas las combinaciones y permutaciones, no solo obtener su número.

Este artículo discutirá cómo obtener el número de combinaciones y permutaciones y cómo obtener todas las combinaciones y permutaciones. También discutiremos qué sucede cuando los vectores tienen elementos duplicados.

Tenga en cuenta que estas funciones funcionan solo para un rango limitado de valores.

el coeficiente binomial y las combinaciones

La función choose(n,k) calcula el coeficiente binomial. Obtenemos el número de combinaciones de n elementos únicos tomados k a la vez sin repetición.

Código de ejemplo:

# Combinaciones
# Contar combinaciones de 2 objetos de 20 objetos
elegir (20,2)

# No funciona para valores muy grandes
elegir(1030,500)

Producción :

> # Count combinations of 2 objects from 20 objects.
> choose(20,2)
[1] 190

> # It does not work for very large values.
> choose(1030,500)
[1] Inf

el factorial y las permutaciones

La función factorial(x) nos da el número de permutaciones de x objetos únicos sin repetición. No existe una función específica en base R para contar las permutaciones de k objetos de un conjunto de n objetos, pero se puede calcular como el cociente de factorial(n) y factorial(k).

Código de ejemplo:

# permutaciones
# Permutaciones de 17 objetos distintos
factoriales(17)

# No funciona para valores grandes
factoriales(171)

# Permutaciones de 5 objetos de 19 objetos distintos
factorial(19)/factorial(5)

Producción :

> # Permutations of 17 distinct objects.
> factorial(17)
[1] 3.556874e+14

> # It does not work for large values.
> factorial(171)
[1] Inf

> # Permutations of 5 objects from 19 distinct objects.
> factorial(19)/factorial(5)
[1] 1.013709e+15

Combinaciones de elementos de un vector

La función combn(x,m) enumera todas las combinaciones de m objetos extraídos de x objetos distintos sin repetición. Las columnas son diferentes combinaciones.

Código de ejemplo:

# el vector de objetos
mv1 = c("Tenis", "Bádminton", "Fútbol", "Atletismo", "Ajedrez")
mv1

# Todas las combinaciones de dos elementos
peine(mv1,2)

# Todas las combinaciones de tres elementos
combinación (mv1,3)

# Comprobar sus propiedades
c3 = combn(mv1,3)
clase (c3)
nombres (c3)

Producción :

> mv1
[1] "Tennis"    "Badminton" "Football"  "Athletics" "Chess"

> # All combinations of two elements.
> combn(mv1,2)
     [,1]        [,2]       [,3]        [,4]     [,5]        [,6]        [,7]        [,8]        [,9]
[1,] "Tennis"    "Tennis"   "Tennis"    "Tennis" "Badminton" "Badminton" "Badminton" "Football"  "Football"
[2,] "Badminton" "Football" "Athletics" "Chess"  "Football"  "Athletics" "Chess"     "Athletics" "Chess"
     [,10]
[1,] "Athletics"
[2,] "Chess"

> # Check its properties.
> c3 = combn(mv1,3)

> class(c3)
[1] "matrix" "array"

> names(c3)
NULL

La salida es una matriz. No hay nombres de columnas o filas.

Combinaciones de Elementos de Muchos Vectores

La función expand.grid() nos permite crear un marco de datos con todas las combinaciones de elementos de los vectores dados. A la función se le pueden dar varios vectores como entrada.

Nuevamente, los vectores de entrada deben tener elementos distintos para que la función proporcione la salida deseada.

Código de ejemplo:

# Crear un nuevo vector
mv2 = c("Manzana", "Mango", "Zanahoria")
mv2

# la función expand.grid() enumera todas las combinaciones de los elementos de los vectores dados
# Usar vectores existentes o crear un vector usando C()
ex_df = expand.grid(Deporte = mv1, Fruta = mv2, Color = c("Azul", "Rojo"))
ex_df

Producción :

> mv2
[1] "Apple"  "Mango"  "Carrot"

> # The expand.grid() function lists all combinations of the elements of the given vectors.
> # Use existing vectors or create a vector using c().
> ex_df = expand.grid(Sport = mv1, Fruit = mv2, Color = c("Blue", "Red"))
> ex_df
       Sport  Fruit Color
1     Tennis  Apple  Blue
2  Badminton  Apple  Blue
3   Football  Apple  Blue
4  Athletics  Apple  Blue
5      Chess  Apple  Blue
6     Tennis  Mango  Blue
7  Badminton  Mango  Blue
8   Football  Mango  Blue
9  Athletics  Mango  Blue
10     Chess  Mango  Blue
11    Tennis Carrot  Blue
12 Badminton Carrot  Blue
13  Football Carrot  Blue
14 Athletics Carrot  Blue
15     Chess Carrot  Blue
16    Tennis  Apple   Red
17 Badminton  Apple   Red
18  Football  Apple   Red
19 Athletics  Apple   Red
20     Chess  Apple   Red
21    Tennis  Mango   Red
22 Badminton  Mango   Red
23  Football  Mango   Red
24 Athletics  Mango   Red
25     Chess  Mango   Red
26    Tennis Carrot   Red
27 Badminton Carrot   Red
28  Football Carrot   Red
29 Athletics Carrot   Red
30     Chess Carrot   Red

Obtenemos un marco de datos en el que las columnas corresponden a los vectores y las filas son combinaciones de los elementos. El número de filas es el producto del número de elementos en cada vector.

Permutaciones de Elementos de un Vector

La función permn() del paquete combinat crea permutaciones de todos los elementos de un vector. Este paquete puede necesitar ser instalado.

Código de ejemplo:

# Instale el paquete Combinat, si no está disponible
# Descomente y ejecute la siguiente línea para instalar
# install.packages("combinar")

# Cargar el Paquete Combinado
biblioteca (combinar)

# Crear todas las permutaciones de un vector
permanente(mv2)

Producción :

> # Create all permutations of a vector.
> permn(mv2)
[[1]]
[1] "Apple"  "Mango"  "Carrot"

[[2]]
[1] "Apple"  "Carrot" "Mango"

[[3]]
[1] "Carrot" "Apple"  "Mango"

[[4]]
[1] "Carrot" "Mango"  "Apple"

[[5]]
[1] "Mango"  "Carrot" "Apple"

[[6]]
[1] "Mango"  "Apple"  "Carrot"

Tratar con elementos no únicos

Veamos qué sucede si algunos elementos de un vector son idénticos. Veremos la salida de las tres funciones.

Código de ejemplo:

# Ejemplo para Combn()
# Vector con algunos elementos idénticos
mv3 = c("Tenis", "Tenis", "Fútbol", "Atletismo")
mv3
# Combinaciones resultantes
c2 = combn(mv3,2)
c2

# Ejemplo para expandir.grid()
mv4 = c("Rojo", "Azul", "Rojo")
por ejemplo = expandir.grid(Deporte = mv3, Color = mv4)
p.ej

# Ejemplo para Permn()
pn = permanente(mv4)
pn

Producción :

# Example for combn().
> mv3
[1] "Tennis"    "Tennis"    "Football"  "Athletics"
> # Resulting combinations.
> c2 = combn(mv3,2)
> c2
     [,1]     [,2]       [,3]        [,4]       [,5]        [,6]
[1,] "Tennis" "Tennis"   "Tennis"    "Tennis"   "Tennis"    "Football"
[2,] "Tennis" "Football" "Athletics" "Football" "Athletics" "Athletics"

> # Example for expand.grid().
> mv4 = c("Red", "Blue", "Red")
> eg = expand.grid(Sport = mv3, Color = mv4)
> eg
       Sport Color
1     Tennis   Red
2     Tennis   Red
3   Football   Red
4  Athletics   Red
5     Tennis  Blue
6     Tennis  Blue
7   Football  Blue
8  Athletics  Blue
9     Tennis   Red
10    Tennis   Red
11  Football   Red
12 Athletics   Red

> # Example for permn().
> pn = permn(mv4)
> pn
[[1]]
[1] "Red"  "Blue" "Red"

[[2]]
[1] "Red"  "Red"  "Blue"

[[3]]
[1] "Red"  "Red"  "Blue"

[[4]]
[1] "Red"  "Blue" "Red"

[[5]]
[1] "Blue" "Red"  "Red"

[[6]]
[1] "Blue" "Red"  "Red"

Los elementos idénticos se combinan con otros elementos en la salida combn(). La salida de expand.grid() tiene filas idénticas, los elementos idénticos aparecen en cada fila de la salida de permn(), y algunas filas también son idénticas.

Si este no es el resultado que queremos, necesitamos hacer más procesamiento de datos. Generalmente, la opción más fácil es asegurarnos de que los vectores que usamos tengan elementos únicos, y podemos usar la función unique() para este propósito.

Código de ejemplo:

# Salida después de eliminar duplicados

# Combn()
c2_u = combn(único(mv3),2)
c2_u

# expandir.grid()
eg_u = expand.grid(Deporte = único(mv3), Color = único(mv4))
por ejemplo_u

# permanente()
pn_u = permn(único(mv4))
pn_u

Producción :

> # combn()
> c2_u = combn(unique(mv3),2)
> c2_u
     [,1]       [,2]        [,3]
[1,] "Tennis"   "Tennis"    "Football"
[2,] "Football" "Athletics" "Athletics"

> # expand.grid()
> eg_u = expand.grid(Sport = unique(mv3), Color = unique(mv4))
> eg_u
      Sport Color
1    Tennis   Red
2  Football   Red
3 Athletics   Red
4    Tennis  Blue
5  Football  Blue
6 Athletics  Blue

> # permn()
> pn_u = permn(unique(mv4))
> pn_u
[[1]]
[1] "Red"  "Blue"

[[2]]
[1] "Blue" "Red"

Conclusión

Cuando necesitamos crear datos para análisis o ilustración, la capacidad de crear todas las combinaciones imaginables de elementos en un vector o varios vectores resulta útil.

En este artículo, vimos lo fácil que es generar combinaciones y permutaciones de vectores en R y calcular los números de tales combinaciones y permutaciones.

También observamos el efecto de elementos idénticos en vectores y vimos una forma de solucionar el problema.