18

我有一个向量，例如c(1, 3, 4, 5, 9, 10, 17, 29, 30)，我想将形成规则的连续序列的“相邻”元素组合在一起，即在一个参差不齐的向量中增加 1，从而导致：

L1：1
L2：3,4,5
L3：9,10
L4：17
L5：29,30

天真的代码（前 C 程序员的）：

partition.neighbors <- function(v)
{
    result <<- list() #jagged array
    currentList <<- v[1] #current series

    for(i in 2:length(v))
    {
        if(v[i] - v [i-1] == 1)
        {
            currentList <<- c(currentList, v[i])
        }
        else
        {
            result <<- c(result, list(currentList))
            currentList <<- v[i] #next series
        }       
    }

    return(result)  
}

现在我明白

a）R不是C（尽管有大括号）
b）全局变量是纯粹的邪恶
c）这是一种非常低效的实现结果的方法

，所以欢迎任何更好的解决方案。

4

5 回答 5

21

大量使用一些 R 习语：

> split(v, cumsum(c(1, diff(v) != 1)))
$`1`
[1] 1

$`2`
[1] 3 4 5

$`3`
[1]  9 10

$`4`
[1] 17

$`5`
[1] 29 30
于 2011-03-07T16:40:58.787 回答
12

daroczig 写道：“你可以基于diff“...

这是一种方法：

split(v, cumsum(diff(c(-Inf, v)) != 1))

编辑（添加时间）：

Tommy 发现注意类型会更快。它变得更快的原因split是在整数上更快，实际上在因子上更快。

这是约书亚的解决方案；的结果cumsum是一个数字，因为它c与 'd 一起使用1，所以它是最慢的。

system.time({
a <- cumsum(c(1, diff(v) != 1))
split(v, a)
})
#   user  system elapsed 
#  1.839   0.004   1.848

就这样，结果是一个整数大大加快了它的速度c。1L

system.time({
a <- cumsum(c(1L, diff(v) != 1))
split(v, a)
})
#   user  system elapsed 
#  0.744   0.000   0.746

这是汤米的解决方案，供参考；它也在一个整数上分裂。

> system.time({
a <- cumsum(c(TRUE, diff(v) != 1L))
split(v, a)
})
#   user  system elapsed 
#  0.742   0.000   0.746

这是我原来的解决方案；它也在一个整数上分裂。

system.time({
a <- cumsum(diff(c(-Inf, v)) != 1)
split(v, a)
})
#   user  system elapsed 
#  0.750   0.000   0.754

这是 Joshua 的，结果在split.

system.time({
a <- cumsum(c(1, diff(v) != 1))
a <- as.integer(a)
split(v, a)
})
#   user  system elapsed 
#  0.736   0.002   0.740

split整数向量上的所有版本都差不多；如果整数向量已经是一个因子，它可能会更快，因为从整数到因子的转换实际上需要大约一半的时间。这里我直接把它变成一个因子；一般不建议这样做，因为它取决于因子类的结构。此处仅用于比较目的。

system.time({
a <- cumsum(c(1L, diff(v) != 1))
a <- structure(a, class = "factor", levels = 1L:a[length(a)])
split(v,a)
})
#   user  system elapsed 
#  0.356   0.000   0.357
于 2011-03-07T16:40:03.563 回答
7

约书亚和亚伦在​​现场。但是，通过仔细使用正确的类型、整数和逻辑，他们的代码仍然可以快两倍以上：

split(v, cumsum(c(TRUE, diff(v) != 1L)))

v <- rep(c(1:5, 19), len = 1e6) # Huge vector...
system.time( split(v, cumsum(c(1, diff(v) != 1))) ) # Joshua's code
# user  system elapsed 
#   2.64    0.00    2.64 

system.time( split(v, cumsum(c(TRUE, diff(v) != 1L))) ) # Modified code
# user  system elapsed 
# 1.09    0.00    1.12
于 2011-04-08T00:04:48.543 回答
4

您可以轻松定义切点：

which(diff(v) != 1)

基于该尝试：

v <- c(1,3,4,5,9,10,17,29,30)
cutpoints <- c(0, which(diff(v) != 1), length(v))
ragged.vector <- vector("list", length(cutpoints)-1)
for (i in 2:length(cutpoints)) ragged.vector[[i-1]] <- v[(cutpoints[i-1]+1):cutpoints[i]]

结果是：

> ragged.vector
[[1]]
[1] 1

[[2]]
[1] 3 4 5

[[3]]
[1]  9 10

[[4]]
[1] 17

[[5]]
[1] 29 30

这个算法不是一个很好的算法，但你可以基于diff:) 写出很多更简洁的代码 祝你好运！

于 2011-03-07T16:34:12.437 回答
4

您可以使用 和 来创建 adata.frame并将元素分配给组diff，ifelse然后cumsum使用 聚合tapply：

v.df <- data.frame(v = v)
v.df$group <- cumsum(ifelse(c(1, diff(v) - 1), 1, 0))
tapply(v.df$v, v.df$group, function(x) x)

$`1`
[1] 1

$`2`
[1] 3 4 5

$`3`
[1]  9 10

$`4`
[1] 17

$`5`
[1] 29 30
于 2011-03-07T16:47:32.770 回答