Tips for consolidating an array of numbers with close values

Question

Tips for consolidating an array of numbers with close values

Looking to develop a function that can shrink a list of numbers based on a specified variation.

Variation Explanation:

The variation should cover a range above and below a given value. For example, if the variance is set at 100 for a value of 5460, it should encompass any number between 5410 - 5510 (50 below and 50 above).

For instance, when presented with this array:

[ 1576420754, 1576420756, 1576593554, 1581172759, 1581172764 ]

I wish to create a function filterSimilarValues(array, variance = 100)

This function should produce the following result:

[ 1576420756, 1576593554, 1581172764 ]

I've experimented with different approaches such as

const filterSimalarValues = (array, variance = 100) => {
    let filteredArray = [];

    for (let i = 0; i < array.length; i++) {
        const number = array[i];

        if (number >= number - (variance / 2) && number <= number + (variance / 2)) {
            return;
        }

        filteredArray.push(number);
    }

    return filteredArray;
};

javascript arrays

Answer 1

Answer №1

To filter out numbers from an array based on the absolute difference between them and the next number being greater or equal to half of a specified variance, you can use the Array.filter() method along with Math.abs(). The last item in the array is included by default.

const excludeSimilarValues = (arr, variation = 50) => 
  arr.filter((num, index) => 
    index === arr.length - 1 ||
    Math.abs(num - arr[index + 1]) >= variation / 2
  )

const dataSet = [1357924680, 2468013579, 3579246801, 4680135792]

const myResult = excludeSimilarValues(dataSet)

console.log(myResult)

Answer 2

To filter out numbers from an array based on the absolute difference between them and the next number being greater or equal to half of a specified variance, you can use the Array.filter() method along with Math.abs(). The last item in the array is included by default.

const excludeSimilarValues = (arr, variation = 50) => 
  arr.filter((num, index) => 
    index === arr.length - 1 ||
    Math.abs(num - arr[index + 1]) >= variation / 2
  )

const dataSet = [1357924680, 2468013579, 3579246801, 4680135792]

const myResult = excludeSimilarValues(dataSet)

console.log(myResult)

Answer 3

Answer №2

I suggest attempting something along these lines:

function removeSimilarValues(array, threshold = 100) {
    return array.reduce((uniqueValues, currentValue) => {
        const similarValueIndex = uniqueValues.findIndex(value => currentValue > value - threshold / 2 && currentValue < value + threshold / 2);
        if (similarValueIndex === -1) {
            uniqueValues.push(currentValue);
        } else {
            uniqueValues[similarValueIndex] = currentValue;
        }
        return uniqueValues;
    }, []);
}

It would also be beneficial to provide more specific details in your query as there are numerous potential scenarios that may not have been addressed.

Answer 4

I suggest attempting something along these lines:

function removeSimilarValues(array, threshold = 100) {
    return array.reduce((uniqueValues, currentValue) => {
        const similarValueIndex = uniqueValues.findIndex(value => currentValue > value - threshold / 2 && currentValue < value + threshold / 2);
        if (similarValueIndex === -1) {
            uniqueValues.push(currentValue);
        } else {
            uniqueValues[similarValueIndex] = currentValue;
        }
        return uniqueValues;
    }, []);
}

It would also be beneficial to provide more specific details in your query as there are numerous potential scenarios that may not have been addressed.

Answer 5

Answer №3

Based on the explanation given and my interpretation of variance, the goal is to restrict the numbers within a specified range of variance. It is assumed that there are at least 2 elements present, but additional checks can be added for that scenario.

function filterSimilarValues(array, variance = 100) {
    const filteredArray = [];
    filteredArray.push(array[0]); // benchmark for comparison
    for (let i = 1; i < array.length; i++) {
        const number_lower_bound = array[i] - variance/2;
        const number_upper_bound = array[i] + variance/2;
        let bound_exist = false;
        for(let bound = number_lower_bound; bound <= number_upper_bound; bound++){
          if (filteredArray.includes(bound)) {
              bound_exist = true;
              break;
          }
        }
        if(!bound_exist){
            filteredArray.push(array[i]);
        }
      }
    
    return filteredArray;
};

Answer 6

Based on the explanation given and my interpretation of variance, the goal is to restrict the numbers within a specified range of variance. It is assumed that there are at least 2 elements present, but additional checks can be added for that scenario.

function filterSimilarValues(array, variance = 100) {
    const filteredArray = [];
    filteredArray.push(array[0]); // benchmark for comparison
    for (let i = 1; i < array.length; i++) {
        const number_lower_bound = array[i] - variance/2;
        const number_upper_bound = array[i] + variance/2;
        let bound_exist = false;
        for(let bound = number_lower_bound; bound <= number_upper_bound; bound++){
          if (filteredArray.includes(bound)) {
              bound_exist = true;
              break;
          }
        }
        if(!bound_exist){
            filteredArray.push(array[i]);
        }
      }
    
    return filteredArray;
};

Answer 7

Answer №4

This is my attempt at finding a solution, and while it works, I believe there may be room for improvement. Therefore, I am keeping an open mind and not settling on my own answer just yet.

const filterSimilarValues = (array, variance = 100) => {
  let filteredArray = [];

  array.forEach(number => {
    const start = number - (variance / 2);
    const end = number + (variance / 2);
    const range = Array(end - start + 1).fill().map((_, idx) => start + idx);
    const found = range.some(r => filteredArray.includes(r))

    if (!found) {
      filteredArray.push(number);
    }
  });

  return filteredArray;
};

Answer 8

This is my attempt at finding a solution, and while it works, I believe there may be room for improvement. Therefore, I am keeping an open mind and not settling on my own answer just yet.

const filterSimilarValues = (array, variance = 100) => {
  let filteredArray = [];

  array.forEach(number => {
    const start = number - (variance / 2);
    const end = number + (variance / 2);
    const range = Array(end - start + 1).fill().map((_, idx) => start + idx);
    const found = range.some(r => filteredArray.includes(r))

    if (!found) {
      filteredArray.push(number);
    }
  });

  return filteredArray;
};

Tips for consolidating an array of numbers with close values

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Is there a way to establish a connection between two excel entries using Angular?

How can we add styles to text entered into a form input field in a targeted way?

Tips on extracting information from several JSON response objects

You can eliminate the display flex property from the MuiCollapse-wrapper

Tips for ensuring the footer always stays at the bottom of the page

What is the best way to incorporate the final paragraph into the foundational code?

What is the best way to include several IDs in a discord.js verification process?

What is the most effective way to alphabetically organize a Javascript array?

A Webpage that is permanently open, with no option to close it. The only option is to watch the video in

Unable to bring in ES6 module to Vue's single file component

Received an empty response while making an AJAX request - ERR_EMPTY_RESPONSE

Is it possible to implement a "load more" feature with JSON data using the getJSON method?

Validation within nested Joi schemas

Collection of arrays (Python/NumPy)

How can I specify the exact width for Bootstrap 3 Progress Bars?

Executing NodeJS awaits in the incorrect order - When using Express with SQLite3's db.all and db.run, one await is prioritized over the other

Unable to stop interval in Angular 5 application

Updating React state from another component - using useState

Select a picture at random from a directory

Failing to utilize callback functions results in forgetting information