एकाधिक Arrays के बीच Consecutive संख्या कैसे खोजें?

Question

मैं अभी एक उदाहरण देता हूँ, अब लगता है मुझे 3 सरणियों एक, ख, ग जैसे

a = c(3,5) 
b = c(6,1,8,7) 
c = c(4,2,9) 

मैं मैं उन के बीच लगातार तीन को निकालने के लिए, ई में सक्षम होना चाहिए है।,

c(1,2,3),c(4,5,6) 

लेकिन यह सिर्फ एक उदाहरण था, मेरे पास 10 से अधिक सरणी के साथ एक बड़ा डेटा सेट होगा, इसलिए लंबाई दस की लगातार श्रृंखला को खोजने में सक्षम होना चाहिए।

तो कोई भी आम तौर पर 'एन' सरणी के बीच लंबाई 'एन' की लगातार श्रृंखला को खोजने के लिए एक एल्गोरिदम प्रदान कर सकता है।

मैं वास्तव में आर में यह सामान कर रहा हूं, इसलिए यदि आप आर में अपना कोड देते हैं तो यह बेहतर है। फिर भी किसी भी भाषा से एल्गोरिदम स्वागत से अधिक है।

Answer 1

डेटा को पहले मूल्य और सरणी संख्या वाली सूची में पुनर्गठित करें। सूची को सॉर्ट करें; आप की तरह ख़ाली होगा:

1-2 
2-3 
3-1 (i.e. " there' s a three in array 1") 
4-3 
5-1 
6-2 
7-2 
8-2 
9-3 

अगर वहाँ वास्तव में कर रहे n लगातार संख्या फिर पाश सूची, चेक करें, फिर जाँच लें कि इन विभिन्न सरणी संख्या

Answer 2

यहां एक दृष्टिकोण है। यह मानता है कि समूहों की संख्या में अवलोकन के अनुक्रम में कोई ब्रेक नहीं है। यहां डेटा।

N <- 3 
a <- c(3,5) 
b <- c(6,1,8,7) 
c <- c(4,2,9) 

फिर

मैं टिप्पणियों

dd <- lattice::make.groups(a,b,c) 
dd <- dd[order(dd$data),] 

अब मैं इस तालिका में पंक्तियों जहां सभी तीन समूहों

idx <- apply(embed(as.numeric(dd$which),N), 1, function(x) { 
    length(unique(x))==N 
}) 

प्रतिनिधित्व कर रहे हैं तो हम देख सकते हैं के लिए देखो द्वारा एक साथ और क्रम में उनके गठबंधन

lapply(which(idx), function(i) { 
    dd[i:(i+N-1),] 
}) 

# [[1]] 
# data which 
# b2 1  b 
# c2 2  c 
# a1 3  a 
# 
# [[2]] 
# data which 
# c1 4  c 
# a2 5  a 
# b1 6  b 

Answer 3

के साथ तीन गुना

यहाँ उदाहरण

# get all combinations 
df <- expand.grid(a,b,c) 

प्रत्येक जोड़ो में संयोजन के लिए अंतर की गणना करने के combn का प्रयोग के रूप में expand.grid और तीन वैक्टर के साथ एक जानवर बल विधि है।

# get all parwise differences 
myDiffs <- combn(names(df), 2, FUN=function(x) abs(x[1]-x[2])) 

# subset data using `rowSums` and `which` 
df[which(rowSums(myDiffs == 1) == ncol(myDiffs)-1), ] 

df[which(rowSums(myDiffs == 1) == ncol(myDiffs)-1), ] 
    Var1 Var2 Var3 
2  5 6 4 
11 3 1 2 

Answer 4

मैं एक साथ हैक कर लिया है एक छोटे से पुनरावर्ती समारोह है कि होगा था जब आप इसे पास करते हैं तो कई वैक्टरों में लगातार तीन तिगुनाएं पाएं (कम से कम तीन पास करने की आवश्यकता है)। यह शायद थोड़ा कच्चा है, लेकिन काम करने लगता है।

फ़ंक्शन तर्क पारित करने के लिए, इलिप्सिस, ... का उपयोग करता है। इसलिए यह आपके द्वारा प्रदान किए जाने वाले कई तर्क (यानी संख्यात्मक वैक्टर) ले जाएगा और उन्हें items सूची में डाल देगा। फिर प्रत्येक उत्तीर्ण वेक्टर के बीच सबसे छोटा मूल्य इसके सूचकांक के साथ स्थित है।

फिर छोटे ट्रिपलेट से संबंधित वैक्टरों के indeces बनाए जाते हैं और for() लूप का उपयोग करके पुनरावृत्त होते हैं, जहां आउटपुट मान आउटपुट वेक्टर out पर पास किए जाते हैं।items में इनपुट वैक्टर काटा जाता है और एक पुनरावर्ती फैशन में फ़ंक्शन में फिर से पारित किया जाता है। केवल, जब सभी वैक्टर NA हैं, यानी वेक्टर में कोई और मूल्य नहीं हैं, फ़ंक्शन अंतिम परिणाम देता है।

library(magrittr) 

# define function to find the triplets 
tripl <- function(...){ 
    items <- list(...) 

    # find the smallest number in each passed vector, along with its index 
    # output is a matrix of n-by-2, where n is the number of passed arguments 
    triplet.id <- lapply(items, function(x){ 
    if(is.na(x) %>% prod) id <- c(NA, NA) 
    else id <- c(which(x == min(x)), x[which(x == min(x))]) 
    }) %>% unlist %>% matrix(., ncol=2, byrow=T) 


    # find the smallest triplet from the passed vectors 
    index <- order(triplet.id[,2])[1:3] 
    # create empty vector for output 
    out <- vector() 

    # go through the smallest triplet's indices 
    for(i in index){ 
    # .. append the coresponding item from the input vector to the out vector 
    # .. and remove the value from the input vector 
    if(length(items[[i]]) == 1) { 
     out <- append(out, items[[i]]) 
     # .. if the input vector has no value left fill with NA 
     items[[i]] <- NA 
    } 
    else { 
     out <- append(out, items[[i]][triplet.id[i,1]]) 
     items[[i]] <- items[[i]][-triplet.id[i,1]] 
    } 
    } 

    # recurse until all vectors are empty (NA) 
    if(!prod(unlist(is.na(items)))) out <- append(list(out), 
               do.call("tripl", c(items), quote = F)) 
    else(out <- list(out)) 

    # return result 
    return(out) 
} 

फ़ंक्शन को इनपुट वैक्टर को तर्क के रूप में पास करके बुलाया जा सकता है।

# input vectors 
a = c(3,5) 
b = c(6,1,8,7) 
c = c(4,2,9) 

# find all the triplets using our function 
y <- tripl(a,b,c) 

परिणाम एक सूची है, जिसमें सभी निरंतर जानकारी शामिल है, यद्यपि अनियंत्रित।

print(y) 
# [[1]] 
# [1] 1 2 3 
# 
# [[2]] 
# [1] 4 5 6 
# 
# [[3]] 
# [1] 7 9 NA 
# 
# [[4]] 
# [1] 8 NA NA 

आदेश सब कुछ sapply() का उपयोग किया जा सकता है:

# put everything in order 
sapply(y, function(x){x[order(x)]}) %>% t 
#  [,1] [,2] [,3] 
# [1,] 1 2 3 
# [2,] 4 5 6 
# [3,] 7 9 NA 
# [4,] 8 NA NA 

बात है, कि यह तीनो को खोजने के लिए वेक्टर प्रति केवल एक मान का उपयोग करेगा। इसलिए यह लगातार तीन तिहाई c(6,7,8) नहीं मिलेगा c(6,7,11), c(8,9,13) और c(10,12,14)। इस उदाहरण में यह c(6,8,10) लौटाएगा (नीचे देखें)।

a<-c(6,7,11) 
b<-c(8,9,13) 
c<-c(10,12,14) 

y <- tripl(a,b,c) 
sapply(y, function(x){x[order(x)]}) %>% t 
#  [,1] [,2] [,3] 
# [1,] 6 8 10 
# [2,] 7 9 12 
# [3,] 11 13 14