Question

在下面的算法中，我计算了char＆＃34; 1＆＃34;出现并且在每个字符串中也处于相同的位置。

    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.是否有一种更具功能性的方法来解决这个而不是这种递归方法？

Answer 1

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

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").coeff3()
res: Float = 6.0

实际上

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")

因此

strs.coeff3()
res: Float = 4.0

strs.coeff3('3')
res: Float = 0.0

strs.coeff3('1')
res: Float = 4.0

strs.coeff3('0')
res: Float = 2.0

Answer 2

您可以使用zip组合两个字符串，然后使用count查找1处于同一位置的次数。

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

Answer 3

一种方法是将它们转换为Ints并将它们的成对产品相加：

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

这是另一种方式：

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

计算二进制值的交集

3 个答案: