Minimize an array by organizing objects based on the proximity of their numbers

Question

Minimize an array by organizing objects based on the proximity of their numbers

My array contains the following data:

[  
  { "begin": 870, "end": 889, "spanType": ["plan", "gt-plan"] },
  { "begin": 890, "end": 925, "spanType": ["plan", "gt-plan"] },
  { "begin": 926, "end": 938, "spanType": ["plan", "gt-plan"] },
  { "begin": 939, "end": 958, "spanType": ["plan", "gt-plan"] },
  { "begin": 7732, "end": 7790, "spanType": ["plan", "gt-plan"] },
  { "begin": 7791, "end": 7879, "spanType": ["plan", "gt-plan"] }
]

I am trying to iterate over this array and create a new array with the following structure:

[  
  { "begin": 870, "end": 958, "spanType": ["plan", "gt-plan"] },
  { "begin": 7732, "end": 7879, "spanType": ["plan", "gt-plan"] }
]

The goal is to merge two spans together if the end of one span is within 3 units of the beginning of the next span.

This is my current approach (not functioning as intended) - check it out on this demo link:

spans.forEach(function(d,i) {
    if (i+1 <= spans.length - 1) {
    if (spans[i+1].begin <= d.end + 3) {
    d.end = spans[i+1].end;
     newSpans.push(d);
  }
    else {
        newSpans.push(spans[i]);
    }
  }
});

Link to the demo for reference - see fiddle

javascript arrays reduce

Answer 1

Answer №1

First step would be to organize the spans in a sorted manner to avoid continuously checking all elements:

spans.sort((a,b) => a.begin - b.begin);

With the spans sorted, we can efficiently merge them together:

const result = [];
result.push(spans.reduce((prev,curr) => {
 if(prev.end < curr.begin - 1){
  result.push(prev);
  return Object.assign({},curr);
 }
 prev.end = Math.max(prev.end, curr.end);
 return prev;
}));

Give it a try

Answer 2

First step would be to organize the spans in a sorted manner to avoid continuously checking all elements:

spans.sort((a,b) => a.begin - b.begin);

With the spans sorted, we can efficiently merge them together:

const result = [];
result.push(spans.reduce((prev,curr) => {
 if(prev.end < curr.begin - 1){
  result.push(prev);
  return Object.assign({},curr);
 }
 prev.end = Math.max(prev.end, curr.end);
 return prev;
}));

Give it a try

Answer 3

Answer №2

When dealing with sorted data, it becomes easier to compare the last inserted element with the current one and make adjustments to the 'end' value if the difference is smaller than a specified number.

This approach modifies the original array. If you prefer to avoid altering the original array, consider creating a copy of the object when pushing.

var list = [{ begin: 870, end: 889, spanType: ["plan", "gt-plan"] }, { begin: 890, end: 925, spanType: ["plan", "gt-plan"] }, { begin: 926, end: 938, spanType: ["plan", "gt-plan"] }, { begin: 939, end: 958, spanType: ["plan", "gt-plan"] }, { begin: 7732, end: 7790, spanType: ["plan", "gt-plan"] }, { begin: 7791, end: 7879, spanType: ["plan", "gt-plan"] }],
    output = list.reduce(function (result, obj, index) {
        if (!index || obj.begin - result[result.length - 1].end >= 3) {
            result.push(obj);
        } else {
            result[result.length - 1].end = obj.end;
        }
        return result;
    }, []);

console.log(output);

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

Answer 4

When dealing with sorted data, it becomes easier to compare the last inserted element with the current one and make adjustments to the 'end' value if the difference is smaller than a specified number.

This approach modifies the original array. If you prefer to avoid altering the original array, consider creating a copy of the object when pushing.

var list = [{ begin: 870, end: 889, spanType: ["plan", "gt-plan"] }, { begin: 890, end: 925, spanType: ["plan", "gt-plan"] }, { begin: 926, end: 938, spanType: ["plan", "gt-plan"] }, { begin: 939, end: 958, spanType: ["plan", "gt-plan"] }, { begin: 7732, end: 7790, spanType: ["plan", "gt-plan"] }, { begin: 7791, end: 7879, spanType: ["plan", "gt-plan"] }],
    output = list.reduce(function (result, obj, index) {
        if (!index || obj.begin - result[result.length - 1].end >= 3) {
            result.push(obj);
        } else {
            result[result.length - 1].end = obj.end;
        }
        return result;
    }, []);

console.log(output);

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

Answer 5

Answer №3

const dataList = [  
  { "start": 870, "finish": 889, "type": ["plan", "gt-plan"] },
  { "start": 890, "finish": 925, "type": ["plan", "gt-plan"] },
  { "start": 926, "finish": 938, "type": ["plan", "gt-plan"] },
  { "start": 939, "finish": 958, "type": ["plan", "gt-plan"] },
  { "start": 7732, "finish": 7790, "type": ["plan", "gt-plan"] },
  { "start": 7791, "finish": 7879, "type": ["plan", "gt-plan"] }
];

// set the range for merging end values
const MERGE_RANGE = 3;

// loop through the available data objects
for (let index = 0; index < dataList.length - 1; index++) {
    // check if merging is necessary based on range condition
    if (dataList[index].finish >= dataList[index+1].start - MERGE_RANGE) {
        // merge current object into the next one
        // adjust start value and combine type entries
        dataList[index+1].start = dataList[i].start;
        Array.prototype.push.apply(dataList[index+1].type, dataList[index]);
        dataList.splice(index, 1);  // remove merged object
        index--;  // adjust index after removal
    }
}
console.log(dataList);

Answer 6

const dataList = [  
  { "start": 870, "finish": 889, "type": ["plan", "gt-plan"] },
  { "start": 890, "finish": 925, "type": ["plan", "gt-plan"] },
  { "start": 926, "finish": 938, "type": ["plan", "gt-plan"] },
  { "start": 939, "finish": 958, "type": ["plan", "gt-plan"] },
  { "start": 7732, "finish": 7790, "type": ["plan", "gt-plan"] },
  { "start": 7791, "finish": 7879, "type": ["plan", "gt-plan"] }
];

// set the range for merging end values
const MERGE_RANGE = 3;

// loop through the available data objects
for (let index = 0; index < dataList.length - 1; index++) {
    // check if merging is necessary based on range condition
    if (dataList[index].finish >= dataList[index+1].start - MERGE_RANGE) {
        // merge current object into the next one
        // adjust start value and combine type entries
        dataList[index+1].start = dataList[i].start;
        Array.prototype.push.apply(dataList[index+1].type, dataList[index]);
        dataList.splice(index, 1);  // remove merged object
        index--;  // adjust index after removal
    }
}
console.log(dataList);

Minimize an array by organizing objects based on the proximity of their numbers

Answer №1

Answer №2

Answer №3

Similar questions

What is the method for subtracting pixels from a percentage value?

Concerns surrounding obtaining a response while using the $.get() method

Exploring ways to retrieve elements from a subarray in Java using indexes instead of keys

Using React/NextJS: What is the best way to handle mapping through an array of objects with dynamic keys?

Basic animation feature malfunctioning

Create and export a React component with dual properties

Support for Vue 3.4 same-name shorthand has been added to VS Code

Ensure that clicking on various links will result in them opening in a new pop-up window consistently

Is there a way to determine if the browser window is currently in use?

Problematic situation when using ng-repeat with dynamic ng-include and template variables scope conflict

Combining two animated gifs using JavaScript: A step-by-step guide

Can you explain how JSON and AJAX are different when used in conjunction with jQuery?

Babel had a SyntaxError in test.jsx file at line 3, position 11 with an Unexpected token

Javascript Parameter

Having trouble correctly parsing XML data using JavaScript

Tips for managing the output of an asynchronous function in TypeScript

Having trouble fetching AJAX POST data in PHP?

The process of incorporating types into Node.js and TypeScript for handling req and res objects

Browser freezes unexpectedly every 10-15 minutes

Callback function for asynchronous operations on the client side with Meteor