Run results for: groupConsecutiveNumbers with immutable, large and small arrays

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36

Browser: Chrome 86

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: 4 years ago

Test name	Executions per second
imperative (large arrays)	1363.0 Ops/sec
functional (large arrays)	227.3 Ops/sec
imperative (small arrays)	5484244.5 Ops/sec
functional (small arrays)	322902.1 Ops/sec

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/immutable/4.0.0-rc.12/immutable.min.js'></script>

Script Preparation code:

const reducerForGroupingConsecutiveNumbers = (accumulator, currentNumber, index) => {
  if (index === 0) {
    accumulator.push([currentNumber]);
  } else {
    const previousGroup = accumulator[accumulator.length - 1];
    const previousNumber = previousGroup[previousGroup.length - 1];
    if (currentNumber === previousNumber + 1 || currentNumber === previousNumber) {
      previousGroup.push(currentNumber);
    } else {
      accumulator.push([currentNumber]);
    }
  }
  return accumulator;
};

/**
 * Will create an array of subarrays of consecutive numbers
 * Given: [0,1,2,5,6,9];
 * Returns: [[0,1,2],[5,6],[9]]
 */
function createGroupingsOfConsecutiveNumbers(array) {
  return array.reduce(reducerForGroupingConsecutiveNumbers, []);
};

const { List } = Immutable;

/** Groups consecutive input values, e.g. [1, 2, 4] -> [[1, 2], [4]] */
function groupConsecutiveNumbers(inputArray) {
  const initialValue = List.of(List.of(Number())); // Use a non-empty initial value to avoid edge cases: https://www.conjur.org/blog/special-cases-are-a-code-smell/
  const groupings = inputArray
    .reduce((accumulator, newNumber) => {
      /* last(accumulator) and last(last(accumulator)) will always be defined because
       * 1. its initial value is an array containing an array with at least one element and
       * 2. we never add array with fewer than 1 elements
       * They can therefore be safely casted as defined */
      const lastSubarray = accumulator.last();
      const lastNumber = lastSubarray.last();

      const isConsecutive = newNumber === lastNumber + 1 || newNumber === lastNumber;
      if (isConsecutive) {
        return accumulator.slice(0, -1).push(lastSubarray.push(newNumber));
      }
      return accumulator.push(List([newNumber]));
    }, initialValue)
    .toJS();
  const [initialValueGroup, ...rest] = groupings;
  const withoutInitialValue = [initialValueGroup.slice(1), ...rest].filter((array) => array.length > 0);
  return withoutInitialValue;
}

Tests:

imperative (large arrays)
const numbersFromOneUpToTenThousandNotDivisibleByThree = [...Array(10000).keys()].filter(s => s % 3 !== 0); createGroupingsOfConsecutiveNumbers(numbersFromOneUpToTenThousandNotDivisibleByThree)
functional (large arrays)
const numbersFromOneUpToTenThousandNotDivisibleByThree = [...Array(10000).keys()].filter(s => s % 3 !== 0); groupConsecutiveNumbers(numbersFromOneUpToTenThousandNotDivisibleByThree)
imperative (small arrays)
const smallArray = [0, 1, 2, 5, 6, 9]; createGroupingsOfConsecutiveNumbers(smallArray)
functional (small arrays)
const smallArray = [0, 1, 2, 5, 6, 9]; groupConsecutiveNumbers(smallArray)

Run results for: groupConsecutiveNumbers with immutable, large and small arrays

imperative (large arrays)

functional (large arrays)

imperative (small arrays)

functional (small arrays)