String 字符的 Scala int 值

Question

我只想对 BigInt 的数字求和。我可以这样做

scala> "1 2 3".split(" ").map(_.toInt).sum
res23: Int = 6

所以我尝试了

scala> BigInt(123).toString().map(_.toInt).sum
res24: Int = 150

这不起作用，因为它将字符映射到它们的 Unicode 值。

以下两者都可以工作，但是有没有比使用 Java 静态方法或额外的 toString 转换更优雅的方法？

BigInt(123).toString().map(Character.getNumericValue(_)).sum
BigInt(123).toString().map(_.toString.toInt).sum

（我还使用递归函数来完成此操作，完全避开字符串，但我对简洁的 1-liner 感兴趣。）

Answer 1

哇...这些答案到处都是！在这里，执行以下操作：

BigInt(123).toString().map(_.asDigit).sum

Answer 2

完全不使用字符串怎么样？

def sumDigits(b:BigInt):BigInt = {
  if (b < 10) b else b%10 + sumDigits(b/10)
}

Answer 3

这并不短，当然也效率不高，但它是另一种方法：（

scala> Iterator.iterate(BigInt(123))(_/10).takeWhile(_>0).map(_%10).sum
res1: scala.math.BigInt = 6

您可能需要一个 Int，无论如何它更快，但需要 .map(i=>( i%10).toInt)。）

此方法（以及直接递归）的问题在于您必须计算与数字一样多的除法。 （您可以使用 /% 将速度提高 2 倍，但这仍然是一个问题。）转换为字符串要快得多，因为所有这些显式 BigInt 创建是可以避免的。

如果您确实想要一些快速工作的东西（我知道不是您所要求的），您需要一种分而治之的方法：

def fastDigitSum(b: BigInt): Int = {
  val bits = b.bitLength
  if (bits < 63) math.abs(b.toLong).toString.map(_-'0').sum
  else {
    val many = 256
    val zeros = math.ceil(bits*0.150515).toInt // constant is 0.5*log(2)/log(10)
    val root = (
      if (zeros<many) BigInt("1" + "0"*zeros)
      else {
        Iterator.iterate((BigInt("1"+"0"*many),many))(x => (x._1 * x._1, 2*x._2)).
          find(_._2 > zeros/2).get._1
      }
    )
    val (q,r) = b /% root
    fastDigitSum(q) + fastDigitSum(r)
  }
}

---

编辑：如果您想要真正快各种尺寸的转换，我修改了我的方案如下。有一些不完全功能的位主要是由于缺少 takeTo 方法。这应该比所有大小的其他所有东西都快（尽管对于非常大的 BigInts，它渐近于 fastDigitSum 性能）。

在 64 位机器上可能会比 32 位机器上运行得更好

。在创建此函数的过程中不会损害任何字符串。

object DigitSum {
  val memend = BigInt(10000000000000000L) :: BigInt(100000000) :: Nil

  def longSum(l: Long, sum: Int = 0): Int = {
    if (l==0) sum else longSum(l/10, sum + (l%10).toInt)
  }

  def bigSum(b: BigInt, memo: List[BigInt] = Nil): Int = {
    val bits = b.bitLength
    if (bits < 64) longSum(b.toLong)
    else {
      val mem = (
        if (memo.isEmpty) {
          val it = Iterator.iterate(memend.head)(x=>x*x).drop(1)
          var xs = memend
          while (xs.head.bitLength*4 <= bits) xs = it.next :: xs
          xs
        }
        else memo.dropWhile(_.bitLength > bits/2)
      )
      val (q,r) = b /% mem.head
      bigSum(q,memo) + bigSum(r,memo)
    }
  }
}

（好吧——此时这有点像代码高尔夫。）

Answer 4

我不认为它比你已经拥有的好多少，但

BigInt(123).toString().split("").tail.map(_.toInt).sum

也有效。

另外

BigInt(123).toString().map(_.toInt - '0'.toInt).sum

，根据 Rex Kerr 的评论，这可以简化为

BigInt(123).toString().map(_-'0').sum

Answer 5

这不是问题的答案，而是对建议的速度测试。我多次运行测试，以确保虚拟机已预热且结果一致：这些结果具有代表性，并且适用于 10000 次迭代。请参阅代码以了解这些方法的定义。

对于 10 位 BigInts

fastDigitSum: 0.020618047 seconds
stringSum:    0.023708908 seconds
stringSum2:   0.02940999 seconds
stringSum3:   0.021641507 seconds
division:     0.052856631 seconds

对于 50 位 BigInts

fastDigitSum: 0.183630732 seconds
stringSum:    0.110235062 seconds
stringSum2:   0.134900857 seconds
stringSum3:   0.096670394 seconds
division:     0.317359989 seconds

对于 100 位 BigInts

fastDigitSum: 0.427543476 seconds
stringSum:    0.228062302 seconds
stringSum2:   0.277711389 seconds
stringSum3:   0.20127497 seconds
division:     0.811950252 seconds

对于 100,000 位 BigInts （1 次迭代）

fastDigitSum: 0.581872856 seconds
stringSum:    2.642719635 seconds
stringSum2:   2.629824347 seconds
stringSum3:   2.61327453 seconds
division:     30.089482042 seconds

所以看起来 BigInt(123).toString().map(_-'0').sum< /code> 是较小 BigInt 的速度和简洁性方面的赢家，但如果您的 BigInt 很大，则 Rex Kerr 的方法很好。

基准代码：

object Benchmark extends App{
  def fastDigitSum(b: BigInt): Int = {
    val bits = b.bitLength
    if (bits < 63) math.abs(b.toLong).toString.map(_-'0').sum
    else {
      val many = 256
      val zeros = math.ceil(bits*0.150515).toInt // constant is 0.5*log(2)/log(10)
      val root = (
        if (zeros<many) BigInt("1" + "0"*zeros)
        else {
          Iterator.iterate((BigInt("1"+"0"*many),many))(x => (x._1 * x._1, 2*x._2)).
            find(_._2 > zeros/2).get._1
        }
      )
      val (q,r) = b /% root
      fastDigitSum(q) + fastDigitSum(r)
    }
  }

  def stringSum(b: BigInt) = b.toString.map(_.getNumericValue).sum
  def stringSum2(b: BigInt) = b.toString.map(_.toString.toInt).sum
  def stringSum3(b: BigInt) = b.toString.map(_ - '0').sum

  def division(b: BigInt) = sumDig(b, 0)
  def sumDig(b: BigInt, sum: Int):Int = {
    if (b == 0) sum
    else sumDig(b / 10, sum + (b % 10).toInt)
  }

  def testMethod(f: BigInt => Int):Double = {
    val b = BigInt("12345678901234567890123456789012345678901234567890")
    val b2 = BigInt("1234567890")
    val b3 = BigInt("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890")
    val t0 = System.nanoTime()
    var i = 0
    while(i < 10000){
      f(b3)
      i += 1
    }
    (System.nanoTime().toDouble - t0)/1e9
  }

  def runTest(){
    var i = 0
    while (i < 5) {
      println("fastDigitSum: " + testMethod ({fastDigitSum}) + " seconds")
      println("stringSum:    " + testMethod ({stringSum}) + " seconds")
      println("stringSum2:   " + testMethod ({stringSum2}) + " seconds")
      println("stringSum3:   " + testMethod ({stringSum3}) + " seconds")
      println("division:     " + testMethod ({division}) + " seconds")
      i += 1
    }
  }

  runTest()
}

Answer 6

我刚刚注意到 RichChar 类有一个 getNumericValue 方法，所以答案是

BigInt(123).toString().map(_.getNumericValue).sum