दिलचस्प पोस्ट
क्या क्रम में स्थैतिक ब्लॉक और इनिशियलाइज़ेशन ब्लॉक निष्पादित करते हैं जब विरासत का उपयोग करते हैं? पीएल / एसक्यूएल में फ़ंक्शन और प्रक्रिया में क्या अंतर है? सर्वश्रेष्ठ सी / सी + + नेटवर्क लाइब्रेरी UIPanGestureRecognizer – केवल ऊर्ध्वाधर या क्षैतिज प्लेबैक वीडियो पूर्ण स्क्रीन कोणीय 2: 'एनजीएमोडेल' से बाध्य नहीं किया जा सकता क्योंकि यह 'इनपुट' की ज्ञात संपत्ति नहीं है स्प्रिंग रेस्ट सर्विस: जेएसन प्रतिक्रिया में रिक्त ऑब्जेक्ट को हटाने के लिए कॉन्फ़िगर कैसे करें चेरी-चुने-चुने कई कमान कैसे करें बैच फ़ाइल में कल की तारीख कैसे प्राप्त करें पायथन डिक्शनरी, कमानों / मूल्यों को एक ही क्रम में कैसे घोषित किया जाता है? "मानक" समयक्षेत्र संक्षेप क्या हैं? एक फ़ोल्डर के अंदर सबफ़ोल्डर फ़ाइलों का लगातार उपयोग करें सबलेट फिल्टर के साथ अनुरोध पैरामीटर संशोधित करें मैं पायथन में कमांड लाइन तर्क कैसे प्राप्त करूं? क्या गोलांग में मूल संरचना से अधिरोहित पद्धति को कॉल करना संभव है?

आर में विखंडों में सदिश को विभाजित करें

मुझे एक सदिश को आर आकार में बराबर आकार के एन खंड में विभाजित करना पड़ता है। मुझे ऐसा करने के लिए कोई भी आधार नहीं मिला। इसके अलावा Google मुझे कहीं नहीं मिला तो यह है कि मैं किसके साथ आया, उम्मीद है कि यह किसी को कुछ में मदद करता है

x <- 1:10 n <- 3 chunk <- function(x,n) split(x, factor(sort(rank(x)%%n))) chunk(x,n) $`0` [1] 1 2 3 $`1` [1] 4 5 6 7 $`2` [1] 8 9 10 

कोई टिप्पणी, सुझाव या सुधार वास्तव में स्वागत है और सराहना की है।

चीयर्स, सेबस्टियन

Solutions Collecting From Web of "आर में विखंडों में सदिश को विभाजित करें"

एक-लाइनर स्प्लिटिंग डी आकार 20 की मात्रा में होता है:

 split(d, ceiling(seq_along(d)/20)) 

अधिक विवरण: मुझे लगता है कि आपको केवल जरूरत है seq_along() , split() और ceiling() :

 > d <- rpois(73,5) > d [1] 3 1 11 4 1 2 3 2 4 10 10 2 7 4 6 6 2 1 1 2 3 8 3 10 7 4 [27] 3 4 4 1 1 7 2 4 6 0 5 7 4 6 8 4 7 12 4 6 8 4 2 7 6 5 [53] 4 5 4 5 5 8 7 7 7 6 2 4 3 3 8 11 6 6 1 8 4 > max <- 20 > x <- seq_along(d) > d1 <- split(d, ceiling(x/max)) > d1 $`1` [1] 3 1 11 4 1 2 3 2 4 10 10 2 7 4 6 6 2 1 1 2 $`2` [1] 3 8 3 10 7 4 3 4 4 1 1 7 2 4 6 0 5 7 4 6 $`3` [1] 8 4 7 12 4 6 8 4 2 7 6 5 4 5 4 5 5 8 7 7 $`4` [1] 7 6 2 4 3 3 8 11 6 6 1 8 4 
 chunk2 <- function(x,n) split(x, cut(seq_along(x), n, labels = FALSE)) 

यह आपके पास क्या अलग है, लेकिन यह अभी भी काफी अच्छी सूची संरचना है जो मुझे लगता है:

 chunk.2 <- function(x, n, force.number.of.groups = TRUE, len = length(x), groups = trunc(len/n), overflow = len%%n) { if(force.number.of.groups) { f1 <- as.character(sort(rep(1:n, groups))) f <- as.character(c(f1, rep(n, overflow))) } else { f1 <- as.character(sort(rep(1:groups, n))) f <- as.character(c(f1, rep("overflow", overflow))) } g <- split(x, f) if(force.number.of.groups) { g.names <- names(g) g.names.ordered <- as.character(sort(as.numeric(g.names))) } else { g.names <- names(g[-length(g)]) g.names.ordered <- as.character(sort(as.numeric(g.names))) g.names.ordered <- c(g.names.ordered, "overflow") } return(g[g.names.ordered]) } 

आप इसे किस प्रकार स्वरूपित करना चाहते हैं, इसके आधार पर आपको निम्नलिखित प्रदान करेगा:

 > x <- 1:10; n <- 3 > chunk.2(x, n, force.number.of.groups = FALSE) $`1` [1] 1 2 3 $`2` [1] 4 5 6 $`3` [1] 7 8 9 $overflow [1] 10 > chunk.2(x, n, force.number.of.groups = TRUE) $`1` [1] 1 2 3 $`2` [1] 4 5 6 $`3` [1] 7 8 9 10 

इन सेटिंग्स का उपयोग करते हुए कुछ समय चलाना:

 set.seed(42) x <- rnorm(1:1e7) n <- 3 

इसके बाद हमारे पास निम्न परिणाम हैं:

 > system.time(chunk(x, n)) # your function user system elapsed 29.500 0.620 30.125 > system.time(chunk.2(x, n, force.number.of.groups = TRUE)) user system elapsed 5.360 0.300 5.663 

संपादित करें: as.factor () से as.character () में बदलकर मेरे फ़ंक्शन ने इसे दो बार तेज़ी से बनाया।

Ggplot2 फ़ंक्शन, cut_number :

 library(ggplot2) x <- 1:10 n <- 3 cut_number(x, n) # labels = FALSE if you just want an integer result #> [1] [1,4] [1,4] [1,4] [1,4] (4,7] (4,7] (4,7] (7,10] (7,10] (7,10] #> Levels: [1,4] (4,7] (7,10] # if you want it split into a list: split(x, cut_number(x, n)) #> $`[1,4]` #> [1] 1 2 3 4 #> #> $`(4,7]` #> [1] 5 6 7 #> #> $`(7,10]` #> [1] 8 9 10 

ढेर के कुछ और रूप …

 > x <- 1:10 > n <- 3 

ध्यान दें, आपको factor फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है, लेकिन फिर भी आप को sort करना चाहते हैं ओ / ओ आपका पहला वेक्टर होगा 1 2 3 10 :

 > chunk <- function(x, n) split(x, sort(rank(x) %% n)) > chunk(x,n) $`0` [1] 1 2 3 $`1` [1] 4 5 6 7 $`2` [1] 8 9 10 

या आप वर्ण इंडेक्स असाइन कर सकते हैं, उपरोक्त बाएं टिक्स में संख्याएं:

 > my.chunk <- function(x, n) split(x, sort(rep(letters[1:n], each=n, len=length(x)))) > my.chunk(x, n) $a [1] 1 2 3 4 $b [1] 5 6 7 $c [1] 8 9 10 

या आप एक सदिश में संग्रहित सादे शब्द का उपयोग कर सकते हैं। ध्यान दें कि x में निरंतर मूल्य प्राप्त करने के लिए sort का उपयोग लेबल को alphabetizes:

 > my.other.chunk <- function(x, n) split(x, sort(rep(c("tom", "dick", "harry"), each=n, len=length(x)))) > my.other.chunk(x, n) $dick [1] 1 2 3 $harry [1] 4 5 6 $tom [1] 7 8 9 10 
 simplified version... n = 3 split(x, sort(x%%n)) 

आप विभाजित / कटौती को जोड़ सकते हैं, जैसा कि एमएमएसिमर द्वारा सुझाव दिया गया है, यहां तक ​​कि समूह बनाने के लिए मात्रा भी है:

 split(x,cut(x,quantile(x,(0:n)/n), include.lowest=TRUE, labels=FALSE)) 

यह आपके उदाहरण के लिए एक ही परिणाम देता है, लेकिन स्क्यूड चर के लिए नहीं

यहाँ एक और संस्करण है

नोट: इस नमूने के साथ आप दूसरे पैरामीटर में CHUNK SIZE निर्दिष्ट कर रहे हैं

  1. सभी भाग समान हैं, सिवाय इसके कि अंतिम;
  2. आखिरी इच्छा सबसे खराब होगी, चक का आकार जितना बड़ा नहीं होगा
 chunk <- function(x,n) { f <- sort(rep(1:(trunc(length(x)/n)+1),n))[1:length(x)] return(split(x,f)) } #Test n<-c(1,2,3,4,5,6,7,8,9,10,11) c<-chunk(n,5) q<-lapply(c, function(r) cat(r,sep=",",collapse="|") ) #output 1,2,3,4,5,|6,7,8,9,10,|11,| 

split(x,matrix(1:n,n,length(x))[1:length(x)])

शायद यह अधिक स्पष्ट है, लेकिन एक ही विचार:
split(x,rep(1:n, ceiling(length(x)/n),length.out = length(x)))

अगर आप इसे आदेश देते हैं, तो इसके चारों ओर एक तरह से फेंक दें

मुझे एक ही समारोह की जरूरत है और पिछले समाधानों को पढ़ा है, हालांकि मुझे असंतुलित हिस्सा अंत में रहने की जरूरत है, अर्थात अगर मेरे पास 10 तत्व हैं, तो उन्हें 3 प्रत्येक के वैक्टर में विभाजित किया जाए, तो मेरे परिणाम के साथ वैक्टर होना चाहिए 3, क्रमशः 3,4 तत्व इसलिए मैंने निम्नलिखित का इस्तेमाल किया (मैंने पठनीयता के लिए अपरिवर्तित कोड छोड़ा, अन्यथा कोई भी कई चर की आवश्यकता नहीं है):

 chunk <- function(x,n){ numOfVectors <- floor(length(x)/n) elementsPerVector <- c(rep(n,numOfVectors-1),n+length(x) %% n) elemDistPerVector <- rep(1:numOfVectors,elementsPerVector) split(x,factor(elemDistPerVector)) } set.seed(1) x <- rnorm(10) n <- 3 chunk(x,n) $`1` [1] -0.6264538 0.1836433 -0.8356286 $`2` [1] 1.5952808 0.3295078 -0.8204684 $`3` [1] 0.4874291 0.7383247 0.5757814 -0.3053884 

इस फ़ंक्शन के लिए @Sebastian पर क्रेडिट

 chunk <- function(x,y){ split(x, factor(sort(rank(row.names(x))%%y))) } 

यदि आप split() पसंद नहीं करते हैं और आप अपनी लघु पूंछ को पैडिंग नहीं मानते हैं:

 chunk <- function(x, n) { if((length(x)%%n)==0) {return(matrix(x, nrow=n))} else {return(matrix(append(x, rep(NA, n-(length(x)%%n))), nrow=n))} } 

लौटे मैट्रिक्स के कॉलम ([, 1: एनकॉल]) वे ड्रॉड्स हैं जिन्हें आप ढूंढ रहे हैं।

यदि आप split() पसंद नहीं करते हैं और आप matrix() अपने लटकती एनएएस के साथ matrix() पसंद नहीं करते हैं, तो यह है:

 chunk <- function(x, n) (mapply(function(a, b) (x[a:b]), seq.int(from=1, to=length(x), by=n), pmin(seq.int(from=1, to=length(x), by=n)+(n-1), length(x)), SIMPLIFY=FALSE)) 

split() , यह एक सूची देता है, लेकिन यह लेबल के साथ समय या स्थान बर्बाद नहीं करता है, इसलिए यह अधिक प्रदर्शनकारी हो सकता है।

मुझे एक फ़ंक्शन की ज़रूरत है जो डेटा के योग्य (उद्धरण चिह्नों) के तर्क और अन्य तर्क जो उस मूल डेटा के सबसेट में पंक्तियों की संख्या पर ऊपरी सीमा है। यह फ़ंक्शन उन डेटा की संख्याओं का उत्पादन करता है जिनकी ऊपरी सीमा को निम्न के लिए अनुमति मिलती है:

 library(data.table) split_dt <- function(x,y) { for(i in seq(from=1,to=nrow(get(x)),by=y)) {df_ <<- get(x)[i:(i + y)]; assign(paste0("df_",i),df_,inherits=TRUE)} rm(df_,inherits=TRUE) } 

यह फ़ंक्शन मुझे डेटा की एक श्रृंखला देता है, जिसका नाम df_ [number] है, नाम के मूल डेटा से चालू पंक्ति से शुरू हो रहा है। आखिरी आंकड़ा हो सकता है छोटा और एनएएस से भर दिया जाये ताकि आप जो भी डाटा छोड़े गए हैं, उसका सबसेट करना होगा। इस प्रकार का फ़ंक्शन उपयोगी है क्योंकि उदाहरण के लिए, कुछ जीआईएस सॉफ्टवेयर आपको कितने पते पिन आयात कर सकते हैं, इसके लिए सीमित है। इसलिए डेटा को छोटे टुकड़ों में जमा करने की सलाह दी जा सकती है, लेकिन हो सकता है कि यह संभवतः टालकर न हो।