Eliminate adjacent items in an array to avoid duplicates and keep track of the remaining count

Question

Eliminate adjacent items in an array to avoid duplicates and keep track of the remaining count

I'm currently working on developing a console interface similar to those found in web browsers. However, I've hit a roadblock when it comes to handling duplicate messages. For example, if you input

[...Array(10)].map(x => console.log("hello"))

into the console, it will output (10) hello.

Now, let's say I have the following array:

const array = [
    {
        output: "testing",
    },
    {
        output: "testing",
    },
    {
        output: "hello",
    },
    {
        output: "world",
    },
    {
        output: "world",
    },
    {
        output: "testing",
    },
]

The desired output should resemble this:

(2) testing    
hello    
(2) world    
testing

So, what I want to achieve is removing consecutive duplicates and displaying how many times they occur in a row. The modified output should be structured like this:

const newArray = [
    {
        output: "testing",
        count: 2
    },
    {
        output: "hello",
        count: 1
    },
    {
        output: "world",
        count: 2
    },
    {
        output: "testing",
        count: 1
    },
]

One approach I considered involves utilizing the following code snippet:

const array = [{
    output: "testing",
  },
  {
    output: "testing",
  },
  {
    output: "hello",
  },
  {
    output: "world",
  },
  {
    output: "world",
  },
  {
    output: "testing",
  },
]
let newArray = [];

for (let i = 0; i < array.length; i++) {
  if (newArray.length > 1 && array[i].output == newArray[newArray.length - 1].output) {
    newArray[newArray.length - 1].counter += 1
  } else {
    newArray.push({
      output: array[i].output,
      counter: 0
    })
  }

}
console.log(newArray)

javascript arrays

Answer 1

Answer №1

UPDATE: The code now groups entries that are close to each other

const array = [
    { output: "testing" },
    { output: "testing" },
    { output: "hello" },
    { output: "world" },
    { output: "world" },
    { output: "testing" }
];

// Result objects
let subRes = false;
const res = [];

// Loop through the array
for(let i = 0; i < array.length; i++) {
  // Create a count object
  if(!subRes) subRes = {
    output: array[i].output,
    count: 1
  }
  // Check if the next entry is the same
  if(array[i+1] && array[i+1].output === array[i].output) {
    subRes.count++;
  } else {
    res.push(subRes);
    subRes = false;
  }
}

// Log the result
console.log(res);

Answer 2

UPDATE: The code now groups entries that are close to each other

const array = [
    { output: "testing" },
    { output: "testing" },
    { output: "hello" },
    { output: "world" },
    { output: "world" },
    { output: "testing" }
];

// Result objects
let subRes = false;
const res = [];

// Loop through the array
for(let i = 0; i < array.length; i++) {
  // Create a count object
  if(!subRes) subRes = {
    output: array[i].output,
    count: 1
  }
  // Check if the next entry is the same
  if(array[i+1] && array[i+1].output === array[i].output) {
    subRes.count++;
  } else {
    res.push(subRes);
    subRes = false;
  }
}

// Log the result
console.log(res);

Answer 3

Answer №2

Perform filtering on the given array and then display the output

An illustrative example is provided below

var myArray = [
    {
        value: "apple",
    },
    {
        value: "apple",
    },
    {
        value: "banana",
    },
    {
        value: "orange",
    },
    {
        value: "orange",
    },
    {
        value: "apple",
    },
]

// Utilize reduce method to condense the array into a single object
result = myArray.reduce((acc, val) => {  
  if(val.value === acc.last_val){
    acc.output[acc.output.length - 1].quantity += 1;
  } else {
    acc.output.push({...val, quantity: 1})
  }
  
  acc.last_val = val.value;
  return acc;
}, {output: [], last_val: null});

console.log(result.output);

Answer 4

Perform filtering on the given array and then display the output

An illustrative example is provided below

var myArray = [
    {
        value: "apple",
    },
    {
        value: "apple",
    },
    {
        value: "banana",
    },
    {
        value: "orange",
    },
    {
        value: "orange",
    },
    {
        value: "apple",
    },
]

// Utilize reduce method to condense the array into a single object
result = myArray.reduce((acc, val) => {  
  if(val.value === acc.last_val){
    acc.output[acc.output.length - 1].quantity += 1;
  } else {
    acc.output.push({...val, quantity: 1})
  }
  
  acc.last_val = val.value;
  return acc;
}, {output: [], last_val: null});

console.log(result.output);

Answer 5

Answer №3

To make management and reuse easier, consider utilizing the reducer function in JavaScript.

Method 1

const array = [...]

const reduceCount = (acc, obj) => {
  const key = obj["output"];
  // check if we already store the key
  if(!(key in acc)){
    //the key is not register yet, so we create a counter state
    acc[key] = {count: 0};
  }

  //increment the key state counter
  acc[key]['count'] += 1
  
  return acc;
}

// Reduce the array to get state of each key
const dictCount = array.reduce(reduceCount, {});

console.log(dictCount) // { testing: { count: 3 }, hello: { count: 1 }, world: { count: 2 } }

const newArray = Object.keys(dictCount).map(key => ({
  output: key, 
  count: dictCount[key]['count']
}));

console.log(newArray) 

/** output
[
  { output: 'testing', count: 3 },
  { output: 'hello', count: 1 },
  { output: 'world', count: 2 }
]
 */

Method 2: Another Approach for Better Reusability:

const array = [...]

const reduceCount = target => (acc, obj) => {
  const key = obj[target];
  // check if we already store the key
  if(!(key in acc)){
    //the key is not register yet, so we create a counter state
    acc[key] = {count: 0};
  }

  //increment the key state counter
  acc[key]['count'] += 1
  
  return acc;
}

const counterState = target => arr => arr.reduce(reduceCount(target), {});
const counterStateOutput = counterState('output'); //specialize the function

// transform state to array
const stateToArray = state =>  Object.keys(state).map(key => ({
  key,
  count: state[key]["count"]
}));

console.log(stateToArray(counterStateOutput(array))) 
//or
console.log(stateToArray(counterState('output')(array))) 

/** output
[
  { key: 'testing', count: 3 },
  { key: 'hello', count: 1 },
  { key: 'world', count: 2 }
]
 */

Answer 6

To make management and reuse easier, consider utilizing the reducer function in JavaScript.

Method 1

const array = [...]

const reduceCount = (acc, obj) => {
  const key = obj["output"];
  // check if we already store the key
  if(!(key in acc)){
    //the key is not register yet, so we create a counter state
    acc[key] = {count: 0};
  }

  //increment the key state counter
  acc[key]['count'] += 1
  
  return acc;
}

// Reduce the array to get state of each key
const dictCount = array.reduce(reduceCount, {});

console.log(dictCount) // { testing: { count: 3 }, hello: { count: 1 }, world: { count: 2 } }

const newArray = Object.keys(dictCount).map(key => ({
  output: key, 
  count: dictCount[key]['count']
}));

console.log(newArray) 

/** output
[
  { output: 'testing', count: 3 },
  { output: 'hello', count: 1 },
  { output: 'world', count: 2 }
]
 */

Method 2: Another Approach for Better Reusability:

const array = [...]

const reduceCount = target => (acc, obj) => {
  const key = obj[target];
  // check if we already store the key
  if(!(key in acc)){
    //the key is not register yet, so we create a counter state
    acc[key] = {count: 0};
  }

  //increment the key state counter
  acc[key]['count'] += 1
  
  return acc;
}

const counterState = target => arr => arr.reduce(reduceCount(target), {});
const counterStateOutput = counterState('output'); //specialize the function

// transform state to array
const stateToArray = state =>  Object.keys(state).map(key => ({
  key,
  count: state[key]["count"]
}));

console.log(stateToArray(counterStateOutput(array))) 
//or
console.log(stateToArray(counterState('output')(array))) 

/** output
[
  { key: 'testing', count: 3 },
  { key: 'hello', count: 1 },
  { key: 'world', count: 2 }
]
 */

Eliminate adjacent items in an array to avoid duplicates and keep track of the remaining count

Answer №1

Answer №2

Answer №3

Similar questions

Tips on transmitting checkbox data from AJAX to PHP

An error was thrown at line 474 in module.js

eliminate elements from a PHP array

Having trouble displaying information in JavaScript after using getScript() to retrieve data from an API containing a JSON block database

Issue with AngularJS post request yielding status code 304 instead of successfully submitting data to backend server

Creating an Angular project that functions as a library and integrating it into a JavaScript project: a step-by-step guide

Utilize dependency injection to connect services with controllers located in separate files

What is the best way to manage the login notification?

Alert received upon selecting the React icon button

Tips for modifying the JSON array output into an object using PHP

How to correctly initialize character arrays in Objective-C?

What is the most effective way to retrieve data when a user clicks?

Utilize regular expressions in TamperMonkey to extract specific groups of text

Steps to remove information from a database using PHP, AJAX, and vanilla JavaScript (without jQuery)

Dynamically adding items in a row to a form panel using extjs

Storing socket.io data in an array

What is the best way to manage communication with a database in a Node.js application?

Unable to pass an Array to the Controller

Ways to emphasize a specific row within a table for special occasions

How to set an already existing anonymous object to a property within the data property in VueJS