Erstellen Sie Kombinationen und Permutationen von Vektoren in R

1. der Binomialkoeffizient und Kombinationen
2. die Fakultät und Permutationen
3. Kombinationen von Elementen eines Vektors
4. Kombinationen von Elementen vieler Vektoren
5. Permutationen von Elementen eines Vektors
6. Umgang mit nicht eindeutigen Elementen
7. Abschluss

Base R bietet Funktionen, die uns helfen, Binomialkoeffizienten zu berechnen und die Anzahl der Permutationen zu finden. Manchmal möchten wir jedoch alle Kombinationen und Permutationen finden und nicht nur ihre Anzahl erhalten.

In diesem Artikel wird erläutert, wie Sie die Anzahl der Kombinationen und Permutationen erhalten und alle Kombinationen und Permutationen erhalten. Wir werden auch besprechen, was passiert, wenn die Vektoren doppelte Elemente haben.

Beachten Sie, dass diese Funktionen nur für einen begrenzten Wertebereich funktionieren.

der Binomialkoeffizient und Kombinationen

Die Funktion choose(n,k) berechnet den Binomialkoeffizienten. Wir erhalten die Anzahl der Kombinationen von n einzigartigen Gegenständen, die jeweils k ohne Wiederholung genommen werden.

Beispielcode:

# Kombinationen
# Kombinationen von 2 Objekten aus 20 Objekten zählen
wählen(20,2)

# Es funktioniert nicht bei sehr großen Werten
wählen(1030,500)

Ausgang:

> # 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

die Fakultät und Permutationen

Die Funktion factorial(x) gibt uns die Anzahl der Permutationen von x einzigartigen Objekten ohne Wiederholung. Es gibt keine spezielle Funktion in der Basis R zum Zählen der Permutationen von k Objekten aus einer Menge von n Objekten, aber sie kann als Quotient von factorial(n) und factorial(k) berechnet werden.

Beispielcode:

# Permutationen
# Permutationen von 17 unterschiedlichen Objekten
Fakultät(17)

# Es funktioniert nicht bei großen Werten
Fakultät(171)

# Permutationen von 5 Objekten aus 19 unterschiedlichen Objekten
faktoriell(19)/faktoriell(5)

Ausgang:

> # 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

Kombinationen von Elementen eines Vektors

Die Funktion combn(x,m) listet ohne Wiederholung alle Kombinationen von m Objekten auf, die aus x unterschiedlichen Objekten gezogen wurden. Die Spalten sind unterschiedliche Kombinationen.

Beispielcode:

# der Objektvektor
mv1 = c("Tennis", "Badminton", "Fußball", "Leichtathletik", "Schach")
mv1

# Alle Kombinationen von zwei Elementen
combn(mv1,2)

# Alle Kombinationen von drei Elementen
combn(mv1,3)

# Überprüfen Sie seine Eigenschaften
c3 = kombn(mv1,3)
Klasse (c3)
Namen (c3)

Ausgang:

> 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

Die Ausgabe ist ein Array. Es gibt keine Spalten- oder Zeilennamen.

Kombinationen von Elementen vieler Vektoren

Die Funktion expand.grid() ermöglicht es uns, einen Datenrahmen mit allen Kombinationen von Elementen der gegebenen Vektoren zu erstellen. Der Funktion können mehrere Vektoren als Eingabe übergeben werden.

Auch hier müssen die Eingabevektoren unterschiedliche Elemente haben, damit die Funktion die gewünschte Ausgabe liefert.

Beispielcode:

# Erstellen Sie einen neuen Vektor
mv2 = c("Apfel", "Mango", "Karotte")
mv2

# Die Funktion expand.grid() listet alle Kombinationen der Elemente der gegebenen Vektoren auf
# Verwenden Sie vorhandene Vektoren oder erstellen Sie einen Vektor mit C()
ex_df = expand.grid (Sport = mv1, Obst = mv2, Farbe = c ("Blau", "Rot"))
ex_df

Ausgang:

> 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

Wir erhalten einen Datenrahmen, in dem die Spalten den Vektoren entsprechen und die Zeilen Kombinationen der Elemente sind. Die Anzahl der Zeilen ist das Produkt der Anzahl der Elemente in jedem Vektor.

Permutationen von Elementen eines Vektors

Die Funktion permn() aus dem Paket combinat erzeugt Permutationen aller Elemente eines Vektors. Dieses Paket muss möglicherweise installiert werden.

Beispielcode:

# Installieren Sie das Combinat-Paket, falls es nicht verfügbar ist
# Entkommentieren Sie und führen Sie die folgende Zeile zur Installation aus
# install.packages("combinat")

# Laden Sie das Combinat-Paket
Bibliothek (Kombinat)

# Alle Permutationen eines Vektors erstellen
Dauer (mv2)

Ausgang:

> # 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"

Umgang mit nicht eindeutigen Elementen

Mal sehen, was passiert, wenn einige Elemente eines Vektors identisch sind. Wir werden uns die Ausgabe aller drei Funktionen ansehen.

Beispielcode:

# Beispiel für Combn()
# Vektor mit einigen identischen Elementen
mv3 = c("Tennis", "Tennis", "Fußball", "Leichtathletik")
mv3
# Resultierende Kombinationen
c2 = kombn(mv3,2)
c2

# Beispiel für expand.grid()
mv4 = c("Rot", "Blau", "Rot")
zB = expand.grid (Sport = mv3, Farbe = mv4)
z.B

# Beispiel für Permn()
pn = permn(mv4)
Pn

Ausgang:

# 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"

Identische Elemente werden in der combn()-Ausgabe mit anderen Elementen kombiniert. Die Ausgabe von expand.grid() hat identische Zeilen, die identischen Elemente erscheinen in jeder Zeile der Ausgabe von permn(), und einige Zeilen sind auch identisch.

Wenn dies nicht die gewünschte Ausgabe ist, müssen wir eine weitere Datenverarbeitung durchführen. Im Allgemeinen ist es am einfachsten sicherzustellen, dass die von uns verwendeten Vektoren eindeutige Elemente enthalten, und wir können zu diesem Zweck die Funktion unique() verwenden.

Beispielcode:

# Ausgabe nach dem Entfernen von Duplikaten

# Kamm()
c2_u = combn(einzigartig(mv3),2)
c2_u

# expand.grid()
eg_u = expand.grid (Sport = einzigartig (mv3), Farbe = einzigartig (mv4))
zB_u

# Dauer()
pn_u = permn(einzigartig(mv4))
pn_u

Ausgang:

> # 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"

Abschluss

Wenn wir Daten zur Analyse oder Veranschaulichung erstellen müssen, ist die Möglichkeit, alle denkbaren Kombinationen von Elementen in einem Vektor oder mehreren Vektoren zu erstellen, praktisch.

In diesem Artikel haben wir gesehen, wie einfach es ist, Kombinationen und Permutationen von Vektoren in R zu generieren und die Anzahl solcher Kombinationen und Permutationen zu berechnen.

Wir haben uns auch die Wirkung identischer Elemente in Vektoren angesehen und einen Weg gesehen, mit dem Problem umzugehen.