Problem:
Problem H: Eleven Lover

Edward Leven loves multiples of eleven very much. When he sees a number, he always tries
to find consecutive subsequences (or substrings) forming multiples of eleven. He calls such
subsequences as 11-sequences. For example, he can find an 11-sequence 781 in a number 17819.

He thinks a number which has many 11-sequences is a good number. He would like to find out
a very good number. As the first step, he wants an easy way to count how many 11-sequences
are there in a given number. Even for him, counting them from a big number is not easy.
Fortunately, one of his friends, you, is a brilliant programmer. He asks you to write a program
to count the number of 11-sequences. Note that an 11-sequence must be a positive number
without leading zeros.

Input

The input is a sequence of lines each of which contains a number consisting of less than or equal
to 80000 digits.

The end of the input is indicated by a line containing a single zero, which should not be processed.

Output

For each input number, output a line containing the number of 11-sequences.

You can assume the answer fits in a 32-bit signed integer.

Sample Input

17819
1111
11011
1234567891011121314151617181920
0

Output for the Sample Input

1
4
4
38

Solution in Scala (judge verdict: Accepted)

import scala.annotation.tailrec
import scala.collection.mutable

object Main extends App {
  import scala.io.StdIn._
  loop()
  @tailrec def loop(): Unit = {
    val str = readLine.trim
    if (str == "0") return
    val memo = Array.fill(str.length){Array.fill(11){-1}}
    val digits = str.map(_.asDigit).toArray
    println(digits.indices.filterNot(digits(_) == 0).map{i ⇒ search(i, 0, digits, memo)}.sum)
    loop()
  }
  def search(current: Int, prev: Int, digits: Array[Int], memo: Array[Array[Int]]): Int = {
    if (current == digits.length) return 0
    if (memo(current)(prev) >= 0) return memo(current)(prev)
    memo(current)(prev) = if ((digits(current) + prev * 10) % 11 == 0) 1 else 0
    memo(current)(prev) += search(current + 1, (digits(current) + prev * 10) % 11, digits, memo)
    memo(current)(prev)
  }
}