Использование rle для удаления первой и последней последовательностей

Я бы написал функцию, используя cumsum, где мы проверяем, сколько первых последовательных значений начинается с first_position и сколько последних последовательных значений начинается с last_position, и удаляем их.

get_reduced_data <- function(dat, first_position, last_position) {
    dat[cumsum(dat != first_position) != 0 &
   rev(cumsum(rev(dat) != last_position) != 0)]
 }

get_reduced_data(foo, first_position, last_position)
#[1] "B" "B" "A" "B" "A"

get_reduced_data(bar, first_position, last_position)
#[1] "B" "A" "B" "A"

get_reduced_data(baz, first_position, last_position)
#character(0)

get_reduced_data(qux, first_position, last_position)
#[1] "C" "A" "C" "A"

данные

foo <- c("A", "A","A", "B", "B", "A", "B", "A", "C")
bar <- c("A", "B","A", "B", "A", "C", "C", "C", "C", "C")
baz <- c(rep("A", 5), rep("C", 5))
qux <- c("A", "C", "A", "C", "A", "C")
first_position <- "A"
last_position <- "C"

Вот один вариант с rle. Идея состоит в том, чтобы подмножество 1-го и последнего values, проверить, равен ли он 'A', 'C', назначить его NA и преобразовать его в логический vector для подмножества

i1 <- !is.na(inverse.rle(within.list(rle(foo$position), 
     values[c(1, length(values))][values[c(1, length(values))] == c("A", "C")] <- NA)))
foo[i1, , drop = FALSE]
#    position
#4        B
#5        B
#6        A
#7        B
#8        A

Другое возможное решение без rle путем создания индекса и подмножества строк между первым появлением не-A и последним появлением не-C:

library(data.table)
output <- function(DT) {
    DT[, rn:=.I][,{
            mn <- min(which(position! = "A"))
            mx <- max(which(position! = "C"))
            if (mn > mx) return(NULL)
            .SD[mn:mx]
        }]
}

output(setDT(foo))
#   position rn
#1:        B  4
#2:        B  5
#3:        A  6
#4:        B  7
#5:        A  8

output(setDT(baz))
#NULL

данные:

foo <- fread("position
A
A
A
B
B
A
B
A
C
C")

baz <- fread("position
A
A
A
A
A
C
C
C
C
C")

Подход Таблица данных мог бы быть,

library(data.table)

setDT(df)[, grp := rleid(position)][
  !(grp == 1 & position == 'A' | grp == max(grp) & position == 'C'), ][
    , grp := NULL][]

который дает,

   position
1:        B
2:        B
3:        A
4:        B
5:        A

Проблема кажется двоякой. Обрезка «первого» и «последнего» элементов и определение того, что составляет «первый» и «последний». Мне нравится ваш подход rle(), потому что он отображает множество возможностей в общую структуру. Итак, задача состоит в том, чтобы написать функцию для маскировки первого и последнего элементов вектора любой длины.

mask_end = function(x) {
    n = length(x)
    mask = !logical(n)
    mask[c(min(1, n), max(0, n))] = FALSE  # allow for 0-length x
    mask
}

Это очень легко всесторонне протестировать

> mask_end(integer(0))
logical(0)
> mask_end(integer(1))
[1] FALSE
> mask_end(integer(2))
[1] FALSE FALSE
> mask_end(integer(3))
[1] FALSE  TRUE FALSE
> mask_end(integer(4))
[1] FALSE  TRUE  TRUE FALSE

Решение (возврат маски; легко изменить, чтобы вернуть фактические значения, x[inverse.rle(r)]) тогда

mask_end_runs = function(x) {
    r = rle(x)
    r$values = mask_end(r$values)
    inverse.rle(r)
}