Problem:
Score : 100 points

Problem Statement

Cat Snuke is learning to write characters.
Today, he practiced writing digits 1 and 9, but he did it the other way around.

You are given a three-digit integer n written by Snuke.
Print the integer obtained by replacing each digit 1 with 9 and each digit 9 with 1 in n.

Constraints

111 \leq n \leq 999

n is an integer consisting of digits 1 and 9.

Input

Input is given from Standard Input in the following format:

n

Output

Print the integer obtained by replacing each occurrence of 1 with 9 and each occurrence of 9 with 1 in n.

Sample Input 1

119

Sample Output 1

991

Replace the 9 in the ones place with 1, the 1 in the tens place with 9 and the 1 in the hundreds place with 9. The answer is 991.

Sample Input 2

999

Sample Output 2

111

Solution in Scala (2.11.7) (judge verdict: Runtime Error)

import scala.io.StdIn

object Main {
    def main(args: Array[String]) = {
        StdIn.readLine()
        val a = StdIn.readLine().split(" ").toList.map { str: String => str.toInt }

        def getAlternateIndex(intList: List[Int], result: List[Int] = Nil): List[Int] = intList match {
                case Nil => result.reverse
                case int :: tail => getAlternateIndex(tail.drop(1), int :: result)
        }

        val even = getAlternateIndex(a)
        val odd  = getAlternateIndex(a.drop(1))

        def makeMap(key: Set[Int], value: List[Int], map: Map[Int, Int] = Map.empty[Int, Int]): Map[Int, Int] = {
            key.toList match {
                case Nil => map
                case k :: tail => makeMap(tail.toSet, value.filter { v: Int => k != v }, map + (k -> value.count { v: Int => k == v }))
            }
        }

        val evenMap = makeMap(even.toSet, even)
        val oddMap = makeMap(odd.toSet, odd)

        val evenMax = evenMap.maxBy(item => item._2)
        val oddMax  = oddMap.maxBy(item => item._2)

        var evenMaxVal = evenMax._2
        var oddMaxVal  = oddMax._2

        val evenMaxKey = evenMax._1
        val oddMaxKey  = oddMax._1

        var count = even.toSet.size + odd.toSet.size match {
            case x: Int if x < 2 => 0
            case _ =>
                if (evenMaxKey == oddMaxKey) {
                    {
                        if (evenMaxVal < oddMaxVal) {
                            var t = makeMap(even.filter { num: Int => num != oddMaxKey }.toSet, even.filter { num: Int => num != oddMaxKey })
                            evenMaxVal = {
                                if (t == Map.empty) {
                                   0
                                } else {
                                   t.maxBy(item => item._2)._2
                                }
                            }
                        } else {
                            var t = makeMap(odd.filter { num: Int => num != evenMaxKey }.toSet, even.filter { num: Int => num != evenMaxKey })
                            evenMaxVal = {
                                if (t == Map.empty) {
                                    0
                                } else {
                                    t.maxBy(item => item._2)._2
                                }
                            }
                        }
                    }
                }
                even.size - evenMaxVal + odd.size - oddMaxVal
        }
        println(count)
    }
}