Filtrar linhas com base no conjunto combinado de valores em uma string

Uma opção para esses dados de exemplo específicos é criar um igraphgráfico a partir de sobreposições de linhas, detectar componentes conectados no gráfico resultante e usar o cluster id do componente como uma variável de agrupamento. A partir daí, podemos escolher a primeira linha de cada grupo.

library(dplyr)
library(igraph)

df <- data.frame(overlap = c("1,2,3", "1,2,3", "1,2,3,4", "3,4", 
                              "5,6", "5,6,7", "6,7", 
                              "8,9", "8,9,10", "9,10", 
                              "11,12,13", "11,12,13", 
                              "11,12,13,14", "13,14", 
                              "15,16", "15,16,17", "16,17", 
                              "18,19", "18,19,20", "19,20"))


df |> 
  mutate(id = row_number(), .before = 1) |> 
  group_by(
    g_clust = 
      strsplit(overlap, ",") |> 
      # either create a directed graph or set duplicate = FALSE for 
      # corner cases like `overlap = c("1", "1,2,3", ...)`
      graph_from_adj_list(mode = "all", duplicate = FALSE) |> 
      components() |> 
      getElement("membership")
    ) |> 
  slice_head(n = 1)
#> # A tibble: 6 × 3
#> # Groups:   g_clust [6]
#>      id overlap  g_clust
#>   <int> <chr>      <dbl>
#> 1     1 1,2,3          1
#> 2     5 5,6            2
#> 3     8 8,9            3
#> 4    11 11,12,13       4
#> 5    15 15,16          5
#> 6    18 18,19          6

Gráfico de sobreposições para referência:

strsplit(df$overlap, ",") |> 
  graph_from_adj_list(mode = "all", duplicate = FALSE) |>
  plot()

Podemos tentar {ivs}:

x = vapply(strsplit(unique(overlap), ","), 
           \(i) as.numeric(i[c(1, length(i))]), numeric(2))

library(ivs)
int = iv_groups(iv(x[1, ], x[2, ]))

dando

> as.data.frame(int)
         y
1   [1, 4)
2   [5, 7)
3  [8, 10)
4 [11, 14)
5 [15, 17)
6 [18, 20)

Isso vapplyé um pouco redundante, pois chamamos as.numericvárias vezes. Você realmente quer inteiros separados por vírgula armazenados como caractere?

transform(as.data.frame(int), 
          s = Vectorize(\(x, y) toString(x:y))(iv_start(int), iv_end(int) - 1))

dando

       int          s
1   [1, 4)    1, 2, 3
2   [5, 7)       5, 6
3  [8, 10)       8, 9
4 [11, 14) 11, 12, 13
5 [15, 17)     15, 16
6 [18, 20)     18, 19

Editar

@Chris está certo no comentário abaixo. Eu deveria acrescentar alguma explicação.

(1) Reestruture os dados. Divida as strings, encontre o primeiro e o último valor, coaja characterpara numeric.

x = # we assign the output of the pipe x |> ... |> ... to x 
  overlap |> # access the data
  unique() |> # get rid of duplicates (not needed)
  strsplit(",") |> # split on ",", we might want to add fixed=TRUE
  # returns a list of character vectors, so we iterate over it with lapply
  lapply(\(x) x[c(1, length(x))]) |> # get first and last element
  # "1,2,3" ---> "1" "2" "3" has length 3 while "3" "4" has length 2
  do.call(what="rbind") |> # list to 2-column matrix 
  type.convert(as.is=TRUE) # we coerce from character to numeric 

dá

> x
      [,1] [,2]
 [1,]    1    3
 [2,]    1    4
 [3,]    3    4
 [4,]    5    6
 [5,]    5    7
 [6,]    6    7
 [7,]    8    9
 [8,]    8   10
 [9,]    9   10
[10,]   11   13
[11,]   11   14
[12,]   13   14
[13,]   15   16
[14,]   15   17
[15,]   16   17
[16,]   18   19
[17,]   18   20
[18,]   19   20
> 
> # of 
> class(x)
[1] "matrix" "array" 

Isso obviamente assume que o menor inteiro está na primeira posição e o maior na última -- uma suposição razoável? Caso contrário, deveríamos forçar para numérico primeiro e aplicar rangeem cada elemento da lista.

(2) Para criar vetores de intervalo , usamos . De sua documentação (cp. ):iv()help(iv)

iv() cria um vetor de intervalo a partir de vetores inicial e final. É assim que você normalmente criará vetores de intervalo, e é frequentemente usado com colunas em um data frame.

ou seja

> library(ivs)
> y = iv(x[, 1], x[, 2])
> y
<iv<integer>[18]>
 [1] [1, 3)   [1, 4)   [3, 4)   [5, 6)   [5, 7)   [6, 7)   [8, 9)   [8, 10) 
 [9] [9, 10)  [11, 13) [11, 14) [13, 14) [15, 16) [15, 17) [16, 17) [18, 19)
[17] [18, 20) [19, 20)

Por fim, usamos iv_groups. De help(iv_groups):

Esta família de funções gira em torno do agrupamento de intervalos sobrepostos dentro de um único iv. Quando múltiplos intervalos sobrepostos são agrupados, eles resultam em um intervalo mais amplo contendo o menor iv_start() e o maior iv_end() das sobreposições.

> z = iv_groups(y)
> z
<iv<integer>[6]>
[1] [1, 4)   [5, 7)   [8, 10)  [11, 14) [15, 17) [18, 20)

(3) Parece que a saída desejada é um vetor de caracteres, onde todas as sequências inteiras dos intervalos restantes são coladas juntas.

Para conseguir isso, usamos ivs::iv_start()e ivs::iv_end()para acessar os limites de cada intervalo. Agora gostaríamos de gerar sequências regulares. Infelizmente, :não é vetorizado, por isso introduzimos:

seq2str = Vectorize(\(from, to) toString(from:to))

toSpring()é um wrapper para format(), sua página de ajuda afirma

O método padrão primeiro converte x em caractere e depois concatena os elementos separados por ", ".

A aplicação de nossa função personalizada a cada início e fim fornece

> seq2str(from = iv_start(z), to = iv_end(z) - 1)
[1] "1, 2, 3"    "5, 6"       "8, 9"       "11, 12, 13" "15, 16"     "18, 19"      

Observação

Você também pode usar esta versão mais curta.

# input data 
overlap = c("1,2,3", "1,2,3", "1,2,3,4", "3,4", "5,6", "5,6,7", "6,7", "8,9", 
            "8,9,10", "9,10", "11,12,13", "11,12,13", "11,12,13,14", "13,14",
            "15,16", "15,16,17", "16,17", "18,19", "18,19,20", "19,20")
# piped version
library(ivs)
overlap |> 
  strsplit(",") |> 
  lapply(\(x) x[c(1, length(x))]) |> 
  do.call(what="rbind") |>
  type.convert(as.is=TRUE) |>
  list(. = _) |>
  with(iv(.[, 1], .[, 2])) |>
  iv_groups() |>
  list(. = _) |>
  with(Vectorize(\(from, to) toString(from:to))(iv_start(.), to = iv_end(.) - 1))

onde usamos um truque para poder usar o operador de pipe para frente da base.

Aqui está uma igraphopção

df %>%
    mutate(id = str_c("r", row_number()), .before = 1) %>%
    separate_longer_delim(overlap, ",") %>%
    graph_from_data_frame() %>%
    components() %>%
    membership() %>%
    enframe() %>%
    filter(startsWith(name, "r")) %>%
    mutate(name = as.integer(sub("\\D", "", name))) %>%
    arrange(name) %>%
    slice_head(n = 1, by = value) %>%
    pull(name) %>%
    slice(.data = df)

Se executarmos um conjunto de dados fictício como abaixo (um pouco diferente do exemplo dos dados do OP, veja o primeiro overlapvalor)

df <- data.frame(overlap = c(
    "1", "1,2,3", "1,2,3,4", "3,4",
    "5,6", "5,6,7", "6,7",
    "8,9", "8,9,10", "9,10",
    "11,12,13", "11,12,13",
    "11,12,13,14", "13,14",
    "15,16", "15,16,17", "16,17",
    "18,19", "18,19,20", "19,20"
))

nós obteremos

   overlap
1        1
2      5,6
3      8,9
4 11,12,13
5    15,16
6    18,19

e os dados originais da pergunta do OP (começando "1,2,3"como o primeiro valor) fornecem

   overlap
1    1,2,3
2      5,6
3      8,9
4 11,12,13
5    15,16
6    18,19