Более эффективный способ памяти, чем strsplit (), чтобы разбить строку на два в R

Question

У меня есть строка символов длиной 1,8 м, и мне нужно разделить ее на строку символов длиной 50 м, которая появляется однажды очень близко к началу строки символов длиной 1,8 м (около 10 тыс. Символов)

Использование strsplit() ошибок

long_string %>% strsplit(., fifty_character_string)

# Error: C stack usage  9065064 is too close to the limit

Я пытался решить конкретную ошибку с помощью этого метода и этого вопроса, но пока не повезло.

Итак, теперь я исследую, существует ли более эффективный способ памяти разделить очень длинную строку на две части. Маловероятно, что мне придется делать это больше, чем небольшое количество раз, поэтому я открыт для хакерских методов, которые просто выполняют свою работу

Answer 1

Вот быстрое сравнение различных методов, чтобы сделать это:

library(stringi)
library(dplyr)

# get some sample data
set.seed(1)
long_string <- stri_paste(stri_rand_lipsum(10000), collapse = " ")
x <- sample(9000:11000, 1)
split_string <- substr(long_string, x, x + 49)

result <- long_string %>% strsplit(., split_string)
length(unlist(result))
#> [1] 2

substr_fun <- function(str, pattern) {
  idx <- regexpr(pattern, str, fixed = TRUE)
  res1 <- list(c(substr(str, 1, idx-1), substr(str, idx + attr(idx, "match.length"), nchar(str))))
  return(res1)  
}

bench::mark(
  strsplit_dplyr = long_string %>% strsplit(., split_string),
  strsplit_dplyr_fixed = long_string %>% strsplit(., split_string, fixed = TRUE),
  strsplit = strsplit(long_string, split_string),
  strsplit_fixed = strsplit(long_string, split_string, fixed = TRUE),
  stri_split_fixed = stringi::stri_split_fixed(long_string, split_string),
  str_split = stringr::str_split(long_string, stringr::fixed(split_string)),
  substr_fun = substr_fun(long_string, split_string)
)
#> # A tibble: 7 x 6
#>   expression                min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr>           <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 strsplit_dplyr          131ms  134.8ms      7.44      280B        0
#> 2 strsplit_dplyr_fixed   36.6ms   37.6ms     26.5       280B        0
#> 3 strsplit                133ms  133.8ms      7.40        0B        0
#> 4 strsplit_fixed         35.4ms   37.2ms     26.7         0B        0
#> 5 stri_split_fixed       40.7ms   42.5ms     23.6     6.95KB        0
#> 6 str_split              41.6ms   43.1ms     23.4    35.95KB        0
#> 7 substr_fun             13.6ms   14.8ms     67.1         0B        0

С точки зрения использования памяти, strsplit с опцией fixed = TRUE и без накладных расходов на трубопровод является лучшим решением.Реализации в stringi и stringr кажутся немного быстрее, но их накладные расходы с точки зрения памяти даже больше, чем эффект от конвейерной обработки.

Обновление

Я добавил метод из @ H 1 ответ, а также его подход к получению 50-символьной подстроки, используемой для разбиения.Единственное изменение - я обернул его в функцию и снова добавил fixed = TRUE, так как я думаю, что в этом случае это имеет больше смысла.

Новая функция - явный победитель, если вы не хотите делать более одного разбиенияв твоей строке!

Answer 2

Поскольку строку нужно разделить только на два, эффективный способ приблизиться к этому - использовать комбинацию regexpr() и substr().

# Generate string (10m char) and pattern
set.seed(10)
long_string <- paste0(sample(letters, 1e+7, replace = TRUE), collapse ="")
x <- sample(9000:11000, 1)
fifty_character_string <- substr(long_string, x, x + 49)

# Find index and split
idx <- regexpr(fifty_character_string, long_string)
res1 <- list(c(substr(long_string, 1, idx-1), substr(long_string, idx + attr(idx, "match.length"), nchar(long_string))))