Découverte du langage Scala

package anagrammes
 
object Anagrammes extends App {
 
  def lettres(mot: String) = mot 
    .filter(_.isLetter)
    . groupBy((a:Char)=>a)
    .mapValues(_.length)
 
  def inf(x: Map[Char, Int], y: Map[Char, Int]): Boolean =
    x.keys.forall( (a: Char) => x(a) <= y.getOrElse(a, 0))  
 
  def sub(x: Map[Char, Int], y: Map[Char, Int]): Map[Char, Int] =
     x.map( {case (a: Char, n : Int) => (a, n - y.getOrElse(a, 0))})
     .filter({case (a, n) => n > 0})
 
  def test1 = {
    println(sub(lettres("aaabbc"), lettres("aaab")))
    println(inf(lettres("aaabbc"), lettres("aaab")))
    println(inf(lettres("aaabbc"), lettres("aaaabbbcccf")))
  }
 
  lazy val lexique = {
    val source = scala.io.Source.fromFile("liste.de.mots.francais.frgut.txt", "utf-8")
    val lignes = source.getLines.toList
    source.close()
    print("création du lexique...")
    val lexique = lignes.groupBy(lettres)
    println(" OK --------------------------------------------------")
    val (maxk, maxs) = lexique.maxBy({case (k,xs) => xs.length}) 
    println("Le lexique contient :\n"
          + lignes.size + " mots répartis en\n"
          + lexique.size + " entrées\n"
          + "La plus grande " + maxk + "\n"
          + "contient " + maxs.length + " mots :\n"
          + maxs)
   println("----------------------------------------------------------------------------")
    lexique 
  }
 
  def soluce1 = {
    println(lexique.get(lettres("vélo")))
  }
 
  def soluce2 = {
    val cible = lettres("sommeil profond")
    val lex = lexique.filterKeys(inf(_, cible))
    println("fin du filtre")
    def solutions = for {
      bag1 <- lex.keys
      bag2 = sub(cible, bag1)
      if lex contains bag2     
    } yield (bag1, bag2)
 
    println("affichage des phrases de deux mots")
    for {
      (bag1, bag2) <- solutions
      mot1 <- lex(bag1)
      mot2 <- lex(bag2)
    } println(mot1 + " " + mot2)
    println("fin")
  }
 
 def soluce2stream = {
    val cible = lettres("sommeil profond")
    val lex = lexique.keys.toStream.filter(inf(_, cible))
    println("fin du filtre")
    def solutions = for {
      bag1 <- lex
      bag2 = sub(cible, bag1)
      if lexique contains bag2     
    } yield (bag1, bag2)
 
    println("affichage des phrases de deux mots")
    for {
      (bag1, bag2) <- solutions
      n = bag1.values.sum
      espaces = " " * (n - 1) + "|" 
      u = println("")
      (mot1, mot2) <- lexique(bag1).zipAll(lexique(bag2), espaces, "|")
    } println(mot1 + " " + mot2)
  }
 
  def soluce3 = {
    println("recherche des solutions en trois mots")
    val cible = lettres("le scénario comique")
    val lex = lexique.keys.filter(inf(_, cible))
    val solutions = for {
    bag1 <- lex
    cible2 = sub(cible, bag1)
    bag2 <- lex.filter(inf(_, cible2))
    bag3 = sub(cible2, bag2)
    if lexique contains bag3
    } yield (bag1, bag2, bag3)
 
    println("affichage des phrases de trois mots")
    for {
      (bag1, bag2, bag3) <- solutions
      mot1 <- lexique(bag1)
      mot2 <- lexique(bag2)
      mot3 <- lexique(bag3)
    }  println(mot1 + " " + mot2 + " " + mot3)
  }
 
  def soluce3stream = {
    println("recherche des solutions en trois mots")
    val cible = lettres("le scénario comique")
    val lex = lexique.keys.toStream.filter(inf(_, cible))
    val solutions = for {
    bag1 <- lex
    cible2 = sub(cible, bag1)
    bag2 <- lex.filter(inf(_, cible2))
    bag3 = sub(cible2, bag2)
    if lexique contains bag3
    } yield (bag1, bag2, bag3)
 
    println("affichage des phrases de trois mots")
    for {
      (bag1, bag2, bag3) <- solutions
      espaces1 = " " * (bag1.values.sum - 1) + "|"   
      espaces2 = " " * (bag2.values.sum - 1) + "|"
      mots = lexique(bag1).zipAll(lexique(bag2)
             .zipAll(lexique(bag3), espaces2, "|"), espaces1, ("",""))
      u = println("")
      (mot1, (mot2, mot3)) <- mots
    }  println(mot1 + " " + mot2 + " " + mot3)
  }
 
  //test1
  //soluce1
  soluce2stream
  //soluce3stream
  println("--------------")
}