# Fast and Simple Jumbled Indexing for Binary RLE Strings

## TL;DR

This paper introduces a simple and efficient indexing algorithm for binary run-length encoded strings that operates in linear time relative to the string length and number of runs, with extensions for position retrieval and space efficiency.

## Contribution

It presents a new, straightforward algorithm for binary RLE string indexing that matches the best known time bounds and offers additional practical extensions.

## Key findings

- Runs in O(n + ρ^2) time, matching prior algorithms.
- Can be extended to return match positions.
- Uses only O(n) bits of space in some variants.

## Abstract

Important papers have appeared recently on the problem of indexing binary strings for jumbled pattern matching, and further lowering the time bounds in terms of the input size would now be a breakthrough with broad implications. We can still make progress on the problem, however, by considering other natural parameters. Badkobeh et al.\ (IPL, 2013) and Amir et al.\ (TCS, 2016) gave algorithms that index a binary string in $O (n + \rho^2 \log \rho)$ time, where $n$ is the length and $\rho$ is the number of runs, and Giaquinta and Grabowski (IPL, 2013) gave one that runs in $O (n + \rho^2)$ time. In this paper we propose a new and very simple algorithm that also runs in $O(n + \rho^2)$ time and can be extended either so that the index returns the position of a match (if there is one), or so that the algorithm uses only $O (n)$ bits of space.