Run results for: groupConsecutiveNumbers, 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)	1347.8 Ops/sec
functional (large arrays)	48.0 Ops/sec
imperative (small arrays)	5417225.0 Ops/sec
functional (small arrays)	312438.8 Ops/sec

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.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, []);
};

/** Groups consecutive input values, e.g. [1, 2, 4] -> [[1, 2], [4]] */
function groupConsecutiveNumbers(inputArray) {
  const initialValue = [[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 = _.last(accumulator);
    const lastNumber = _.last(lastSubarray);

    const isConsecutive = newNumber === lastNumber + 1 || newNumber === lastNumber;
    if (isConsecutive) {
      return [...accumulator.slice(0, -1), [...lastSubarray, newNumber]];
    }
    return [...accumulator, [newNumber]];
  }, initialValue);
  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, large and small arrays

imperative (large arrays)

functional (large arrays)

imperative (small arrays)

functional (small arrays)