Subtract Seq[A] from Seq[B]

Question

I have two classes A and B. Both of them have the same property: id and many other different properties.

How can I subtract Seq[A] from Seq[B] by matching the id's?

Luis Miguel Mejía Suárez · Answer 1 · 2019-05-22T15:36:56.130

4

This should work as long as the id field of both classes have the same type.

val as: Seq[A] = ???
val bs: Seq[B] = ???

val asSet = as.iterator.map(a => a.id).toSet
val substracted: Seq[B] = bs.filterNot(b => asSet(b.id))

edited May 22 '19 at 15:36

answered May 22 '19 at 14:55

Luis Miguel Mejía Suárez

21,686
3
28
45

this would fail if `as` is infinite! – stew May 22 '19 at 16:26
@stew If `as` is infinite I do not see any way of solving the problem. I agree that is the problem of using a failed abstraction like `Seq`. – Luis Miguel Mejía Suárez May 22 '19 at 16:40

score 4 · Accepted Answer · answered May 22 '19 at 15:26

4

Another feasible solution:

val seqSub = seqB.filterNot(x => seqA.exists(_.id == x.id))

answered May 22 '19 at 15:26

det0

281
2
5

ALee · Answer 3 · 2021-03-22T23:53:35.973

Couldn't find an answer matching my definition of subtract, where duplicate elements aren't filtered, (e.g. Seq(1,2,2) subtract Seq(2) = Seq(1,2), det0's definition gives Seq(1) so posting it here.

    trait IntId {
      def id: Int
    }
    
    case class A(id: Int) extends IntId
    
    case class B(id: Int) extends IntId
    
    val seqB = Seq(B(1),B(4),B(7),B(7),B(7))
    
    val seqA = Seq(A(7))

    // BSubtractA =  Seq(B(1),B(4),B(7),B(7)), only remove one instance of id 7
    val BSubtractA = seqA.foldLeft(seqB){
      case (seqBAccumulated, a) =>
        val indexOfA = seqBAccumulated.map(_.id).indexOf(a.id)
        if(indexOfA >= 0) {
          seqBAccumulated.take(indexOfA) ++ seqBAccumulated.drop(indexOfA + 1)
        }
        else {
          seqBAccumulated
        }
    }

Yes, there are shortcomings to this solution. For example, if seqA is larger than seqB , then it runs into null pointers (+ I haven't refactored it into a def). Also the performance could be improved to iterate fewer times over the input, however, this satisfied my use case.

Instead of `acc.take(x) ++ acc.drop(x+1)` you could just `acc.patch(x, Seq(), 1)`. — jwvh, Mar 17 '21 at 16:46
@jwvh Agreed. I copied the first answer from here: https://stackoverflow.com/questions/18847249/how-to-remove-an-item-from-a-list-in-scala-having-only-its-index But I think you're right `patch` is also valid — ALee, Mar 18 '21 at 09:21

score 0 · Answer 4 · answered Jan 18 '23 at 19:11

0

That will be far more clean -

val seqSub = seqB.filterNot(x => seqA.contains(x))

answered Jan 18 '23 at 19:11

Maor Aharon

312
3
14

Subtract Seq[A] from Seq[B]

4 Answers4