Find duplicates in an array of accounts

Question

The challenge description is as follows:

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

The input is as follows:

[
  {
    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'
  }
];

This is what the output should look like:

[
  [
    {
      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"
    }
  ]
];

I got the sorting done. This code returns an array of objects which key has all common values, the object and sorted by date:

function findDuplicateTransactions (transactions = []) {
return transactions.map(t => ({
    key: JSON.stringify([t.sourceAccount, t.targetAccount, t.amount, t.category]), 

    t
})).sort((a,b) => 
    a.t.time.localeCompare(b.t.time)).sort((a, b) =>a.key < b.key ? -1 : 1)}

I´m missing the last step, in which I should compare one agaisnt each other and form arrays. I´m guessing reduce is in order, but I can´t wrap my head around it. Could anyone help?

What happens to the transactions that are more than 1 minute? Are they not included in the results? — Jorjon, Feb 24 '20 at 21:49
Perhaps you can gain insight from [this question's answers](https://stackoverflow.com/q/46794232/215552)? — Heretic Monkey, Feb 24 '20 at 22:31

Sunil Lama · Answer 1 · 2020-02-24T23:09:44.883

First map the array using the same values, then sort it on the basis of time like below:

var arr = [{
    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'
  }
];

function findDuplicateTransactions(transactions = []) {
  return transactions.reduce((ini, curr, idx) => {
    if (ini[
        curr.sourceAccount +
        curr.targetAccount +
        curr.amount +
        curr.category]) {
      ini[curr.sourceAccount + curr.targetAccount + curr.amount + curr.category]
        .push(curr);
    } else {
      ini[
        curr.sourceAccount +
        curr.targetAccount +
        curr.amount +
        curr.category] = [curr];
    }
    return ini;
  }, []);

}

var result = Object.values(findDuplicateTransactions(arr));

var expected = result.map(x => sortDate(x)).map(y => checkTimeDiff(y));

function checkTimeDiff(array) {
  var returnArr = [];
  returnArr.push(array[0]);
  for (var i = 0; i < array.length - 1; i++) {
    if ((new Date(array[i + 1].time) - new Date(array[i].time)) / 60000 <= 1) {
      returnArr.push(array[i + 1]);
    }
  }
  return returnArr;
}

function sortDate(array) {
  return array.sort(function(a, b) {
    var keyA = new Date(a.time),
      keyB = new Date(b.time);
    // Compare the 2 dates
    if (keyA < keyB) return -1;
    if (keyA > keyB) return 1;
    return 0;
  });
}
console.log(expected);

Thanks, but this doesn´t work: it still includes id4 which has a difference bigger than a minute when compared to the others. — Edgardo Minotauro, Feb 24 '20 at 22:52
@EdgardoMinotauro, just add a time difference function like above, check the edited function — Sunil Lama, Feb 24 '20 at 23:10
Good answer. I decided to bail, getting the sense that I was a programmer for hire, here, at very low pay. — danh, Feb 25 '20 at 00:44

danh · Answer 2 · 2020-02-24T22:37:46.363

Consider that Transaction is an object which can be taught to say whether it's a dup of another transaction...

const transactionData = [{
    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'
  }
]


class Transaction {
  constructor(obj) {
    Object.assign(this, obj)
  }
  isDupOf(xaction) {
    return (
      this.id !== xaction.id &&  // transactions are not dups of themselves
      this.sourceAccount == xaction.sourceAccount &&
      this.targetAccount == xaction.targetAccount &&
      this.category == xaction.category &&
      this.amount == xaction.amount &&
      this.hasAboutTheSameTimeAs(xaction))

  }
  hasAboutTheSameTimeAs(xaction) {
    let msDiff = Math.abs(new Date(this.time) - new Date(xaction.time))
    return msDiff < 60000
  }
}

// transform the data into objects
const transactions = transactionData.map(d => new Transaction(d))

// this could be a static method on transaction
function isDupWithinTransactions(xaction) {
  return transactions.some(t => t.isDupOf(xaction))
}

const dups = transactions.filter(t => isDupWithinTransactions(t))
console.log(dups.sort((a,b) => a.id - b.id))

It doesnt really work since it includes id4 which is over an minute when compared to the others in the same category. — Edgardo Minotauro, Feb 24 '20 at 22:24
Edited: (1) forgot to match amounts, (2) also sorted by id, which I figured you'd figure out. — danh, Feb 24 '20 at 22:37
The output has two nested arrays, this one is only an array of objects. — Edgardo Minotauro, Feb 24 '20 at 22:44
@danh, the op wants to group the object on the basis of similarity in values, I think that is the only part missing in your answer — Sunil Lama, Feb 24 '20 at 23:16

score 0 · Answer 3 · answered Feb 25 '20 at 05:53

Didn't do any fancy map, reduce, filter, etc. just a little brute force iteration but I think this gives you what you want. Basically took the result of your findDuplicateTransactions (note I added a new attribute to you map in the function called dt that contains milliseconds for the timestamp for coparison purposes) and then did the following:

filter to remove any transactions that are not within 1 minute of the transaction before/after with the same key
loop through putting each unique key in its own sub array of a master array.

masterArray should contain what you want.

function findDuplicateTransactions (transactions = []) {
    return transactions.map(t => ({
    key: JSON.stringify([t.sourceAccount, t.targetAccount, t.amount, t.category]), 
    dt: new Date(t.time).valueOf(),
    t
    })).sort((a,b) => 
    a.t.time.localeCompare(b.t.time)).sort((a, b) =>a.key < b.key ? -1 : 1)
}
var sortedArray = findDuplicateTransactions(transactionData);
var filteredArray = [];
for (var i=0; i<sortedArray.length; i++) {
    if ((i<sortedArray.length-1 && sortedArray[i].key == sortedArray[i+1].key && sortedArray[i+1].dt - sortedArray[i].dt < 60000) || 
        (i>0 && sortedArray[i].key == sortedArray[i-1].key && sortedArray[i].dt - sortedArray[i-1].dt < 60000)) 
      filteredArray.push(sortedArray[i]);
}
var masterArray = [];
var subArray = [];
var lastkey = "";
for (var i=0; i<filteredArray.length; i++) {
    if (filteredArray[i].key != lastkey) {
        if (subArray.length>0) masterArray.push(subArray);
        subArray = [];
    }
    subArray.push(filteredArray[i]);
    lastkey = filteredArray[i].key;
}
masterArray.push(subArray);

Find duplicates in an array of accounts

3 Answers3