Requirement:

Based on mainArray which contains the master list of items, and compArray which has items of interest; construct a 2 dimensional third array that contains the array of contiguous elements.

The purpose of this requirement is for plotting poly-line on map wherever an incident occurred in contiguous manner, plotted using the finalArray of locations.

Example:

const mainArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];

const compArray = [1, 2, 3, 6, 7, 11, 12, 13, 15];



// produces finalArray

[[ 1, 2, 3 ],[ 6, 7 ],[ 11, 12, 13 ],[ 15 ]]

My current solution:

console.clear();



const mainArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];

const compArray = [1, 2, 3, 6, 7, 11, 12, 13, 15];

let compArrayIndex = 0;

let finalArray = ;

let currentArray = null;



for (let i = 0; i < mainArray.length; i++) {

  const e = mainArray[i];



  if (e === compArray[compArrayIndex]) {

    if (!currentArray) {

      currentArray = ;

    }

    currentArray.push(e);

    compArrayIndex++;

  } else {

    if (currentArray) {

      finalArray.push([...currentArray]);

      currentArray = null;

    }

  }

}



if (currentArray) {

  finalArray.push([...currentArray]);

  currentArray = null;

}



console.log(mainArray);

console.log(compArray);

console.log('finl arr:');

for (let i = 0; i < finalArray.length; i++) {

  const e = finalArray[i];

  console.log(e);

}

Good algorithm

Your solution is good, however its implementation is somewhat poor.

Clear requirements

It is very unclear what inputs to expect so I must add...

The input arrays are sorted and contain unique values, I must assume a requirement that is true.

I deduce this from your code as if the above was not true your code would fail.

Style & code

• The variable names are too long. Remember code is always in context and if you are handling arrays do you really need to add that in their names?


• Don't copy the array, just push it to the result. finalArray.push([...currentArray]); can be finalArray.push(currentArray); The copy halves the performance of your code (see below)


• Use undefined rather than null
  


• Simplify the code by using else if when possible. You have } else { if (currentArray) { which can be } else if (currentArray) {
  


• 
  finalArray should be a constant.


• Don't add code that is not needed. The last statement block up assign null to currentArray yet the variable is never used after that line.

Apart from the above points your algorithm is good as it has low complexity (if you use finalArray.push(currentArray) you halve the complexity as [...currentArray] requires iteration of each item).

You missed the opportunity to exit early. If you pass the end of the either arrays you know that no more items need to be added, however you continue to the end of the first array, which if longer than the second could mean many rundundent iterations.

If you change the for loop to...

for (let i = 0; i < mainArray.length && compArrayIndex < compArray.length; i++) {

...you gain a reduction in overall complexity.

Cleaning up your solution

Thus we can rewrite your algorithm as

function extractRuns(main, comp) { 

    var seq, j = 0;

    const result = ;

    for (let i = 0; i < main.length && j < comp.length; i++) {

        const e = main[i];

        if (e === comp[j]) {

            if (!seq) { seq =  }

            seq.push(e);

            j++;

        } else if (seq) {

            result.push(seq);

            seq = undefined;

        }

    }

    if (seq) { result.push(seq) }

    return result;

}

Short is not always best

I must point out that the existing answer by guest271314 is very poor as it has very bad complexity by using Array.includes and is forced to iterate each item in the main array as it has no way to exit early from Array.reduce.

Rewrite

I personally would have written the solution as below as it gains a little performance (not by reduced complexity) via an inner while loop. (I am a bit of an off grid performance freak :) )

function extractRuns(main, comp) { // both arrays must be sorted and contain unique values

    var m = 0, c = 0, seq;  // c and m are indexes 

    const result = , mLen = main.length, cLen = comp.length;

    while (m < mLen && c < cLen) {

        const a = main[m], b = comp[c];

        if (a === b) {

            c ++;

            m ++;

            result.push(seq = [a]);

            while (m < mLen && r < cLen && main[m] === comp[c]) {

                seq.push(main[m ++]);

                c ++;

            }

        } else if (b < a) { c ++ }

        else { m ++ }

    }

    return result;

}    

But I think your solution is far more readable and only a few % points slower to not be an issue.

The code could be reduced to a single line by utilizing Array.prototype.reduce()

const mainArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];

const compArray = [1, 2, 3, 6, 7, 11, 12, 13, 15];



const finalArray = mainArray.reduce((a, b) => {

  // `c` is boolean result of checking if `compArray` includes `b`

  // `x` is first, and if matching elements found, last array in `finalResult`

  const [c, x] = [compArray.includes(b), a[a.length - 1]];

  // if `c` push `b` to last array of `a`

  if (c) x.push(b)

  // else if `x.length` push a new array to `a`

  else if (x.length) a.push();

  // return `a`

  return a;

}, []); // pass initial array containing single array `a` to `reduce`



console.log(finalArray);