Accueil > Enseignement > Flux de données en programmation (M2) > Découverte du langage Scala

Découverte du langage Scala

vendredi 6 mars 2015, par Pierre

Références

– API Scala officielle
– site communautaire de documentation

Autres ressources

– Vidéo d’introduction générale à Scala, par Martin Odersky Working Hard to Keep It Simple (en, 16:31, 2011).
– Deux cours sur Coursera (mais c’est fermé aux non inscrits, et on ne peut s’inscrire que lors d’une session) : Functional Programming Principles par Martin Odersky et Reactive Functional Programming par Martin Odersky, Erik Meijer et Roland Kuhn.
– Sites web Scala Scool ! et [http://www.scala-tour.com/] (façon prezi).
– Une longue refcard, format page web.
– La société Typesafe propose le Typesafe Activator à installer et tester (IDE dans le navigateur, tutos).
– Pour apprendre Scala en jouant : Scalatron.
– Pour comparer les syntaxes des langages de programmation.
http://hyperpolyglot.org/

Exercice sur la recherche de phrases anagrammes

On utilise le lexique du français compulsé par Christophe Pallier, qu’il faut convertir en utf-8 : C-x Ret f dans Emacs puis C-x C-s, ou bien en utlisiant iconv dans un shell :

iconv -f windows-1252 -t utf-8 liste.de.mots.francais.frgut.txt > lexique.txt

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("--------------")
}

Découverte du langage Scala

Références

Autres ressources

Exercice sur la recherche de phrases anagrammes

Portfolio