मेरे पास संख्याओं का वेक्टर है:
numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435,
453,435,324,34,456,56,567,65,34,435)
सदिश में एक मान x प्रकट होने की संख्या को R कितनी बार गिन सकता है ?
मेरे पास संख्याओं का वेक्टर है:
numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435,
453,435,324,34,456,56,567,65,34,435)
सदिश में एक मान x प्रकट होने की संख्या को R कितनी बार गिन सकता है ?
जवाबों:
आप बस उपयोग कर सकते हैं table():
> a <- table(numbers)
> a
numbers
4 5 23 34 43 54 56 65 67 324 435 453 456 567 657
2 1 2 2 1 1 2 1 2 1 3 1 1 1 1 फिर आप इसे सब्मिट कर सकते हैं:
> a[names(a)==435]
435
3या यदि आप उस के साथ काम करने में अधिक सहज हैं, तो इसे डेटा.फ्रेम में परिवर्तित करें:
> as.data.frame(table(numbers))
numbers Freq
1 4 2
2 5 1
3 23 2
4 34 2
...a["435"]इनसेट क्यों नहीं a[names(a)==435]?
सबसे सीधा रास्ता है sum(numbers == x)।
numbers == xएक तार्किक वेक्टर बनाता है जो हर उस स्थान पर TRUE होता है जो x होता है, और जब suming होता है, तार्किक वेक्टर संख्यात्मक के लिए बाध्य होता है जो TRUE को 1 और FALSE को 0 में परिवर्तित करता है।
हालाँकि, ध्यान दें कि फ़्लोटिंग पॉइंट नंबरों के लिए कुछ का उपयोग करना बेहतर है sum(abs(numbers - x) < 1e-6):।
xविशिष्ट ज्ञात मूल्य के बजाय डेटा में सभी के लिए उत्तर प्रदान करता है x। निष्पक्ष होना, यही मूल प्रश्न था। जैसा कि मैंने नीचे अपने जवाब में कहा, "मुझे लगता है कि यह दुर्लभ है कि मैं एक मूल्य की आवृत्ति जानना चाहता हूं और सभी मूल्यों की नहीं ..."
मैं शायद ऐसा कुछ करूंगा
length(which(numbers==x))लेकिन वास्तव में, एक बेहतर तरीका है
table(numbers)table(numbers)सबसे आसान समाधान की तुलना में बहुत अधिक काम sum(numbers==x)करने जा रहा है, क्योंकि यह सूची में अन्य सभी नंबरों की संख्या का भी पता लगाने जा रहा है।
मेरा पसंदीदा समाधान उपयोग करता है rle, जो एक मान (लेबल, xआपके उदाहरण में) और एक लंबाई लौटाएगा , जो यह दर्शाता है कि क्रम में कितनी बार मूल्य प्रकट हुआ।
के rleसाथ संयोजन करके sort, आपके पास किसी भी मूल्य के प्रकट होने की संख्या को गिनने का एक बहुत तेज़ तरीका है। यह अधिक जटिल समस्याओं के साथ सहायक हो सकता है।
उदाहरण:
> numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435,453,435,324,34,456,56,567,65,34,435)
> a <- rle(sort(numbers))
> a
Run Length Encoding
lengths: int [1:15] 2 1 2 2 1 1 2 1 2 1 ...
values : num [1:15] 4 5 23 34 43 54 56 65 67 324 ...यदि आप जो मूल्य चाहते हैं वह दिखाई नहीं देता है, या आपको उस मूल्य को बाद में संग्रहीत करने की आवश्यकता है, तो aएक बनाएं data.frame।
> b <- data.frame(number=a$values, n=a$lengths)
> b
values n
1 4 2
2 5 1
3 23 2
4 34 2
5 43 1
6 54 1
7 56 2
8 65 1
9 67 2
10 324 1
11 435 3
12 453 1
13 456 1
14 567 1
15 657 1मुझे लगता है कि यह दुर्लभ है कि मैं एक मूल्य की आवृत्ति जानना चाहता हूं और सभी मूल्यों की नहीं, और आरईएल उन सभी को गिनने और संग्रहीत करने का सबसे तेज तरीका है।
c(rep('A', 3), rep('G', 4), 'A', rep('G', 2), rep('C', 10))वापस आ जाएगा values = c('A','G','A','G','C')और lengths=c(3, 4, 1, 2, 10)जो कभी-कभी उपयोगी होता है।
tableतेजी से दिखाई देता है when the vector is long(मैंने 100000 की कोशिश की) लेकिन थोड़ी देर जब यह छोटा हो गया (मैंने 1000 की कोशिश की)
उसके लिए R में एक मानक कार्य है
tabulate(numbers)
tabulateयह है कि आप शून्य और नकारात्मक संख्या से नहीं निपट सकते।
tabulate। नोट: sortसामान्य रूप से इसके सही उपयोग के लिए आवश्यक प्रतीत होता है tabulate(sort(numbers)):।
numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435 453,435,324,34,456,56,567,65,34,435)
> length(grep(435, numbers))
[1] 3
> length(which(435 == numbers))
[1] 3
> require(plyr)
> df = count(numbers)
> df[df$x == 435, ]
x freq
11 435 3
> sum(435 == numbers)
[1] 3
> sum(grepl(435, numbers))
[1] 3
> sum(435 == numbers)
[1] 3
> tabulate(numbers)[435]
[1] 3
> table(numbers)['435']
435
3
> length(subset(numbers, numbers=='435'))
[1] 3यदि आप बाद में दिखावे की संख्या गिनना चाहते हैं, तो आप sapplyफ़ंक्शन का उपयोग कर सकते हैं :
index<-sapply(1:length(numbers),function(x)sum(numbers[1:x]==numbers[x]))
cbind(numbers, index)आउटपुट:
numbers index
[1,] 4 1
[2,] 23 1
[3,] 4 2
[4,] 23 2
[5,] 5 1
[6,] 43 1
[7,] 54 1
[8,] 56 1
[9,] 657 1
[10,] 67 1
[11,] 67 2
[12,] 435 1
[13,] 453 1
[14,] 435 2
[15,] 324 1
[16,] 34 1
[17,] 456 1
[18,] 56 2
[19,] 567 1
[20,] 65 1
[21,] 34 2
[22,] 435 3आप निम्नलिखित पंक्ति में अपनी इच्छानुसार संख्या बदल सकते हैं
length(which(numbers == 4))एक और तरीका मुझे सुविधाजनक लगता है:
numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435,453,435,324,34,456,56,567,65,34,435)
(s<-summary (as.factor(numbers)))यह डाटासेट को कारक में परिवर्तित करता है, और फिर सारांश () हमें नियंत्रण योग देता है (अद्वितीय मूल्यों की गणना)।
आउटपुट है:
4 5 23 34 43 54 56 65 67 324 435 453 456 567 657
2 1 2 2 1 1 2 1 2 1 3 1 1 1 1 यह पसंदीदा होने पर डेटाफ्रेम के रूप में संग्रहीत किया जा सकता है।
as.data.frame (cbind (संख्या = नाम), Freq = s), स्ट्रिंग्सएफ़एक्टर्स = F, row.names = 1: लंबाई (s)
यहाँ row.names का उपयोग पंक्ति के नाम बदलने के लिए किया गया है। बिना row.names का उपयोग किए, नए डेटाफ्रेम में पंक्ति नामों के रूप में कॉलम नामों का उपयोग किया जाता है
आउटपुट है:
Number Freq
1 4 2
2 5 1
3 23 2
4 34 2
5 43 1
6 54 1
7 56 2
8 65 1
9 67 2
10 324 1
11 435 3
12 453 1
13 456 1
14 567 1
15 657 1तालिका का उपयोग करना लेकिन उसके साथ तुलना किए बिना names:
numbers <- c(4,23,4,23,5,43,54,56,657,67,67,435)
x <- 67
numbertable <- table(numbers)
numbertable[as.character(x)]
#67
# 2 tableउपयोगी है जब आप कई बार विभिन्न तत्वों की गिनती का उपयोग कर रहे हैं। यदि आपको केवल एक गिनती की आवश्यकता है, तो उपयोग करेंsum(numbers == x)
एक विशिष्ट तत्वों की गिनती के विभिन्न तरीके हैं
library(plyr)
numbers =c(4,23,4,23,5,43,54,56,657,67,67,435,453,435,7,65,34,435)
print(length(which(numbers==435)))
#Sum counts number of TRUE's in a vector
print(sum(numbers==435))
print(sum(c(TRUE, FALSE, TRUE)))
#count is present in plyr library
#o/p of count is a DataFrame, freq is 1 of the columns of data frame
print(count(numbers[numbers==435]))
print(count(numbers[numbers==435])[['freq']])एक विधि जो लंबे वैक्टर पर अपेक्षाकृत तेज़ होती है और एक सुविधाजनक आउटपुट देती है वह है उपयोग करने के लिए lengths(split(numbers, numbers))( एस के अंत में नोट करें lengths):
# Make some integer vectors of different sizes
set.seed(123)
x <- sample.int(1e3, 1e4, replace = TRUE)
xl <- sample.int(1e3, 1e6, replace = TRUE)
xxl <-sample.int(1e3, 1e7, replace = TRUE)
# Number of times each value appears in x:
a <- lengths(split(x,x))
# Number of times the value 64 appears:
a["64"]
#~ 64
#~ 15
# Occurences of the first 10 values
a[1:10]
#~ 1 2 3 4 5 6 7 8 9 10
#~ 13 12 6 14 12 5 13 14 11 14 आउटपुट केवल एक नामित वेक्टर है।
गति JBeckerrle द्वारा प्रस्तावित करने के लिए तुलनीय प्रतीत होती है और यहां तक कि बहुत लंबे वैक्टर पर थोड़ा तेज भी। यहाँ प्रस्तावित कार्यों में से कुछ के साथ R 3.6.2 में एक माइक्रोबेनमार्क है :
library(microbenchmark)
f1 <- function(vec) lengths(split(vec,vec))
f2 <- function(vec) table(vec)
f3 <- function(vec) rle(sort(vec))
f4 <- function(vec) plyr::count(vec)
microbenchmark(split = f1(x),
table = f2(x),
rle = f3(x),
plyr = f4(x))
#~ Unit: microseconds
#~ expr min lq mean median uq max neval cld
#~ split 402.024 423.2445 492.3400 446.7695 484.3560 2970.107 100 b
#~ table 1234.888 1290.0150 1378.8902 1333.2445 1382.2005 3203.332 100 d
#~ rle 227.685 238.3845 264.2269 245.7935 279.5435 378.514 100 a
#~ plyr 758.866 793.0020 866.9325 843.2290 894.5620 2346.407 100 c
microbenchmark(split = f1(xl),
table = f2(xl),
rle = f3(xl),
plyr = f4(xl))
#~ Unit: milliseconds
#~ expr min lq mean median uq max neval cld
#~ split 21.96075 22.42355 26.39247 23.24847 24.60674 82.88853 100 ab
#~ table 100.30543 104.05397 111.62963 105.54308 110.28732 168.27695 100 c
#~ rle 19.07365 20.64686 23.71367 21.30467 23.22815 78.67523 100 a
#~ plyr 24.33968 25.21049 29.71205 26.50363 27.75960 92.02273 100 b
microbenchmark(split = f1(xxl),
table = f2(xxl),
rle = f3(xxl),
plyr = f4(xxl))
#~ Unit: milliseconds
#~ expr min lq mean median uq max neval cld
#~ split 296.4496 310.9702 342.6766 332.5098 374.6485 421.1348 100 a
#~ table 1151.4551 1239.9688 1283.8998 1288.0994 1323.1833 1385.3040 100 d
#~ rle 399.9442 430.8396 464.2605 471.4376 483.2439 555.9278 100 c
#~ plyr 350.0607 373.1603 414.3596 425.1436 437.8395 506.0169 100 b महत्वपूर्ण रूप से, एकमात्र फ़ंक्शन जो लापता मानों की संख्या भी गिनता NAहै plyr::count। इन्हें अलग-अलग उपयोग करके भी प्राप्त किया जा सकता हैsum(is.na(vec))
यह एक आयामी परमाणु वैक्टर के लिए एक बहुत तेज समाधान है। यह निर्भर करता है match(), इसलिए यह संगत है NA:
x <- c("a", NA, "a", "c", "a", "b", NA, "c")
fn <- function(x) {
u <- unique.default(x)
out <- list(x = u, freq = .Internal(tabulate(match(x, u), length(u))))
class(out) <- "data.frame"
attr(out, "row.names") <- seq_along(u)
out
}
fn(x)
#> x freq
#> 1 a 3
#> 2 <NA> 2
#> 3 c 2
#> 4 b 1आप एल्गोरिथ्म को भी ट्विक कर सकते हैं ताकि यह न चले unique()।
fn2 <- function(x) {
y <- match(x, x)
out <- list(x = x, freq = .Internal(tabulate(y, length(x)))[y])
class(out) <- "data.frame"
attr(out, "row.names") <- seq_along(x)
out
}
fn2(x)
#> x freq
#> 1 a 3
#> 2 <NA> 2
#> 3 a 3
#> 4 c 2
#> 5 a 3
#> 6 b 1
#> 7 <NA> 2
#> 8 c 2ऐसे मामलों में जहां यह आउटपुट वांछनीय है, आपको मूल वेक्टर को फिर से वापस करने के लिए शायद इसकी आवश्यकता भी नहीं है, और दूसरा कॉलम शायद आप सभी की जरूरत है। आप पाइप के साथ एक लाइन में प्राप्त कर सकते हैं:
match(x, x) %>% `[`(tabulate(.), .)
#> [1] 3 2 3 2 3 1 2 2यह एक स्पष्ट अर्थ के साथ, outerउसके बाद समानता का एक मैट्रिक्स प्राप्त करने के लिए किया जा सकता है rowSums।
मायने रखता है और numbersएक ही डेटासेट में, पहली बार एक डेटा.फ्रेम बनाया जाता है। यदि आप अलग इनपुट और आउटपुट चाहते हैं तो इस चरण की आवश्यकता नहीं है।
df <- data.frame(No = numbers)
df$count <- rowSums(outer(df$No, df$No, FUN = `==`))