Problem:
Problem C: !

You are one of ICPC participants and in charge of developing a library for multiprecision numbers
and radix conversion. You have just finished writing the code, so next you have to test if it
works correctly. You decided to write a simple, well-known factorial function for this purpose:

Your task is to write a program that shows the number of trailing zeros when you compute M!
in base N, given N and M.

Input

The input contains multiple data sets. Each data set is described by one line in the format
below:

N M

where N is a decimal number between 8 and 36 inclusive, and M is given in the string repre-
sentation in base N. Exactly one white space character appears between them.

The string representation of M contains up to 12 characters in base N. In case N is greater
than 10, capital letters A, B, C, ... may appear in the string representation, and they represent
10, 11, 12, ..., respectively.

The input is terminated by a line containing two zeros. You should not process this line.

Output

For each data set, output a line containing a decimal integer, which is equal to the number of
trailing zeros in the string representation of M! in base N.

Sample Input

10 500
16 A
0 0

Output for the Sample Input

124
2

Solution in Scala (judge verdict: Accepted)

object Main extends App {

  import scala.io.StdIn._

  solve
  def solve: Unit = {
    val Array(n, m) = readLine.trim.split(' ')
    if (n == "0") return
    val value = m.toBasedInt(n.toInt)
    println(List(31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2).filter(n.toInt % _ == 0).map{prime ⇒ countFactorInFactorial(value, prime) / countPrimeFactor(n.toInt, prime)}.min)
    solve
  }
  implicit class ToBase(val str: String) extends AnyVal {
    def toBasedInt(base: Int): Long = {
      str.foldLeft(0L){
          case (a, b) if b.isDigit ⇒ a * base + b.asDigit
          case (a, b) ⇒ a * base + b - 'A' + 10
        }
      }
  }
  def countPrimeFactor(value: Int, prime: Int): Int = {
    value % prime match {
      case 0 ⇒ 1 + countPrimeFactor(value / prime, prime)
      case _ ⇒ 0
    }
  }
  def countFactorInFactorial(value: Long, prime: Long): Long = {
    value match {
      case 0 ⇒ 0
      case _ ⇒ value / prime + countFactorInFactorial(value / prime, prime)
    }
  }
  implicit class Extension[T](val value :T) extends AnyVal {
    @inline
    def let[A](@inline func: T ⇒ A): A = func(value)
    @inline
    def also(@inline func: T ⇒ Unit): T = {func(value); value}
    @inline
    def takeIf(@inline predicate: T ⇒ Boolean): Option[T] = Some(value).filter(predicate)
  }
}