如何在多个阵列中找到连续数?

时间:2016-06-24 14:36:08

标签: arrays r algorithm permutation number-theory

我马上举个例子, 现在假设我有3个数组a,b,c,如

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

我必须能够在其中提取连续的三元组,例如,

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

但这只是一个例子,我将拥有一个甚至超过10个数组的更大数据集,因此必须能够找到长度为10的连续系列。

因此,任何人都可以提供一种算法,通常可以找到连续的长度序列' n'在' n'之间阵列。

我实际上是在R中做这个东西,所以如果你用R代码你的代码就更好了。但是,任何语言的算法都不过是受欢迎的。

4 个答案:

答案 0 :(得分:7)

首先将数据重组为包含值和数组编号的列表。 对列表排序;你可能会像:

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个连续数字,然后检查它们是否有不同的数组

答案 1 :(得分:5)

这是一种方法。这假设在组数的观察序列中没有中断。这里的数据。

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

答案 2 :(得分:2)

这是一个带有expand.grid的蛮力方法和示例中的三个向量

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

使用combn计算每个成对组合的差异。

# 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

答案 3 :(得分:1)

我已经将一个小的递归函数混合在一起,它会在你传递它的过程中找到所有连续的三元组(需要传递至少三个)。它可能有点粗糙,但似乎有效。

该函数使用省略号...来传递参数。因此,您需要提供许多参数(即数字向量)并将它们放在列表items中。然后定位每个传递的矢量中的最小值及其索引。

然后创建对应于最小三元组的向量的indeces并使用for()循环进行迭代,其中输出值被传递给输出向量outitems中的输入向量被修剪并以递归方式再次传递到函数中。 只有当所有向量都是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

问题是,每个向量只使用一个值来查找三元组。 因此,它不会在例如{3}中找到连续的三元组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