できない.dev

配列を指定サイズで分割するには

配列(リスト)を指定した個数ごとの小さな配列に分割する基本形を各言語で示す。
最後の端数の扱いや、サイズに 0 を渡したときの挙動までを扱う。

公開:

選んだ言語は、ほかのサンプルコードを開いたときも最初に表示する。

Python

def chunk(items, size):
    return [items[i:i + size] for i in range(0, len(items), size)]
 
 
print(chunk([1, 2, 3, 4, 5], 2))  # [[1, 2], [3, 4], [5]]
print(chunk([], 3))               # []

range に step としてサイズを渡し、スライスで切り出すと標準ライブラリだけで書ける。
スライスは範囲を超えても例外にならないため、最後の端数もそのまま短いリストとして残る。

JavaScript

const chunk = (arr, size) =>
  Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
    arr.slice(i * size, i * size + size),
  );
 
console.log(chunk([1, 2, 3, 4, 5], 2)); // [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
console.log(chunk([], 3));              // []

必要な個数を Math.ceil で求め、Array.from で各ブロックを slice して作る。
slice も範囲外を切り詰めるので、末尾の端数を別処理する必要がない。

TypeScript

function chunk<T>(arr: T[], size: number): T[][] {
  const result: T[][] = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}
 
console.log(chunk([1, 2, 3, 4, 5], 2)); // [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
console.log(chunk<string>([], 3));      // []

ジェネリクスにすると要素の型を保ったまま number[][] や string[][] を返せる。
for ループで i をサイズずつ進める形は、結果の型を明示しやすく読みやすい。

Go

package main
 
import "fmt"
 
func chunk[T any](s []T, size int) [][]T {
	var out [][]T
	for i := 0; i < len(s); i += size {
		end := min(i+size, len(s)) // min は Go 1.21 以降の組み込み関数
		out = append(out, s[i:end])
	}
	return out
}
 
func main() {
	fmt.Println(chunk([]int{1, 2, 3, 4, 5}, 2)) // [[1 2] [3 4] [5]]
	fmt.Println(len(chunk([]int{}, 3)))         // 0
}

ジェネリクスで任意の型のスライスを扱い、終端を min で丸めて端数を切り出す。
部分スライスは元の配列を共有するため、書き換えるなら copy で複製してから使う。

Rust

fn main() {
    let nums = vec![1, 2, 3, 4, 5];
    let chunks: Vec<Vec<i32>> = nums.chunks(2).map(|c| c.to_vec()).collect();
    println!("{:?}", chunks); // [[1, 2], [3, 4], [5]]
 
    let empty: Vec<i32> = Vec::new();
    println!("{}", empty.chunks(3).count()); // 0
}

スライスの chunks メソッドがそのまま使える。
各ブロックは元のデータを借りるだけなので、所有する Vec にしたいときは to_vec で複製する。

Java

import java.util.ArrayList;
import java.util.List;
 
public class Main {
    static <T> List<List<T>> chunk(List<T> list, int size) {
        List<List<T>> result = new ArrayList<>();
        for (int i = 0; i < list.size(); i += size) {
            result.add(list.subList(i, Math.min(i + size, list.size())));
        }
        return result;
    }
 
    public static void main(String[] args) {
        System.out.println(chunk(List.of(1, 2, 3, 4, 5), 2)); // [[1, 2], [3, 4], [5]]
        System.out.println(chunk(List.<Integer>of(), 3));     // []
    }
}

標準ライブラリに分割用のメソッドはないため、subList で切り出す。
終端は Math.min で丸めて端数に対応する。
subList は元のリストのビューなので、独立させたいなら new ArrayList でコピーする。

C#

using System;
using System.Linq;
 
int[] nums = { 1, 2, 3, 4, 5 };
var chunks = nums.Chunk(2); // .NET 6 以降の LINQ
Console.WriteLine(string.Join(" ", chunks.Select(c => "[" + string.Join(",", c) + "]"))); // [1,2] [3,4] [5]
Console.WriteLine(Array.Empty<int>().Chunk(3).Count()); // 0

LINQ の Chunk は指定サイズごとに配列の列を返す。
.NET 6 以降で使え、末尾の端数は短い配列として残る。

つまずき

サイズに 0 を渡す場合の挙動は言語ごとに違う。

  • Python は range の step が 0 になり ValueError で止まる。
  • JavaScript は配列の長さが Infinity になり RangeError で止まる。
  • Rust の chunks は 0 を渡すと panic する。
  • Go や Java のように i += size でループを進める書き方では、0 のままだとループが進まず終わらなくなる。

外部から受け取る値をサイズにするなら、1 以上かどうかを先に検査しておく。

端数の扱い

要素数がサイズで割り切れないとき、最後のブロックだけ要素が少なくなる。
たとえば 5 個を 2 個ずつに分けると [1, 2]、[3, 4]、[5] の 3 ブロックになる。
最後を捨てたり、ほかの値で埋めたりしたい場合は、分割した後でブロックの長さを見て処理する。
空の配列を渡した場合は、どの書き方でもブロックが 0 個になる。