Javascript - Group and Sort Objects

Question

I received a challenge and have done, but I think not a good way. I think there is a short way to do the same thing.

I look for MAP, REDUCE and FILTERS, but not discover a nice way.

The objectives was:

Find Duplicate Transactions.
Group similars
Sort the results

Instructions: Sometimes when a customer is charged, there is a duplicate transaction created. We need to find those transactions so that they can be dealt with. Everything about the transaction should be identical, except the transaction id and the time at which it occurred, as there can be up to a minute delay.

findDuplicateTransactions(transactions)

Find all transactions that have the same sourceAccount, targetAccount, category, amount, and the time difference between each consecutive transaction is less than 1 minute.

Input You can assume that all parameters will always be present and valid. However, the incoming transactions are not guaranteed to be in any particular order.

list of transactions (Transaction[]) Output list of all the duplicate transaction groups, ordered by time ascending (Transaction[][]) The groups should be sorted in ascending order of the first transaction in the group. Example The input:

[
  {
    id: 3,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:34:30.000Z'
  },
  {
    id: 1,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:33:00.000Z'
  },
  {
    id: 6,
    sourceAccount: 'A',
    targetAccount: 'C',
    amount: 250,
    category: 'other',
    time: '2018-03-02T10:33:05.000Z'
  },
  {
    id: 4,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:36:00.000Z'
  },
  {
    id: 2,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:33:50.000Z'
  },
  {
    id: 5,
    sourceAccount: 'A',
    targetAccount: 'C',
    amount: 250,
    category: 'other',
    time: '2018-03-02T10:33:00.000Z'
  }
];

Output expect:

[
  [
    {
      id: 1,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:33:00.000Z"
    },
    {
      id: 2,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:33:50.000Z"
    },
    {
      id: 3,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:34:30.000Z"
    }
  ],
  [
    {
      id: 5,
      sourceAccount: "A",
      targetAccount: "C",
      amount: 250,
      category: "other",
      time: "2018-03-02T10:33:00.000Z"
    },
    {
      id: 6,
      sourceAccount: "A",
      targetAccount: "C",
      amount: 250,
      category: "other",
      time: "2018-03-02T10:33:05.000Z"
    }
  ]
];

This is my code, but I did not like it. There are some nice way to do?

function findDuplicateTransactions (transactions = []) {
    var result = [];

    console.info("total itens :" + transactions.length);

      //sort
      transactions = transactions.sort((a,b)=> a.time.localeCompare(b.time))

      //remove itens not duplicated
      result = removeItens(transactions);


      //group
      result = groupBy(result, function(item){
          return [item.sourceAccount, item.targetAccount, item.amount, item.category];
      });

  console.info(result);

      //remove UniqueElements
      result = removeUniqueElements(result);



      return result;
  }

  function removeUniqueElements(array){
      var filtered = array.filter(function(value, index, arr){
          return value.length >= 2;
      });

      return filtered;
  }

  function removeItens(array){
      var itensToBeRemoved = [];
      for (var index = 0; index < array.length; index++) {
          const element1 = array[index];
          var cont = 0;

          console.info("============== looking for: " + element1.id);

          for (var index2 = 0; index2 < array.length; index2++) {
              const element2 = array[index2];

              if(element1.id != element2.id){


                var date1 = new Date(element1.time);
                var date2 = new Date(element2.time);

                var timeDiff = Math.abs(date2.getTime() - date1.getTime());

                console.info("comparing :" + element1.id + "<->" + element2.id + " diff: " + timeDiff);


                if( timeDiff < 60000) {
                    //keep it - is similar
                    console.info("find one duplicated: " + element2.id);
                    break;
                }else{
                    cont++;
                }
              }
          }

          //console.info("cont: " + cont)

          if(cont == array.length-1){
            //array.splice(index, 1);
            console.info("possible duplicated: " + element1.id);
            itensToBeRemoved.push(element1.id);
          }
      }

      var filtered = [];

      for(var i=0; i<itensToBeRemoved.length; i++){
          console.info("remove item: " + itensToBeRemoved[i]);
          array = arrayRemove(array, itensToBeRemoved[i]);
      }

    return array;
  }

function arrayRemove(arr, value) {
   return arr.filter(function(ele){
       console.info("watching: " + ele.id);
       console.info("index: " + value);
       return ele.id != value;
   });
}

  function groupBy( array , f ){
      var lists = {};
      array.forEach( function( o ){
          var list = JSON.stringify( f(o) );
          lists[list] = lists[list] || [];
          lists[list].push( o );  
      });
      return Object.keys(lists).map( function( list ){
          return lists[list]; 
      })
  }

On the basis of which key the objects are grouped. And also why obj with id:4 is not result? — Maheer Ali
– Maheer Ali, Commented Apr 13, 2019 at 13:27
Oh, there some rule not listed here... sorry. I will complete the question — Willians Martins
– Willians Martins, Commented Apr 13, 2019 at 23:52

Nina Scholz · Accepted Answer · 2019-04-14 07:37:42Z

2

You could sort the array in advance and reduce the array by looking for a group with the same category.

var data = [{ id: 3, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:34:30.000Z' }, { id: 1, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:00.000Z' }, { id: 6, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:05.000Z' }, { id: 4, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:36:00.000Z' }, { id: 2, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:50.000Z' }, { id: 5, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:00.000Z' }],
    result = data
        .sort(({ time: a }, { time: b }) => a.localeCompare(b))
        .reduce((r, o) => {
            var temp = r.find(([{ category }]) => category === o.category);
            if (!temp) r.push(temp = []);
            temp.push(o);
            return r;
        }, []);

console.log(result);

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

With a hash table.

const delta = (t1, t2) => Math.abs(new Date(t1) - new Date(t2));

var data = [{ id: 3, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:34:30.000Z' }, { id: 1, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:00.000Z' }, { id: 6, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:05.000Z' }, { id: 4, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:36:00.000Z' }, { id: 2, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:50.000Z' }, { id: 5, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:00.000Z' }],
    keys = ['sourceAccount', 'targetAccount', 'amount', 'category'],
    result = Object.values(data
        .sort(({ time: a }, { time: b }) => a.localeCompare(b))
        .filter((o, i, a) => {
            while (a[--i] && delta(o.time, a[i].time) < 60000) {
                if (keys.every(k => o[k] === a[i][k])) return;
            }
            return true;
        })
        .reduce((r, o) => ((r[o.category] = r[o.category] || []).push(o), r), {})
    );

console.log(result);

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

edited Apr 14, 2019 at 7:37

answered Apr 13, 2019 at 13:32

Nina Scholz

388k26 gold badges367 silver badges417 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

James Over a year ago

Nice but I would do category lookups with object keys to save time.

Nina Scholz Over a year ago

please see the second approach.

Willians Martins Over a year ago

if you see, the id: 4 is not in result, because the diference of time is more then 1 minute, I described the question after, sorry

Nina Scholz Over a year ago

why is id: 2 in ...?

Code Maniac · Accepted Answer · 2019-04-14 02:35:36Z

0

You can sort first based on time and than reduce

let data =  [{id: 3,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:34:30.000Z'},{id: 1,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:33:00.000Z'},
{id: 6,sourceAccount: 'A',targetAccount: 'C',amount: 250,category: 'other',time: '2018-03-02T10:33:05.000Z'},
{id: 4,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:36:00.000Z'},
{id: 2,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:33:50.000Z'},{id: 5,sourceAccount: 'A',targetAccount: 'C',amount: 250,category: 'other',time: '2018-03-02T10:33:00.000Z'}];

let sortedData = data.sort((a,b)=> a.time.localeCompare(b.time))

let keyTrack = sortedData[0].sourceAccount + sortedData[0].targetAccount
let temp = []
let final = sortedData.reduce((op,inp) => {
  let key = inp.sourceAccount + inp.targetAccount
  if(keyTrack !== key){
    keyTrack = key
    op.push(temp)
    temp = []
  }
  temp.push(inp)
  return op
},[])

if(temp.length){
  final.push(temp)
}

console.log(final)

edited Apr 14, 2019 at 2:35

answered Apr 13, 2019 at 13:32

Code Maniac

37.9k5 gold badges44 silver badges65 bronze badges

1 Comment

Willians Martins Over a year ago

if you see, the id: 4 is not in result, because the diference of time is more then 1 minute, I described the question after, sorry

Muhammad Shahzeb Kalam · Accepted Answer · 2022-11-26 10:21:00Z

The way you were doing was the best way but using some unnecessary code, please have a look at how I reduced your code and removed a few bugs e.g while removing we must check sourceAccount target account and etc as mentioned with time gaps as well.

function findDuplicateTransactions (transactions = []) {
    var result = [];
    //just for the result should be in ascending order
      result = transactions.sort((a,b)=> a.time.localeCompare(b.time));
      //remove unique transactions
      result = removeUniqueTransactions(result);
      //group with category
      result = groupItems(result);
      // returning result
      return result;
  }
  function removeUniqueTransactions (transactions = []) {
    var result = [];
    for (const item of transactions) {
      let lengthOfcheckInArray = 0;
      for(const item2 of transactions) {

        if(item.id !== item2.id) {
          if(
            Math.abs(new Date(item.time) - new Date(item2.time)) < 60000 && 
            item.amount === item2.amount && 
            item.sourceAccount === item2.sourceAccount && 
            item.targetAccount === item2.targetAccount && 
            item.category === item2.category
            ) {
              break;
          }else{
            lengthOfcheckInArray ++;
          }
        }
      }
      // just either unique in entire length of array or not
      if (lengthOfcheckInArray === transactions.length - 1) {
        result.push(item);
      }
    }
    return transactions.filter(trans => !result.includes(trans));
  }
  function groupItems (transactions = []) {
    var result = [];

    var group = transactions.reduce((r, a) => {
      r[a.category] = [...r[a.category] || [], a];
      return r;
    }, {});

    result = Object.values(group);

    return result;
  }

Collectives™ on Stack Overflow

Javascript - Group and Sort Objects

3 Answers 3

4 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related