DouKaku?

＜入力例＞
ドウカク org ヘ ヨウコソ
コノ サイト ハ ダサレタ オダイ ヲ イカニ トクカ キソイアウ
 プログラマ ノ タメノ コロシアム デス
トウコウ ヲ タメシテ ミタイ カタ ハ テスト
トリアエズ ナガメテ ミタイ カタ ハ ゲンゴ ノ イチラン ガ オススメ デス

＜出力例＞
ドウモク org ヘ ヨウコソ
コノ ザレゴト ハ ダサレタ オダイ ヲ イワハダ トシシタ キソイアウ
 プログラマ ノ タチノミ コロシアム デス
トウコウ ヲ ハナシテ ミチノリ カタ ハ プリント
トリアエズ ナガメテ ミツリン カタ ハ ゲンゴ ノ キンラン ガ オススメ デス

import    java.io.{File,FileInputStream,InputStreamReader,BufferedReader}
import    scala.util.Random

object LevenshteinDistance {
    def distance(a:String, b:String) = {
        var    t:List[List[Int]] = List.range(a.size, -1, -1).foldLeft(List[List[Int]]())(
            (r,i) => i match {
                case 0 => List.range(0, b.size + 1)::r
                case _ => (i::List.make(b.size, 0))::r
            }
        )
        1.to(t.size - 1).foreach(i =>
            1.to(t(i).size - 1).foreach(j =>
                t = t.take(i) ++
                    List(
                        t(i).take(j) ++
                        List(
                            (t(i - 1)(j) + 1)
                            .min(t(i)(j - 1) + 1)
                            .min(
                                t(i - 1)(j - 1) +
                                ((a(i - 1) == b(j - 1)) match { case true => 0; case _ => 1 })
                            )
                        ) ++
                        t(i).takeRight(t(i).size - j - 1)
                    ) ++
                    t.takeRight(t.size - i - 1)
            )
        )
        t.last.last
    }
}

class CKnights(f:String, e:String) {
    var    d:List[String] = List()
    val    i:BufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(f), e))
    val    r:Random = new Random
    while(i.ready) {
        val    l:String = i.readLine
        if (l != "") d = d:::l.split("\\s+").toList
    }
    i.close
    def translate(s:String)(j:(String,String)=>Boolean):List[String] =
        s.split("\\s+").foldRight(List[String]())((w,k) =>
            (d.filter(e => j(w, e)) match {
                case t if t.isEmpty => w
                case t => t(r.nextInt(t.size))
            })::k
        )
}

object Knights {
    def source:List[String] = readLine match {
            case null => List()
            case l => l::source
        }
    def main(args:Array[String]):Unit = args.size match {
            case a if a != 1 => println("usage: Knights DICTFILE")
            case _ => {
                var    s:List[String] = source
                var    k:CKnights = new CKnights(args.first, "Shift_JIS")
                println("入力:")
                s.foreach(l => println(l))
                println("出力:")
                s.foreach(l => println(
                        k.translate(l)((w, e) =>
                            LevenshteinDistance.distance(w, e).toFloat / w.size.max(e.size) < 0.5
                        ).mkString(" ")
                    )
                )
                println("出力:")
                s.foreach(l => println(
                        k.translate(l)((w, e) =>
                            Math.abs(w.size - e.size) <= 1 && w.first == e.first && w.last == e.last
                        ).mkString(" ")
                    )
                )
            }
        }
}