---
{
    "title": "ARRAY_REVERSE_SPLIT",
    "language": "en-US",
    "description": "Split the input array into multiple subarrays according to given boolean flags."
}
---

## Function

Split the input array into multiple subarrays according to given boolean flags.

- Splitting rule (left to right): for `arr=[a1,a2,...,an]` and `flags=[f1,f2,...,fn]`, at every position where `fi==true`, split between `ai` and `a(i+1)`.
  - For example, with `arr=[3, 4, 5]` and `flags=[false, true, false]`, the second flag is true, so split between the second and third elements, resulting in two subarrays `[3, 4]` and `[5]`.

## Syntax

- `ARRAY_REVERSE_SPLIT(arr, flags)`
- `ARRAY_REVERSE_SPLIT(lamda, arr0, ...)`
- `ARRAY_REVERSE_SPLIT(lambda, arr0, ...)` is equivalent to `ARRAY_REVERSE_SPLIT(arr0, ARRAY_MAP(lambda, arr0, ...))`

## Parameters

- `arr`: `ARRAY<T>`.
- `flags`: `ARRAY<BOOLEAN>`, whose length must match that of `arr` row by row. `true` means split between the current position and the next element.
- `arr0, ...`: one or more `ARRAY<T>`.
- `lambda`: a `lambda` expression applied to `arr0, ...` to produce `flags`, which are then used for splitting.

## Return value

- Returns `ARRAY<ARRAY<T>>`. Elements of inner arrays are the same as those of `arr`.
- If the element counts of `arr` and `flags` do not match, an error is thrown.

## Usage notes

- If a position in `flags` is `NULL`, it is treated as no split (equivalent to `false`).
- The splitting rule of `ARRAY_REVERSE_SPLIT` is: at each position where `fi==true`, split between `ai` and `a(i+1)`.
- The splitting rule of `ARRAY_SPLIT` is: at each position where `fi==true`, split between `ai` and `a(i-1)`.

## Examples

- Basic splitting: at each `true` position, split from the right side neighbor.
  - `ARRAY_REVERSE_SPLIT([1,2,3,4,5], [false,true,false,true,false])` -> `[[1,2], [3,4], [5]]`
  - `ARRAY_REVERSE_SPLIT(['a','b','c'], [false,false,false])` -> `[['a','b','c']]`

- With `NULL` in `flags`: `NULL` is treated the same as `false` (no split).
  - `ARRAY_REVERSE_SPLIT([1,NULL,3], [false,null,false])` -> `[[1, NULL, 3]]`

- `lambda= x -> x-1` applied to `arr=[1, 2, 3]` produces `flags=[0,1,2]`, equivalent to `flags=[false,true,true]`
  - `ARRAY_REVERSE_SPLIT(x->x-1, [1, 2, 3])` is equivalent to `ARRAY_REVERSE_SPLIT([1, 2, 3], [false,true,true])` -> `[[1, 2], [3]]`

- `lambda= (x,y) -> x-y` applied to `arr=[1, 2, 3]` and `arr1=[0,1,2]` produces `flags=[true,true,true]`
  - `ARRAY_REVERSE_SPLIT((x,y) -> x-y, [1, 2, 3], [0, 1, 2])` is equivalent to `ARRAY_REVERSE_SPLIT([1, 2, 3], [true,true,true])` -> `[[1], [2], [3]]`