Determine all sequences within an array using JavaScript

Question

Determine all sequences within an array using JavaScript

Given an array (with a fixed length) of objects in the following structures:

{type: 'A', value: 1}

or

{type: 'B', text: 'b'}

What is the most efficient method to identify all sequences of objects with type 'A' and return their indices?

For example, consider the following array:

[
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
]

The expected output would be:

[
  {startIndex: 0, startValue: 1, length: 2},
  {startIndex: 3, startValue: 11, length: 3},
  {startIndex: 7, startValue: 10, length: 1},
]

Instead of using a complex forEach loop with multiple conditions, is there a simpler approach to achieve this task effectively?

Thank you.

javascript arrays

Answer 1

Answer №1

To achieve this, you can utilize the reduce method. Create a variable called prev to store the previous item's type. If the current item's type matches your target type, check if the previous item had a different type. If so, add a new object; otherwise, increment the length property.

let data = [{type:'A',value:1},{type:'A',value:2},{type:'B',text:'b1'},{type:'A',value:11},{type:'A',value:12},{type:'A',value:13},{type:'B',text:'b2'},{type:'A',value:10},{type:'B',text:'b3'}],
    prev;

const result = data.reduce((acc, { type, value }, index) => {
  if (type === 'A') {
    if (prev !== type) {
      acc.push({ startIndex: index, startValue: value, length: 1 });
    } else {
      acc[acc.length - 1].length++;
    }
  }

  prev = type;
  return acc;
}, []);

console.log(result)

Answer 2

To achieve this, you can utilize the reduce method. Create a variable called prev to store the previous item's type. If the current item's type matches your target type, check if the previous item had a different type. If so, add a new object; otherwise, increment the length property.

let data = [{type:'A',value:1},{type:'A',value:2},{type:'B',text:'b1'},{type:'A',value:11},{type:'A',value:12},{type:'A',value:13},{type:'B',text:'b2'},{type:'A',value:10},{type:'B',text:'b3'}],
    prev;

const result = data.reduce((acc, { type, value }, index) => {
  if (type === 'A') {
    if (prev !== type) {
      acc.push({ startIndex: index, startValue: value, length: 1 });
    } else {
      acc[acc.length - 1].length++;
    }
  }

  prev = type;
  return acc;
}, []);

console.log(result)

Answer 3

Answer №2

To create a new group, you can simplify the array and check both the value and type for each element.

var array = [{ type: 'A', value: 1 }, { type: 'A', value: 2 }, { type: 'B', text: 'b1' }, { type: 'A', value: 11 }, { type: 'A', value: 12 }, { type: 'A', value: 13 }, { type: 'B', text: 'b2' }, { type: 'A', value: 10 }, { type: 'B', text: 'b3' }],
    result = array.reduce((r, { type, value }, i, a) => {
        var previous = a[i - 1] || {},
            last = r[r.length - 1];
        if (!isFinite(value) || type !== 'A') return r;
        if (previous.type !== type) {
            r.push({ startIndex: i, startValue: value, length: 1 });
            return r;
        }
        if (value === a[last.startIndex].value + last.length) last.length++;
        return r;
    }, []);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 4

To create a new group, you can simplify the array and check both the value and type for each element.

var array = [{ type: 'A', value: 1 }, { type: 'A', value: 2 }, { type: 'B', text: 'b1' }, { type: 'A', value: 11 }, { type: 'A', value: 12 }, { type: 'A', value: 13 }, { type: 'B', text: 'b2' }, { type: 'A', value: 10 }, { type: 'B', text: 'b3' }],
    result = array.reduce((r, { type, value }, i, a) => {
        var previous = a[i - 1] || {},
            last = r[r.length - 1];
        if (!isFinite(value) || type !== 'A') return r;
        if (previous.type !== type) {
            r.push({ startIndex: i, startValue: value, length: 1 });
            return r;
        }
        if (value === a[last.startIndex].value + last.length) last.length++;
        return r;
    }, []);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 5

Answer №3

To simplify your code, consider utilizing a forEach loop. It enhances readability and reduces complexity.

let arr = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
]

function findSequences(arr, character) {
  let seq = []

  let seqStarted = false;
  let seqI = 0;

  arr.forEach((el, i) => {
    if (el.type == character) {
      if (seqStarted == true) {
        seq[seqI].length += 1;
      } else {
        seqStarted = true;
        seq.push({
          startIndex: i,
          startValue: el.value,
          length: 1
        });
      }
    } else {
      if (seqStarted) {
        seqStarted = false;
        seqI++;
      }
    }
  })

  return seq;
}

console.log(findSequences(arr, 'A'))

Answer 6

To simplify your code, consider utilizing a forEach loop. It enhances readability and reduces complexity.

let arr = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
]

function findSequences(arr, character) {
  let seq = []

  let seqStarted = false;
  let seqI = 0;

  arr.forEach((el, i) => {
    if (el.type == character) {
      if (seqStarted == true) {
        seq[seqI].length += 1;
      } else {
        seqStarted = true;
        seq.push({
          startIndex: i,
          startValue: el.value,
          length: 1
        });
      }
    } else {
      if (seqStarted) {
        seqStarted = false;
        seqI++;
      }
    }
  })

  return seq;
}

console.log(findSequences(arr, 'A'))

Answer 7

Answer №4

Iterating over an array using a simple for loop is one of the simplest ways to construct your desired answer. This approach has linear complexity because you only traverse the array once. There's no need for overly complex conditions in this scenario.

A straightforward solution might look something like this:

const arr = [
{type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
{type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
{type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

const result = [];

for (let [index, el] of arr.entries()) {
if (el.type === 'A') {
// consider the first entry encountered
if (result.length === 0) {
result.push({startIndex: index, length: 1, startValue: el.value});
} else {
const lastSequence = result[result.length - 1];
// check if we are continuing with a sequence
if (lastSequence.startIndex + lastSequence.length === index) {
lastSequence.length += 1;
} else {
// create a new sequence if not continuing
result.push({startIndex: index, length: 1, startValue: el.value});
}
}
}
}

console.log(result);

Answer 8

Iterating over an array using a simple for loop is one of the simplest ways to construct your desired answer. This approach has linear complexity because you only traverse the array once. There's no need for overly complex conditions in this scenario.

A straightforward solution might look something like this:

const arr = [
{type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
{type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
{type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

const result = [];

for (let [index, el] of arr.entries()) {
if (el.type === 'A') {
// consider the first entry encountered
if (result.length === 0) {
result.push({startIndex: index, length: 1, startValue: el.value});
} else {
const lastSequence = result[result.length - 1];
// check if we are continuing with a sequence
if (lastSequence.startIndex + lastSequence.length === index) {
lastSequence.length += 1;
} else {
// create a new sequence if not continuing
result.push({startIndex: index, length: 1, startValue: el.value});
}
}
}
}

console.log(result);

Answer 9

Answer №5

When examining the given array:

var arr =[
   {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
   {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
   {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

arr.reduce((result, current, index) => {
    if(current.type == 'A'){
        if(result.length == 0 || index - result[result.length - 1].length != result[result.length - 1]. startIndex){
            result.push({startIndex: index, startValue: current.value, length: 1})
        }
        else{
           result[result.length - 1].length++
       }
    }
    return result;
}, [])

Answer 10

When examining the given array:

var arr =[
   {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
   {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
   {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

arr.reduce((result, current, index) => {
    if(current.type == 'A'){
        if(result.length == 0 || index - result[result.length - 1].length != result[result.length - 1]. startIndex){
            result.push({startIndex: index, startValue: current.value, length: 1})
        }
        else{
           result[result.length - 1].length++
       }
    }
    return result;
}, [])

Answer 11

Answer №6

Instead of using the imperative forEach method, you can opt for a declarative approach like this:

const data = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

var filteredData = data.map((item,index) => {
return item.type == 'A' ? {startIndex: index,startValue: item.value} : null
}).filter(element => element).reduce((accumulator,item) => {

if (accumulator.filter(element => element.startIndex + element.length  == item.startIndex).length > 0){
accumulator[accumulator.length-1].length ++;
} else {
item.length = 1;
accumulator.push(item);
}
return accumulator;
},[]);
console.log(filteredData);

Answer 12

Instead of using the imperative forEach method, you can opt for a declarative approach like this:

const data = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
];

var filteredData = data.map((item,index) => {
return item.type == 'A' ? {startIndex: index,startValue: item.value} : null
}).filter(element => element).reduce((accumulator,item) => {

if (accumulator.filter(element => element.startIndex + element.length  == item.startIndex).length > 0){
accumulator[accumulator.length-1].length ++;
} else {
item.length = 1;
accumulator.push(item);
}
return accumulator;
},[]);
console.log(filteredData);

Answer 13

Answer №7

Despite the abundance of valuable responses already provided, I felt compelled to contribute an answer that delves into a broader scope of segmenting a list. This code snippet allows for the specification of a segmenter function, which evaluates two items to determine if a new segment should be initialized.

Once these segments are established, reaching the desired final output becomes a straightforward process.

const data = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
]

const segmentBy = segmenter => items => {
  const segmentReducer = (prev = [], curr) => {
    let lastSegment = [];
    let lastItem = null;
    
    try {
      lastSegment = prev[prev.length - 1];
      lastItem = lastSegment[lastSegment.length - 1];
    } catch (e) {
      return [...prev, [curr]];
    }
    const requiresNewSegment = segmenter(lastItem, curr);
    
    if (requiresNewSegment) {
      return [...prev, [curr]];
    }
    
    return [...prev.slice(0, prev.length - 1), [...lastSegment, curr]];
  };
  
  return items.reduce(segmentReducer, []);
};

const addIndex = a => a.map((x, i) => ({...x, index: i}))

const segmentByType = segmentBy((a, b) => a.type !== b.type);
const segments = segmentByType(addIndex(data));

const result = segments
  .map(segment => ({
    startIndex: segment[0].index,
    startValue: segment[0].value || null,
    length: segment.length
  }))
  .filter(x => x.startValue !== null)
  
console.dir(result);

Answer 14

Despite the abundance of valuable responses already provided, I felt compelled to contribute an answer that delves into a broader scope of segmenting a list. This code snippet allows for the specification of a segmenter function, which evaluates two items to determine if a new segment should be initialized.

Once these segments are established, reaching the desired final output becomes a straightforward process.

const data = [
  {type: 'A', value: 1}, {type: 'A', value: 2}, {type: 'B', text: 'b1'},
  {type: 'A', value: 11}, {type: 'A', value: 12}, {type: 'A', value: 13},
  {type: 'B', text: 'b2'}, {type: 'A', value: 10}, {type: 'B', text: 'b3'}
]

const segmentBy = segmenter => items => {
  const segmentReducer = (prev = [], curr) => {
    let lastSegment = [];
    let lastItem = null;
    
    try {
      lastSegment = prev[prev.length - 1];
      lastItem = lastSegment[lastSegment.length - 1];
    } catch (e) {
      return [...prev, [curr]];
    }
    const requiresNewSegment = segmenter(lastItem, curr);
    
    if (requiresNewSegment) {
      return [...prev, [curr]];
    }
    
    return [...prev.slice(0, prev.length - 1), [...lastSegment, curr]];
  };
  
  return items.reduce(segmentReducer, []);
};

const addIndex = a => a.map((x, i) => ({...x, index: i}))

const segmentByType = segmentBy((a, b) => a.type !== b.type);
const segments = segmentByType(addIndex(data));

const result = segments
  .map(segment => ({
    startIndex: segment[0].index,
    startValue: segment[0].value || null,
    length: segment.length
  }))
  .filter(x => x.startValue !== null)
  
console.dir(result);

Determine all sequences within an array using JavaScript

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Answer №7

Similar questions

Is it possible to execute JavaScript code (using Node.js) through AppleScript on MAC OS?

Only one condition is met when using the Javascript if statement with the :checked and .bind methods

Is it possible to convert a jQuery function into an AngularJS directive?

transfer data from local array to global variable

Difficulty with Vue Router horizontal scrolling to hash functionality

Creating a circular image in a responsive navigation bar

Ways to cycle through information within a table using a multi-dimensional array

Issue encountered with the carousel plugin while transitioning to a different page (utilizing Durandal)

How do you manage dependencies for nested components within Angular2?

Strategies for identifying specific children in my particular situation

Replicating DIV element with input field

Dynamic AngularJS Content Loader

Display only posts from an array in WordPress

Adding a struct to an array of structs in Swift 3

Associate a unique identifier string with a randomly generated integer identifier by Agora

React hooks - The setState function fails to modify state attributes

Centering Dynamic Text Vertically in Adobe Animate using Javascript

Error: Unable to access the 'create' property of an undefined object while utilizing sequelize to register a user and add an entry

Is the XMLHttpRequest object closed once the response is received?

Creating an overloaded callable interface using TypeScript