Разбить вектор на куски в R

Question

Разбить вектор на куски в R

Я должен разделить вектор на n кусков одинакового размера в R. Я не смог найти ни одной базовой функции для этого. Кроме того, Google нигде не получил меня. Так вот, что я придумал, надеюсь, это поможет кому-то где-то.

x <- 1:10
n <- 3
chunk <- function(x,n) split(x, factor(sort(rank(x)%%n)))
chunk(x,n)
$`0`
[1] 1 2 3

$`1`
[1] 4 5 6 7

$`2`
[1]  8  9 10

Любые комментарии, предложения или улучшения действительно приветствуются и приветствуются.

Ура, Себастьян

301

r vector

Источник

user400269 23 июл '10 в 13:01

22 ответа

Другие вопросы по тегам r vector

user135944 23 июл '10 в 19:22 2010-07-23 19:22 · Answer 1 · 2010-07-23 19:22

Однострочник разделяется на куски размером 20:

split(d, ceiling(seq_along(d)/20))

Более подробная информация: я думаю, все, что вам нужно seq_along(), split() а также ceiling():

> d <- rpois(73,5)
> d
 [1]  3  1 11  4  1  2  3  2  4 10 10  2  7  4  6  6  2  1  1  2  3  8  3 10  7  4
[27]  3  4  4  1  1  7  2  4  6  0  5  7  4  6  8  4  7 12  4  6  8  4  2  7  6  5
[53]  4  5  4  5  5  8  7  7  7  6  2  4  3  3  8 11  6  6  1  8  4
> max <- 20
> x <- seq_along(d)
> d1 <- split(d, ceiling(x/max))
> d1
$`1`
 [1]  3  1 11  4  1  2  3  2  4 10 10  2  7  4  6  6  2  1  1  2

$`2`
 [1]  3  8  3 10  7  4  3  4  4  1  1  7  2  4  6  0  5  7  4  6

$`3`
 [1]  8  4  7 12  4  6  8  4  2  7  6  5  4  5  4  5  5  8  7  7

$`4`
 [1]  7  6  2  4  3  3  8 11  6  6  1  8  4

user1563634 29 апр '13 в 09:37 2013-04-29 09:37 · Answer 2 · 2013-04-29 09:37

chunk2 <- function(x,n) split(x, cut(seq_along(x), n, labels = FALSE))

117

Источник

user1563634 29 апр '13 в 09:37

user6228417 20 апр '16 в 21:03 2016-04-20 21:03 · Answer 3 · 2016-04-20 21:03

simplified version...
n = 3
split(x, sort(x%%n))

54

Источник

user6228417 20 апр '16 в 21:03

user1717729 01 ноя '18 в 04:47 2018-11-01 04:47 · Answer 4 · 2018-11-01 04:47

Использование базы R rep_len:

x <- 1:10
n <- 3

split(x, rep_len(1:n, length(x)))
# $`1`
# [1]  1  4  7 10
# 
# $`2`
# [1] 2 5 8
# 
# $`3`
# [1] 3 6 9

И, как уже упоминалось, если вы хотите отсортировать индексы, просто:

split(x, sort(rep_len(1:n, length(x))))
# $`1`
# [1] 1 2 3 4
# 
# $`2`
# [1] 5 6 7
# 
# $`3`
# [1]  8  9 10

27

Источник

user1717729 01 ноя '18 в 04:47

user3873994 09 янв '15 в 13:41 2015-01-09 13:41 · Answer 5 · 2015-01-09 13:41

Попробуйте функцию ggplot2, cut_number:

library(ggplot2)
x <- 1:10
n <- 3
cut_number(x, n) # labels = FALSE if you just want an integer result
#>  [1] [1,4]  [1,4]  [1,4]  [1,4]  (4,7]  (4,7]  (4,7]  (7,10] (7,10] (7,10]
#> Levels: [1,4] (4,7] (7,10]

# if you want it split into a list:
split(x, cut_number(x, n))
#> $`[1,4]`
#> [1] 1 2 3 4
#> 
#> $`(4,7]`
#> [1] 5 6 7
#> 
#> $`(7,10]`
#> [1]  8  9 10

23

Источник

user3873994 09 янв '15 в 13:41

user2757239 23 дек '14 в 18:26 2014-12-23 18:26 · Answer 6 · 2014-12-23 18:26

Если тебе не нравится split() а тебе не нравится matrix() (с его свисающими NA), есть это:

chunk <- function(x, n) (mapply(function(a, b) (x[a:b]), seq.int(from=1, to=length(x), by=n), pmin(seq.int(from=1, to=length(x), by=n)+(n-1), length(x)), SIMPLIFY=FALSE))

подобно split(), он возвращает список, но не тратит время и пространство на метки, поэтому он может быть более производительным.

user300123 23 июл '10 в 14:39 2010-07-23 14:39 · Answer 7 · 2010-07-23 14:39

Это разделит его по-другому на то, что у вас есть, но я думаю, что все еще довольно хорошая структура списка:

chunk.2 <- function(x, n, force.number.of.groups = TRUE, len = length(x), groups = trunc(len/n), overflow = len%%n) { 
  if(force.number.of.groups) {
    f1 <- as.character(sort(rep(1:n, groups)))
    f <- as.character(c(f1, rep(n, overflow)))
  } else {
    f1 <- as.character(sort(rep(1:groups, n)))
    f <- as.character(c(f1, rep("overflow", overflow)))
  }

  g <- split(x, f)

  if(force.number.of.groups) {
    g.names <- names(g)
    g.names.ordered <- as.character(sort(as.numeric(g.names)))
  } else {
    g.names <- names(g[-length(g)])
    g.names.ordered <- as.character(sort(as.numeric(g.names)))
    g.names.ordered <- c(g.names.ordered, "overflow")
  }

  return(g[g.names.ordered])
}

Что даст вам следующее, в зависимости от того, как вы хотите его отформатировать:

> x <- 1:10; n <- 3
> chunk.2(x, n, force.number.of.groups = FALSE)
$`1`
[1] 1 2 3

$`2`
[1] 4 5 6

$`3`
[1] 7 8 9

$overflow
[1] 10

> chunk.2(x, n, force.number.of.groups = TRUE)
$`1`
[1] 1 2 3

$`2`
[1] 4 5 6

$`3`
[1]  7  8  9 10

Выполнение нескольких таймингов с использованием этих настроек:

set.seed(42)
x <- rnorm(1:1e7)
n <- 3

Тогда мы получим следующие результаты:

> system.time(chunk(x, n)) # your function 
   user  system elapsed 
 29.500   0.620  30.125 

> system.time(chunk.2(x, n, force.number.of.groups = TRUE))
   user  system elapsed 
  5.360   0.300   5.663

РЕДАКТИРОВАТЬ: переход от as.factor() к as.character() в моей функции сделал это в два раза быстрее.

user334755 23 июл '10 в 14:38 2010-07-23 14:38 · Answer 8 · 2010-07-23 14:38

Еще несколько вариантов в кучу...

> x <- 1:10
> n <- 3

Обратите внимание, что вам не нужно использовать factor здесь, но вы все еще хотите sort твой первый вектор будет 1 2 3 10:

> chunk <- function(x, n) split(x, sort(rank(x) %% n))
> chunk(x,n)
$`0`
[1] 1 2 3
$`1`
[1] 4 5 6 7
$`2`
[1]  8  9 10

Или вы можете назначить индексы символов, используя цифры в левом поле:

> my.chunk <- function(x, n) split(x, sort(rep(letters[1:n], each=n, len=length(x))))
> my.chunk(x, n)
$a
[1] 1 2 3 4
$b
[1] 5 6 7
$c
[1]  8  9 10

Или вы можете использовать простые имена, хранящиеся в векторе. Обратите внимание, что с помощью sort чтобы получить последовательные значения в x алфавитные метки:

> my.other.chunk <- function(x, n) split(x, sort(rep(c("tom", "dick", "harry"), each=n, len=length(x))))
> my.other.chunk(x, n)
$dick
[1] 1 2 3
$harry
[1] 4 5 6
$tom
[1]  7  8  9 10

user2473891 10 сен '18 в 21:31 2018-09-10 21:31 · Answer 9 · 2018-09-10 21:31

Еще одна возможность splitIndices функция из пакета parallel:

library(parallel)
splitIndices(20, 3)

дает:

[[1]]
[1] 1 2 3 4 5 6 7

[[2]]
[1]  8  9 10 11 12 13

[[3]]
[1] 14 15 16 17 18 19 20

11

Источник

user2473891 10 сен '18 в 21:31

user386327 23 июл '10 в 14:22 2010-07-23 14:22 · Answer 10 · 2010-07-23 14:22

Вы можете объединить split/cut, как предлагает mdsummer, с квантилем для создания четных групп:

split(x,cut(x,quantile(x,(0:n)/n), include.lowest=TRUE, labels=FALSE))

Это дает тот же результат для вашего примера, но не для перекошенных переменных.

10

Источник

user386327 23 июл '10 в 14:22

user1185154 14 сен '13 в 16:41 2013-09-14 16:41 · Answer 11 · 2013-09-14 16:41

Вот еще один вариант.

ПРИМЕЧАНИЕ: в этом примере вы указываете CHUNK SIZE во втором параметре

все куски одинаковы, кроме последнего;
последний в худшем случае будет меньше, а не больше, чем размер куска.

chunk <- function(x,n)
{
    f <- sort(rep(1:(trunc(length(x)/n)+1),n))[1:length(x)]
    return(split(x,f))
}

#Test
n<-c(1,2,3,4,5,6,7,8,9,10,11)

c<-chunk(n,5)

q<-lapply(c, function(r) cat(r,sep=",",collapse="|") )
#output
1,2,3,4,5,|6,7,8,9,10,|11,|

user275455 23 июл '10 в 16:30 2010-07-23 16:30 · Answer 12 · 2010-07-23 16:30

split(x,matrix(1:n,n,length(x))[1:length(x)])

возможно это более понятно, но идея та же
split(x,rep(1:n, ceiling(length(x)/n),length.out = length(x)))

если хотите, чтобы он был заказан, разбросайте его

7

Источник

user275455 23 июл '10 в 16:30

user2513107 23 июн '13 в 07:41 2013-06-23 07:41 · Answer 13 · 2013-06-23 07:41

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

chunk <- function(x,n){
  numOfVectors <- floor(length(x)/n)
  elementsPerVector <- c(rep(n,numOfVectors-1),n+length(x) %% n)
  elemDistPerVector <- rep(1:numOfVectors,elementsPerVector)
  split(x,factor(elemDistPerVector))
}
set.seed(1)
x <- rnorm(10)
n <- 3
chunk(x,n)
$`1`
[1] -0.6264538  0.1836433 -0.8356286

$`2`
[1]  1.5952808  0.3295078 -0.8204684

$`3`
[1]  0.4874291  0.7383247  0.5757814 -0.3053884

user8800534 08 фев '18 в 14:30 2018-02-08 14:30 · Answer 14 · 2018-02-08 14:30

Простая функция для разделения вектора путем простого использования индексов - не нужно слишком усложнять это

vsplit <- function(v, n) {
    l = length(v)
    r = l/n
    return(lapply(1:n, function(i) {
        s = max(1, round(r*(i-1))+1)
        e = min(l, round(r*i))
        return(v[s:e])
    }))
}

5

Источник

user8800534 08 фев '18 в 14:30

user7380504 21 авг '18 в 13:29 2018-08-21 13:29 · Answer 15 · 2018-08-21 13:29

Извините, если этот ответ приходит так поздно, но, возможно, он может быть полезен для кого-то еще. На самом деле есть очень полезное решение этой проблемы, объясненное в конце? Split.

> testVector <- c(1:10) #I want to divide it into 5 parts
> VectorList <- split(testVector, 1:5)
> VectorList
$`1`
[1] 1 6

$`2`
[1] 2 7

$`3`
[1] 3 8

$`4`
[1] 4 9

$`5`
[1]  5 10

user2757239 23 дек '14 в 17:42 2014-12-23 17:42 · Answer 16 · 2014-12-23 17:42

Если тебе не нравится split() и вы не возражаете против того, чтобы ваши подхалимы были короткими:

chunk <- function(x, n) { if((length(x)%%n)==0) {return(matrix(x, nrow=n))} else {return(matrix(append(x, rep(NA, n-(length(x)%%n))), nrow=n))} }

Столбцы возвращаемой матрицы ([,1:ncol]) - это те дроиды, которых вы ищете.

2

Источник

user2757239 23 дек '14 в 17:42

user305675 26 мар '17 в 21:24 2017-03-26 21:24 · Answer 17 · 2017-03-26 21:24

Мне нужна функция, которая принимает аргумент data.table (в кавычках) и другой аргумент, который является верхним пределом количества строк в подмножествах этого исходного data.table. Эта функция генерирует любое число data.tables, которое позволяет верхний предел:

library(data.table)    
split_dt <- function(x,y) 
    {
    for(i in seq(from=1,to=nrow(get(x)),by=y)) 
        {df_ <<- get(x)[i:(i + y)];
            assign(paste0("df_",i),df_,inherits=TRUE)}
    rm(df_,inherits=TRUE)
    }

Эта функция дает мне ряд data.tables с именем df_[число] с начальной строкой из исходного data.table в имени. Последняя таблица data.table может быть короткой и заполненной NA, поэтому вам нужно вернуть ее обратно к любым оставшимся данным. Этот тип функций полезен, потому что определенное программное обеспечение ГИС имеет ограничения, например, на количество выводов адреса, которые вы можете импортировать. Поэтому разделение data.tables на более мелкие фрагменты не рекомендуется, но этого нельзя избежать.

05 дек '14 в 15:24 2014-12-05 15:24 · Answer 18 · 2014-12-05 15:24

Кредит @Sebastian для этой функции

chunk <- function(x,y){
         split(x, factor(sort(rank(row.names(x))%%y)))
         }

2

Источник

05 дек '14 в 15:24

user400269 19 сен '18 в 11:08 2018-09-19 11:08 · Answer 19 · 2018-09-19 11:08

Вау, этот вопрос получил больше тяги, чем ожидалось.

Спасибо за все идеи. Я пришел с этим решением:

require(magrittr)
create.chunks <- function(x, elements.per.chunk){
    # plain R version
    # split(x, rep(seq_along(x), each = elements.per.chunk)[seq_along(x)])
    # magrittr version - because that's what people use now
    x %>% seq_along %>% rep(., each = elements.per.chunk) %>% extract(seq_along(x)) %>% split(x, .) 
}
create.chunks(letters[1:10], 3)
$`1`
[1] "a" "b" "c"

$`2`
[1] "d" "e" "f"

$`3`
[1] "g" "h" "i"

$`4`
[1] "j"

Ключ должен использовать параметр seq(each = chunk.size), чтобы он работал. Использование seq_along действует как rank(x) в моем предыдущем решении, но на самом деле может дать правильный результат с дублирующимися записями.

user13393038 25 окт '22 в 23:08 2022-10-25 23:08 · Answer 20 · 2022-10-25 23:08

Не уверен, что это отвечает на вопрос ОП, но я думаю, что%%здесь может быть полезно

      df # some data.frame
N_CHUNKS <- 10
I_VEC <- 1:nrow(df)
df_split <- split(df, sort(I_VEC %% N_CHUNKS))

0

Источник

user13393038 25 окт '22 в 23:08

user5472037 05 окт '21 в 13:38 2021-10-05 13:38 · Answer 21 · 2021-10-05 13:38

Вот еще один, позволяющий вам контролировать, хотите ли вы, чтобы результат был упорядочен или нет:

      split_to_chunks <- function(x, n, keep.order=TRUE){
  if(keep.order){
    return(split(x, sort(rep(1:n, length.out = length(x)))))
  }else{
    return(split(x, rep(1:n, length.out = length(x))))
  }
}

split_to_chunks(x = 1:11, n = 3)
$`1`
[1] 1 2 3 4

$`2`
[1] 5 6 7 8

$`3`
[1]  9 10 11

split_to_chunks(x = 1:11, n = 3, keep.order=FALSE)

$`1`
[1]  1  4  7 10

$`2`
[1]  2  5  8 11

$`3`
[1] 3 6 9

user2361465 31 июл '19 в 11:27 2019-07-31 11:27 · Answer 22 · 2019-07-31 11:27

This splits into chunks of size ⌊n/k⌋+1 or ⌊n/k⌋ and does not use the O(n log n) sort.

get_chunk_id<-function(n, k){
    r <- n %% k
    s <- n %/% k
    i<-seq_len(n)
    1 + ifelse (i <= r * (s+1), (i-1) %/% (s+1), r + ((i - r * (s+1)-1) %/% s))
}

split(1:10, get_chunk_id(10,3))

-1

Источник

user2361465 31 июл '19 в 11:27