data.table基于组的滞后值删除行

Question

I have a data.table in the following form:

DT <- data.table(tag = rep(c("A", "B"), each = 10),
                 value =  c(0, 3, 3, 3, 0, 1, 1, 1, 3, 0,
                            0, 1, 3, 1, 0, 3, 0, 1, 1, 0))
> DT
    tag value
 1:   A     0
 2:   A     3
 3:   A     3
 4:   A     3
 5:   A     0
 6:   A     1
 7:   A     1
 8:   A     1
 9:   A     3
10:   A     0
11:   B     0
12:   B     1
13:   B     3
14:   B     1
15:   B     0
16:   B     3
17:   B     0
18:   B     1
19:   B     1
20:   B     0

I would like to remove all the rows that have value of 3 but only those follow a 0. That is I would like to remove row 2, 3, 4 and row 16, but need to keep row 9 and row 13.

Is there is a way to perform this?

Answer 1

A possible solution:

DT[, `:=` (threes = rleid(value==3), apz = value == 3 & shift(value) == 0)
   ][, if (all(!apz)) .SD, by = threes
     ][, c('threes','apz') := NULL]

which gives:

    tag value
 1:   A     0
 2:   A     0
 3:   A     1
 4:   A     1
 5:   A     1
 6:   A     3
 7:   A     0
 8:   B     0
 9:   B     1
10:   B     3
11:   B     1
12:   B     0
13:   B     0
14:   B     1
15:   B     1
16:   B     0

Answer 2

DT[, prev.value := shift(value), by = tag][
   , prev.value := prev.value[1], by = .(tag, rleid(value))][
   !(value == 3 & prev.value == 0)]
#    tag value prev.value
# 1:   A     0         NA
# 2:   A     0          3
# 3:   A     1          0
# 4:   A     1          0
# 5:   A     1          0
# 6:   A     3          1
# 7:   A     0          3
# 8:   B     0         NA
# 9:   B     1          0
#10:   B     3          1
#11:   B     1          3
#12:   B     0          1
#13:   B     0          3
#14:   B     1          0
#15:   B     1          0
#16:   B     0          1

Answer 3

Here's a one-liner of sorts (props to @Procrastinatus for the improvement):

DT[setDT(rle(value))[, rep(!( values==3 & shift(values)==0 ), lengths)] ]

To understand how it works, try running DT[, setDT(rle(value))] , showing how R summarizes runs of sequential values, and read ?rle .

---

My original approach was:

DT[ rleid(value) %in% setDT(rle(value))[ , .I[!( values==3 & shift(values)==0 )]] ]

Try DT[, rleid(value)] and read ?rleid for details. This second approach is worse because the runs are evaluated twice (using both rle and rleid ).