Diese Multiple-Choice-R-Fragen und -Antworten helfen Ihnen, R-Themen besser zu verstehen. Mit diesen über 100 R-MCQs können Sie sich auf Ihre nächste Prüfung oder Ihr nächstes Vorstellungsgespräch vorbereiten.
Scrollen Sie nach unten, um mit der Antwort zu beginnen.
A. lm (x ~ y)
B. Proc Reg; Modell y = x; laufen;
C. lm (y ~ x)
D. Regress y x
A. ytemp & lt;- rnorm (100, 0, 1); Y & lt; -cut (ytemp, breaks = c (-10, -2, -1, 1, 2, 10))
B. Y & lt;- rbinom (100, 5, 0,5)
C. Y & lt;- Probe (rep (c (1: 5), jeweils = 20), Größe = 100)
D. Y & lt;- Probe (C (1, 2, 3, 4, 5), 100, ersetzen = true)
A. für (i in 1: nnn) {& lt; Simulationscode & gt; }
B. für i in 1: nnn: & lt; Simulationscode & gt;
C. für (i - nnn) {& lt; Simulationscode & gt; }
D. für (i = 1, nnn, 1) {& lt; Simulationscode & gt; }
A. Es bedeutet einen Bereich von x bis y.
B. Es bedeutet, dass x und y korreliert sind.
C. Es bedeutet, dass y logisch aus x folgt.
D. Es bedeutet, dass x und y reelle Zahlen sind.
E. Es bedeutet, dass X für diesen Vorgang die Wahrscheinlichkeit von y gilt.
A. 2 10
B. 1 3 5 7 9 9
C. 2 4 6 8 10
D. 2
A. Der Datenvektor wie in H.
B. das gesamte Array als Array
C. die Auswahl aller Nullen
D. der Dimensionsvektor C (3,4,2)
A. [1] 2
B. [1] " Hallo Welt "
C. NULL
D. N / A
E. [1] Hallo Welt
A. a = 1
B. a == 1
C. a & lt; & lt;- 1
D. a & lt;- 1
E. a -& gt; 1
A. 4
B. 3
C. WAHR
D. FALSCH
E. 1
A. import.csv (" x.csv ")
B. Import (" X.CSV ")
C. read.csv (" x.csv ")
D. Read (" X.csv ")
A. sortieren (x, abnehmen = t)
B. sortieren (x)
C. Bestellung (x)
D. X [sortieren (x)]
A. Fassen Sie x zusammen
B. Zusammenfassung (x)
C. Proc Inhalt x;
D. Fassen Sie (x) zusammen
A. Diagramm (x)
B. hist (x)
C. Diagramm x
D. Plot.hist (x)
A. x $ 1
B. x [0]
C. X.1
D. x [1]
E. x $ 0
A. 0
B. -2
C. N / A
D. 2
A. Objekte
B. Modus
C. Veranstaltungen
D. Befehle
A. Readdata
B. Scan
C. read.csv
D. read.table
A. AS.TS
B. is.ts
C. ts
D. if.ts
A. Konvertieren Sie die Daten in Ganzzahl
B. Umwandeln Sie die Daten in Vektor
C. Umwandeln Sie die Daten in Matrizen
D. Konvertieren Sie die Daten in das Zeitreihenobjekt
A. N / A
B. Nan
C. #WERT!
D. [eine leere Zelle]
E. NULL
A. Überraschungen des Wortes des Wortes " Hallo "
B. Richtig rechtfertigt das Wort " Hallo "
C. Druckt das Wort " Hallo " in kühner Schrift
D. Erhöht die Größe des Wortes " Hallo " Mit dem Faktor 2
A. xlim = c (0, 1)
B. xlimit = " 0, 1 "
C. xlim = " 0, 1 "
D. xlab = c (0, 1)
A. " Der Wert von x beträgt 2 und der Wert von y [x] ist C (1: 3) [2] "
B. " Der Wert von x beträgt 2 und der Wert von y [x] beträgt 4 "
C. " Der Wert von x beträgt 2 und der Wert von y [x] beträgt 2 "
D. " Der Wert von x beträgt 2 und der Wert von y [x] beträgt 6 "
A. 1 4
B. 1 4 7
C. 1 3 5
D. 1 2 3 4 5
A. Linien (0, 1)
B. lty = c (0, 1)
C. Abline (0, 1)
D. glatt.spling (0, 1)
A. [1] Falsch falsch falsch wahr
B. [1] Falsch
C. Wirft einen Fehler aus.
D. [1] wahr
E. [1] na na na true
A. [1] wahr [1] Falsch
B. [1] wahr [1] wahr
C. [1] Falsch [1] wahr
D. NULL
E. [1] nan [1] na
A. 3
B. 1 2 3 4
C. 1 2 2 2 3 3 3
D. 1 2 3
A. read.table ()
B. last.table ()
C. Belastung()
D. lesen()
A. tabellarisch (x, y)
B. Tabelle (y ~ x)
C. Tabelle (x*y)
D. Tabelle (x, y)
A. N / A
B. WAHR
C. FALSCH
D. -Inf
A. 1 2 1 2
B. 1 1
C. 1 1 3 3
D. 1 3 1 3
A. NULL
B. 2
C. 1.5
D. N / A
A. 5 2
B. 10
C. 2 5
D. 20
A. lm (y ~ x1: x3 + x1: x2)
B. lm (y ~ x1 + x2 + x3 + x1*x2)
C. LM (y ~ x1 + x2 + x3 + Interaktion (x1, x2))
D. lm (y ~ x1: x2 + x3)
A. Zeitreihenanalyse
B. Verallgemeinerte lineare Modelle
C. Lineare Mixed Effects -Modelle
D. Analyse der Varianzmodelle
E. Clustering -Tools
A. x == y
B. x! = y
C. x =! y
D. x = ~ y
E. x %% y
A. Mittelwert (x [1: Länge (x [, 1]),], na.rm = t)
B. anwenden (x, 1, Mittelwert, na.rm = t)
C. durch (x, 1, Mittelwert, na.rm = t)
D. anwenden (x, 1, Mittelwert)
A. Matrix (x, y, z, nrow = 3)
B. Matrix (cbind (x, y, z), nrow = 3)
C. Matrix (rbind (x, y, z), nrow = 3)
D. Matrix (rbind (x, y, z), ncol = 3)
A. merge (x, y, by = " id ")
B. merge (x, y, by = " id " alle = true)
C. merge (x, y, sort = " id ", alle = true)
D. kombinieren (x, y, by = " id ")
A. Matrix
B. Vektor
C. Data.Frame
D. Liste
E. Array
A. sort (data.frame (x = c (10, -3, 4)))
B. sortieren (Liste (10, -3, 4))
C. sortieren (c (10, -3, 4))
D. sortieren (10, -3, 4)
A. lm (y ~ x) $ residuales
B. lm (y ~ x) $ resiual - lm (y ~ x) $ angebracht.Values
C. Residuen (LM (y ~ x))
D. Y - lm (y - x) $ angebracht.werte
A. Gleich dem Ergebnis von: & gt; c (Mittelwert (x [, 1]), Mittelwert (x [, 2]), Mittelwert (x [, 3]))
B. Gleich dem Ergebnis von: & gt; c (Mittelwert (x [1,]), Mittelwert (x [2,]), Mittelwert (x [3,]), Mittelwert (x [4,]))
C. Gleich dem Ergebnis von: & gt; c (Mittelwert (x [, 1]), Mittelwert (x [, 2]), Mittelwert (x [, 3]), Mittelwert (x [, 4])
D. Gleich dem Ergebnis von: & gt; c (Mittelwert (x [1,]), Mittelwert (x [2,]), Mittelwert (x [3,]))
A. X [c (3,7)] & lt;- x [c (7,3)]
B. ersetzen (x, c (3, 7), c (7,3)
C. X [7] & lt;- x [3]; X [3] & lt;- x [7]
D. X [3] & lt;- x [7]; X [7] & lt;- x [3]
A. [1] null
B. [1] wahr
C. [1] -inf
D. [1] Nan
E. [1] Falsch
A. Eine Fehlermeldung
B. N / A
C. Ein Korrelationskoeffizient
D. R quadriert
A. Streuung (x ~ y)
B. Diagramm (Data.Frame (y ~ x))
C. Diagramm (x ~ y)
D. xyplot (x, y)
A. WAHR
B. 0
C. FALSCH
D. 110
A. Der Dimensionsvektor C (3,4,2)
B. das gesamte Array als Array
C. die Auswahl aller Nullen
D. Der Datenvektor wie in H.
A. [1] 1 1 1 2 2 2
B. [1] 1 2 1 2 1 2
C. [1] " 1: 2 " " 1: 2 " " 1: 2 "
D. [1] 3 6
A. Umschließung (x, 1, 2)
B. ! Psych [Rescale (X, C (1, 2))]
C. Plotrix :: Rescale (x, c (1, 2))
D. Plotrix.rescale (x, c (1, 2))
E. Plotrix (Rescale (X, C (1, 2)))
A. [1] " O " [2] " M " [3] " G "
B. [1] " OMG "
C. [1] " omg "
D. [1] " O M G "
A. von
B. Länge
C. aus
D. mal
A. Colmeans (DF)
B. für (i in 1: nrow (df)) drucken (mittler (as.numeric (df [i,])))
C. bewerben (df, 2, Mittelwert)
D. Sapply (1: ncol (df), Funktion (col) Mittelwert (df [, col]))
E. für (i in 1: ncol (df)) drucken (Mean (df [, i]))
A. Der Zeilenvektor [Falsch falsches falsch]
B. Der Zeilenvektor [1 2 3]
C. der Zeilenvektor [2 3 4]
D. Der Zeilenvektor [True True wahr]
A. S4
B. S3
C. R5 (Referenzklasse)
A. 2
B. 3 4
C. 2 4 6 8 10
D. 4
A. Regress y x, kein Interzept
B. lm (y ~ x, intercept = f)
C. lm (y ~ -1 + x)
D. Proc Reg; Modell y = x; intercept = f; laufen;
A. Wahre wahre na
B. N / A
C. WAHR
D. Wahres wahres Falsch
E. FALSCH
A. X & lt;- rund (y, 0)
B. X & lt;- as.numeric (y)
C. X & lt;- IS.Integer (y)
D. X & lt;- as.ineger (y)
A. Ein Array, das die Zahlen 1 bis 30 enthält
B. Ein 2-Reis-Array, ein 3-Reihen-Array und ein 5-Reihen-Array, das jeweils die Nummern 1 bis 30 enthält
C. Zwei Matrizen, eine mit 3 Spalten, der andere mit 5
D. Fünf Matrizen mit jeweils 2 Zeilen und 3 Spalten
A. Der Zeilenvektor [" x1 " " Y1 " " x2 " " Y2 " " x3 " " Y3 " " x4 " " Y4 " " x5 " " Y5 " " x6 " " Y6 " " x7 " " Y7 " " x8 " " Y8 " " x9 " " Y9 " "
B. Der Zeilenvektor [" x1 " " Y2 " " x3 " " Y4 " " x5 " " Y6 " " x7 " " Y8 " " x9 " " Y10 "]
C. Der Zeilenvektor [" Y1 " " Y2 " " Y3 " " Y4 " " Y5 " " Y6 " " Y7 " " Y8 " " Y9 " " Y10 "]
D. Der Zeilenvektor [" x1 " " x2 " " x3 " " x4 " " x5 " " x6 " " x7 " " x8 " " x9 " " x10 "]
A. %%
B. %/%
C. /
D. %*%
E. Mod
A. [, 1] [, 2] [1,] 3 2
B. [, 1] [1,] 3 [2,] 2
C. [, 1] [1,] 2 [2,] 1
D. [, 1] [, 2] [1,] 2 3
A. df [, Mean (x), durch = Faktor]
B. für (f in den Ebenen (df $ faktor)) drucken (Mittelwert (Subset (df, faktor == f) $ x)).
C. Sapply (Ebenen (df $ Faktor), Funktion (f) Mittelwert (Teilmenge (df, faktor == f) $ x))
D. ddply (df,. (faktor), zusammenfassen, Mittelwert (x))
A. 1 3
B. 1 2
C. 1 4
D. 2 4
A. X [[3]] [4]
B. X [4]] [3]]
C. X [3, 4]]
D. X [3, 4]
E. X [3] [4]
A. 2
B. 1
C. Eine 2x2 -Matrix mit allen Zellen gleich 1
D. 4
A. ! ist.na (x)
B. ! All (ist.na (x))
C. alle (is.na (x))
D. All (! ist.na (x))
A. Matrizen können transponiert werden; Arrays können nicht
B. Arrays können mehrere verschiedene Objektklassen enthalten
C. Nur Arrays unterstützen unendliche Werte
D. Sie sind identisch; Beide sind zur einfachen Anwendung enthalten
E. Arrays unterstützen mehr als 2 Dimensionen
A. Es werden keine Werte angezeigt
B. 0, 2
C. 0, 10
D. 0, 1
A. 5
B. " 5 "
C. 5.457
D. 5.5
A. Modus (y)
B. sortieren (y, abnehmen = t) [1]
C. Namen (Tabelle (y)) [Tabelle (y) == max (Tabelle (y))]
D. sortieren (Tabelle (y), abnehmen = t)
A. macht Z zu einer Reihe aller Nullen
B. würde einen Fehler über die Nichtübereinstimmung der Länge signalisieren
C. werden von Anfang an wieder recycelt, um es bis zu Größe 24 wieder gut zu machen
D. sind genauso wie die Länge von H
A. (All dies ist korrekt)
B. Zuordnung (" x ", C (10.4, 5,6, 3,1, 6,4, 21,7))
C. C (10.4, 5,6, 3,1, 6,4, 21,7) -& Gt; X
D. x & lt;- c (10.4, 5,6, 3,1, 6,4, 21,7)
A. Datum (x, " Tag ")
B. strsplit (x, "-")
C. Split (x, "-") [3]
D. Substr (x, 10, 11)
A. t.test (a, b, gepaart = true)
B. Mittelwert (a) == Mittelwert (b)
C. Ks.test (a, b)
D. t.test (a, b, gepaart = false)
A. Der Dimensionsvektor C (3,4,2)
B. das gesamte Array als Array
C. Der Datenvektor wie in H
D. die Auswahl aller Nullen
A. X [" B ", " C " ]
B. X [, c (2, 4)]
C. X [c (" B ", " C ")]
D. X [2, 4]
A. ??Parzelle
B. ? " Plot "
C. Hilfe (" Plot ")
D. Hilfe (Grundstück)
E. ?Parzelle
A. tabellarisch (x, y, na.omit = f)
B. Tabelle (x, y, na.include = t)
C. Tabelle (x, y, usena = " immer ")
D. Tabelle (x*y, na.rm = f)
A. Y [was (x & lt; 100)]
B. Y [, was (x & lt; 100)]
C. Y [x & lt; = 100]
D. Y [wo (x & lt; 100),]
A. & gt; ab & lt;- a * b
B. & gt; AB & lt;- äußere (a, b, %o %)
C. & gt; AB & lt;- äußere (a, b, *)
D. & gt; AB & lt;- A % o % b
A. Komplex
B. (All dies ist gültig)
C. logisch
D. doppelt
E. ganze Zahl
A. Der Ausdruck wird von rechts nach links gescannt
B. Alle kurzen Vektoroperanden werden erweitert, indem sie ihre Werte recyceln, bis sie der Größe anderer Operanden entsprechen
C. Jeder Vektoroperand kürzer als eine Matrix- oder Array -Operand generiert einen Fehler
D. Solange nur kurze Vektoren und Arrays auftreten, können die Arrays das unterschiedliche Dim -Attribut oder einen Fehlerergebnis haben
A. Jarqueberatest (Rest (x))
B. BGTest (x)
C. Heteroscedastis (x)
D. gqTest (x)
A. x & lt; -Seq (1,5, by = 2); s & lt; -Rep (x, mal = 3); sortieren (en)
B. x & lt; -Seq (1,5, by = 2); rep (x, mal = 3)
C. x & lt; -Seq (1,5, by = 2); rep (x, jeweils = 3)
D. x & lt; -C (1 1 1 3 3 3 5 5 5)
A. Autokorrelationstest (x)
B. GQTEST (x)
C. Jarqueberatest (Rest (x))
D. BGTest (x)
A. Es zeichnet 1 Zahl aus 40 verschiedenen Normalverteilungen
B. Es zeichnet 40 Pseudo-Random-Zahlen
C. Es zeichnet 40 Zufallszahlen aus einer Normalverteilung mit Mittelwert von 1
D. Es zeichnet 40 Zufallszahlen aus einer Normalverteilung mit Standardabweichung von 4
A. Der Zeilenvektor [1 2 3 Falsch]
B. der Reihenvektor [1 2 3 na]
C. Der Zeilenvektor [wahr wahrer wahrer Falsch]
D. Der Zeilenvektor [falsch falsches falsches wahres]
A. Eine Matrix kann nur numerische Werte enthalten.
B. Eine Matrix darf nicht einzigartig sein.
C. Ein Datenrahmen kann Variablen enthalten, die unterschiedliche Modi haben.
D. Ein Datenrahmen kann Variablen unterschiedlicher Längen enthalten.
A. 1
B. 365
C. 4
D. 12
A. Entfernen()
B. Löschen()
C. Ablösen()
D. Löschen()
A. Höhe (Länge (Höhe))
B. Höhe [Länge (Höhe)]
C. Höhe [Länge [Höhe]]
D. Höhe (5)
A. Var_a!
B. \ _Vara
C. .2var_a
D. Var2_a
A. Eine Matrix hat zwei Dimensionen, während ein Array drei oder mehr Dimensionen haben kann.
B. Ein Array ist ein Subtyp des Datenrahmens, während eine Matrix ein separater Typ ist.
C. Eine Matrix kann Spalten unterschiedlicher Längen haben, aber die Spalten eines Arrays müssen alle gleiche Länge haben.
D. Eine Matrix kann nur numerische Werte enthalten, während ein Array verschiedene Arten von Werten mischen kann.
A. Typ
B. Länge
C. Attribute
D. Skalar
A. BOF (Pizza, 5)
B. Erstens (Pizza, 5)
C. Top (Pizza, 5)
D. Kopf (Pizza, 5)
A. Konsole (-25)
B. Konsole (Reverse = True)
C. Geschichte()
D. Geschichte (max.show = 25)