Лучший способ сократить последовательные НС до единичного NA

Мне нужно уменьшить последовательный NA в векторе до одного NA, не касаясь других значений.
Так, например, задан такой вектор:

NA NA  8  7 NA NA NA NA NA  3  3 NA -1  4

что мне нужно получить, это следующий результат:

NA  8  7 NA  3  3 NA -1  4

В настоящее время я использую следующую функцию:

reduceConsecutiveNA2One <- function(vect){
  enc <- rle(is.na(vect))

  # helper func
  tmpFun <- function(i){
    if(enc$values[i]){
      data.frame(L=c(enc$lengths[i]-1, 1), V=c(TRUE,FALSE))
    }else{
      data.frame(L=enc$lengths[i], V=enc$values[i])
    }
  }

  Df <- do.call(rbind.data.frame,lapply(1:length(enc$lengths),FUN=tmpFun))

  return(vect[rep.int(!Df$V,Df$L)])
}

и, похоже, он работает нормально, но, вероятно, есть более простой/быстрый способ выполнить эту задачу.

Любые предложения?

Спасибо заранее.

Ответы

Ответ 1

Вот одна идея:

x <- c(NA, NA,8,7,NA, NA, NA, NA, NA, 3, 3, NA, -1,  4)

x[!(is.na(x) & diff(c(FALSE, is.na(x)))==0)]
# [1] NA  8  7 NA  3  3 NA -1  4

## It also works for length-one vectors
x <- NA
x[!(is.na(x) & diff(c(FALSE, is.na(x)))==0)]
# [1] NA

Ответ 2

Возможно, это может быть полезно

x <- c(NA, NA,8,7,NA, NA, NA, NA, NA, 3, 3, NA, -1,  4)
c(x[rowSums(is.na(embed(x,2)))!=2], x[length(x)])
[1] NA  8  7 NA  3  3 NA -1  4

Если вы хотите, чтобы функция попыталась:

myfun <- function(x){
  if(length(x)==1) {
    return(x)
  }
  else{
    return(c(x[rowSums(is.na(embed(x,2)))!=2], x[length(x)]))
  }
}

> myfun(x)
[1] NA  8  7 NA  3  3 NA -1  4
> y <- c(x, NA, NA, NA, 3)
> y
 [1] NA NA  8  7 NA NA NA NA NA  3  3 NA -1  4 NA NA NA  3
> myfun(y)
 [1] NA  8  7 NA  3  3 NA -1  4 NA  3
> myfun(NA)
[1] NA
> myfun(1)
[1] 1

Ответ 3

Веселое упражнение с использованием head и tail:

merge.na <- function(x) c(head(x, 1), tail(x, -1)[!(is.na(tail(x, -1)) &
                                                    is.na(head(x, -1)))])

Ответ 4

Не так классно, как другие ответы, но другой подход, используя rle:

x <- c(NA, NA,  8,  7, NA, NA, NA, NA, NA,  3,  3, NA, -1,  4)
x[is.na(x)] <- 999
y <- rle(x)
y[[1]][y[[2]]==999] <- 1
y[[2]][y[[2]]==999] <- NA
rep(y[[2]], y[[1]])

#per Dason Suggestion:
inverse.rle(y)

На самом деле мне удивительно, что rle не объединяет NA. Он делает это:

> rle(x)
Run Length Encoding
  lengths: int [1:13] 1 1 1 1 1 1 1 1 1 2 ...
  values : num [1:13] NA NA 8 7 NA NA NA NA NA 3 ...

Следовательно, необходимость перекодировать до 999