How to consecutively concatenate a vector of integers in R

vec <- c(1, 3, 2, 37)

I want to consecutively concatenate this vector such that the output looks something like this:

> output
[[1]]
[1] 1

[[2]]
[1] 1 3

[[3]]
[1] 1 3 2

[[4]]
[1] 1 3 2 37

I wrote a function to do this, but it didn't give me the correct output:

myfun <- function(vec){
  output = vector("list", length(vec))
  output[[1]] = vec[1]
  for(i in 2:length(vec)){
    output[[i]] = paste(output[[i - 1]], vec[i])
    output[[i]] = as.numeric(strsplit(output[[i]], " ")[[1]])
  }
  return(output)
}
> myfun(c(1, 3, 2, 37))
[[1]]
[1] 1

[[2]]
[1] 1 3

[[3]]
[1] 1 2

[[4]]
[1]  1 37

A direct way to do this would be Reduce:

Reduce(f = c,x = vec,accumulate = TRUE)

There's a purrr::accumulate function what will accomplish the same thing:

purrr::accumulate(.x = vec,.f = c,.simplify = FALSE)

(Edited to incorporate the comment to just use c() as the function, much simpler.)

We can use lapply and head (or [) for this:

lapply(seq_along(vec), head, x = vec)
# [[1]]
# [1] 1
# [[2]]
# [1] 1 3
# [[3]]
# [1] 1 3 2
# [[4]]
# [1]  1  3  2 37

• seq_along(vec) is analogous to 1:length(vec) (and we can use that too, but seq_along is safer in corner-cases);
• when lapply is given a function, it normally calls it once with the first argument containing the value (which will be 1 through 4, consecutively); since we include x=vec (which is the first argument of head), then lapply applies the number as the next argument to head, which happens to be n=.

We could also have done lapply(seq_along(vec), function(z) vec[1:z]).

Edit: the latter (vec[1:z] implementation) is significantly faster than using head, I should have known that.

bench::mark(
  a1=lapply(seq_along(vec), head, x = vec),
  a2=lapply(seq_along(vec), function(z) vec[1:z]), 
  a3=lapply(1:length(vec), function(z) vec[1:z]),
  b=Reduce(f = c,x = vec,accumulate = TRUE),
  iterations = 100000)
# # A tibble: 4 × 13
#   expression      min   median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time result     memory     time      
#   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl> <int> <dbl>   <bch:tm> <list>     <list>     <list>    
# 1 a1          11.51µs  16.14µs    53800.        0B     3.23 99994     6      1.86s <list [4]> <Rprofmem> <bench_tm>
# 2 a2           2.95µs   4.06µs   215605.        0B     4.31 99998     2    463.8ms <list [4]> <Rprofmem> <bench_tm>
# 3 a3           3.04µs   4.01µs   221482.        0B     2.21 99999     1    451.5ms <list [4]> <Rprofmem> <bench_tm>
# 4 b            3.42µs    4.3µs   209810.        0B     4.20 99998     2   476.61ms <list [4]> <Rprofmem> <bench_tm>
# # ℹ 1 more variable: gc <list>

I cannot think of better solutions than Reduce (by @joran) or lapply (by @r2evans), which are already sufficiently efficient and concise.

Here is another base R option but just for fun

> split(vec[(k <- sequence(seq_along(vec)))], cumsum(k == 1))
$`1`
[1] 1

$`2`
[1] 1 3

$`3`
[1] 1 3 2

$`4`
[1]  1  3  2 37

If the reason to do this is so that you can iterate over the list later taking, for example, sums

L <- list(vec[1], vec[1:2], vec[1:3], vec[1:4])
sapply(L, sum)
## [1]  1  4  6 43

then we can avoid creating L in the first place by using rollapplyr:

library(zoo)

rollapplyr(vec, seq_along(vec), sum)  # same but no intermediate L
## [1]  1  4  6 43

Note

vec taken from the question

vec <- c(1, 3, 2, 37)

Another base R approach using matrix just for completeness

mat <- matrix(vec, nrow=length(vec), ncol=length(vec), byrow=T)
mat[upper.tri(mat)] <- NA
apply(mat, 1, \(x) as.vector(na.omit(x)))
[[1]]
[1] 1

[[2]]
[1] 1 3

[[3]]
[1] 1 3 2

[[4]]
[1]  1  3  2 37