Try(Source.fromURL(url).getLines.toList).getOrElse(List())

//(2) 

def removeN[A](xs: List[A], elem: A, n: Int) : List[A] = xs match {

    case Nil => Nil

    case x :: tail if x == elem && n > 0 => removeN(tail, elem, n - 1)

    case x :: tail => x :: removeN(tail, elem, n)

    (for(index <- (0 to word.length-1); if (word(index) != secret(index))) yield secret(index).toChar).toList

// t

    if (secret.isEmpty) List()

        if (secret.head == word.head) Correct :: aux(secret.tail, word.tail, pool)

        else if (pool.contains(word.head)) Present :: aux(secret.tail, word.tail, pool.filterNot(_ == word.head))

        else Absent :: aux(secret.tail, word.tail, pool)

def score(secret: String, word: String) : List[Tip] = aux(secret.toList, word.toList, pool(secret, word))

def eval(t: Tip) : Int = t match {

    case Correct => 10

    case Present => 1

    case Absent => 0 

def iscore(secret: String, word: String) : Int =  (for(current <- score(secret, word)) yield eval(current)).sum

// (5) t

    if (secrets.isEmpty) acc

    else {

        val score = iscore(secrets.head, word)

        if (score == current) lowest(secrets.tail, word, current, secrets.head :: acc)

        else if (score < current) lowest(secrets.tail, word, score, List(secrets.head))

        else lowest(secrets.tail, word, current, acc)

def evil(secrets: List[String], word: String) = lowest(secrets, word, Int.MaxValue ,List())

// (6) t

    val occurrences = secrets.mkString.groupBy(identity).mapValues(_.length)

    val all_letters = secrets.mkString.length.toDouble

    occurrences.map{ case (c, n) => c -> (1 - n/all_letters) }.toMap

// (7) 

def rank(frqs: Map[Char, Double], s: String) : Double = s.map(c => frqs(c)).sum

def ranked_evil(secrets: List[String], word: String): List[String] = {

    val frqs = frequencies(secrets)

    val ranked_secrets = evil(secrets, word).map(s => (s, rank(frqs, s)))

    List((ranked_secrets.sortWith(_._2 > _._2)).map(_._1).head )

}