Comparing items in two lists

Question

I have two lists : List(1,1,1) , List(1,0,1)

I want to get the following :

1. A count of every element that contains a 1 in first list and a 0 in the corresponding list at same position and vice versa. In above example this would be 1 , 0 since the first list contains a 1 at middle position and second list contains a 0 at same position (middle).

2. A count of every element where 1 is in first list and 1 is also in second list. In above example this is two since there are two 1's in each corresponding list. I can get this using the intersect method of class List.

I am just looking an answer to point 1 above. I could use an iterative a approach to count the items but is there a more functional method ? Here is the entire code :

class Similarity {
  def getSimilarity(number1: List[Int], number2: List[Int]) = {
    val num: List[Int] = number1.intersect(number2)
    println("P is " + num.length)
  }
}

object HelloWorld {
  def main(args: Array[String]) {
    val s = new Similarity
    s.getSimilarity(List(1, 1, 1), List(1, 0, 1))
  }
}

Answer 1

For the first one:

scala> val a = List(1,1,1)
a: List[Int] = List(1, 1, 1)

scala> val b = List(1,0,1)
b: List[Int] = List(1, 0, 1)

scala> a.zip(b).filter(x => x._1==1 && x._2==0).size
res7: Int = 1

For the second:

scala> a.zip(b).filter(x => x._1==1 && x._2==1).size
res7: Int = 2

Answer 2

You can count all combinations easily and have it in a map with

def getSimilarity(number1 : List[Int] , number2 : List[Int]) = {

  //sorry for the 1-liner, explanation follows 
  val countMap = (number1 zip number2) groupBy (identity) mapValues {_.length}

}

/*
 * Example
 * number1 = List(1,1,0,1,0,0,1)
 * number2 = List(0,1,1,1,0,1,1)
 * 
 * countMap = Map((1,0) -> 1, (1,1) -> 3, (0,1) -> 2, (0,0) -> 1)
 */

---

The trick is a common one

// zip the elements pairwise

(number1 zip number2) 

/* List((1,0), (1,1), (0,1), (1,1), (0,0), (0,1), (1,1))
 *
 * then group together with the identity function, so pairs
 * with the same elements are grouped together and the key is the pair itself
 */ 

.groupBy(identity) 

/* Map( (1,0) -> List((1,0)), 
 *      (1,1) -> List((1,1), (1,1), (1,1)), 
 *      (0,1) -> List((0,1), (0,1)), 
 *      (0,0) -> List((0,0))
 * )
 *
 * finally you count the pairs mapping the values to the length of each list
 */

.mapValues(_.length)

/* Map( (1,0) -> 1, 
 *      (1,1) -> 3, 
 *      (0,1) -> 2, 
 *      (0,0) -> 1
 * )

Then all you need to do is lookup on the map