Algorithm 计算二进制值的交集

在下面的算法中，我计算字符“1”出现的次数，并且在每个字符串中处于相同的位置

    def coeff3(a: String, b: String): Float = {
    val aArray = a.toArray
    val bArray = b.toArray
    var i, intersectCounter = 0;
    def coeff1: Int = {
      if ((aArray(i).asDigit == 1) && (bArray(i).asDigit == 1)) {
        intersectCounter += 2
      }
      i = i + 1
      if ((aArray.size) == i)
        intersectCounter
      else
        coeff1
    }

    coeff1

  }                                               //> coeff3: (a: String, b: String)Float

  val str1 = "10110"                              //> str1  : String = 10110
  val str2 = "10111"                              //> str2  : String = 10111

    coeff3(str1 , str2)  > res2: Float = 6.0

---

可以看到

coeff3（str1，str2）

返回6。有没有一种更实用的方法来代替这种递归方法？

您可以使用

zip

组合两个字符串，然后使用

count

查找

1

处于相同位置的次数

scala> str1.zip(str2).count(t => t._1 == '1' && t._2 == '1') * 2
res11: Int = 6

---

考虑这种一般方法，其中输入是字符串列表

implicit class RichCoeffs(val xss: List[String]) extends AnyVal {

  def coeff3(key: Char = '1'): Float = {
    if (xss.size < 2) 0F
    else
      xss.transpose.map{ xs => xs.forall { _ == key } }.count{ _ == true } * 2F
  }

}

其实

List("10110","10111").transpose
res: List[List[Char]] = List(List(1, 1), 
                             List(0, 0), 
                             List(1, 1), 
                             List(1, 1), 
                             List(0, 1))

因此，我们需要检查每个列表中的所有元素是否等于关键字符；然后我们计算有多少人满足这样的要求，并将问题中要求的金额加倍

现在让我们考虑一下

val strs = List("10110", "10111", "10100")

因此

---

一种方法是将它们转换为整数，并将它们的两两乘积相加，如下所示：

scala> (str1,str2).zipped.map(_.asDigit * _.asDigit).sum * 2
res19: Int = 6

还有一种方法：

scala> str1.zip(str2).count( _ == ('1','1') ) * 2
res77: Int = 6

scala> (str1,str2).zipped.map(_.asDigit * _.asDigit).sum * 2
res19: Int = 6

scala> str1.zip(str2).count( _ == ('1','1') ) * 2
res77: Int = 6