Découverte du langage Scala

Photo Nelson Pavlosky en cc-By-Sa

, 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

  1. package anagrammes
  2.  
  3. object Anagrammes extends App {
  4.  
  5.   def lettres(mot: String) = mot
  6.     .filter(_.isLetter)
  7.     . groupBy((a:Char)=>a)
  8.     .mapValues(_.length)
  9.    
  10.   def inf(x: Map[Char, Int], y: Map[Char, Int]): Boolean =
  11.     x.keys.forall( (a: Char) => x(a) <= y.getOrElse(a, 0))  
  12.      
  13.   def sub(x: Map[Char, Int], y: Map[Char, Int]): Map[Char, Int] =
  14.      x.map( {case (a: Char, n : Int) => (a, n - y.getOrElse(a, 0))})
  15.      .filter({case (a, n) => n > 0})
  16.    
  17.   def test1 = {
  18.     println(sub(lettres("aaabbc"), lettres("aaab")))
  19.     println(inf(lettres("aaabbc"), lettres("aaab")))
  20.     println(inf(lettres("aaabbc"), lettres("aaaabbbcccf")))
  21.   }
  22.  
  23.   lazy val lexique = {
  24.     val source = scala.io.Source.fromFile("liste.de.mots.francais.frgut.txt", "utf-8")
  25.     val lignes = source.getLines.toList
  26.     source.close()
  27.     print("création du lexique...")
  28.     val lexique = lignes.groupBy(lettres)
  29.     println(" OK --------------------------------------------------")
  30.     val (maxk, maxs) = lexique.maxBy({case (k,xs) => xs.length})
  31.     println("Le lexique contient :\n"
  32.           + lignes.size + " mots répartis en\n"
  33.           + lexique.size + " entrées\n"
  34.           + "La plus grande " + maxk + "\n"
  35.           + "contient " + maxs.length + " mots :\n"
  36.           + maxs)
  37.    println("----------------------------------------------------------------------------")
  38.     lexique
  39.   }
  40.  
  41.   def soluce1 = {
  42.     println(lexique.get(lettres("vélo")))
  43.   }
  44.  
  45.   def soluce2 = {
  46.     val cible = lettres("sommeil profond")
  47.     val lex = lexique.filterKeys(inf(_, cible))
  48.     println("fin du filtre")
  49.     def solutions = for {
  50.       bag1 <- lex.keys
  51.       bag2 = sub(cible, bag1)
  52.       if lex contains bag2    
  53.     } yield (bag1, bag2)
  54.    
  55.     println("affichage des phrases de deux mots")
  56.     for {
  57.       (bag1, bag2) <- solutions
  58.       mot1 <- lex(bag1)
  59.       mot2 <- lex(bag2)
  60.     } println(mot1 + " " + mot2)
  61.     println("fin")
  62.   }
  63.  
  64.  def soluce2stream = {
  65.     val cible = lettres("sommeil profond")
  66.     val lex = lexique.keys.toStream.filter(inf(_, cible))
  67.     println("fin du filtre")
  68.     def solutions = for {
  69.       bag1 <- lex
  70.       bag2 = sub(cible, bag1)
  71.       if lexique contains bag2    
  72.     } yield (bag1, bag2)
  73.      
  74.     println("affichage des phrases de deux mots")
  75.     for {
  76.       (bag1, bag2) <- solutions
  77.       n = bag1.values.sum
  78.       espaces = " " * (n - 1) + "|"
  79.       u = println("")
  80.       (mot1, mot2) <- lexique(bag1).zipAll(lexique(bag2), espaces, "|")
  81.     } println(mot1 + " " + mot2)
  82.   }
  83.  
  84.   def soluce3 = {
  85.     println("recherche des solutions en trois mots")
  86.     val cible = lettres("le scénario comique")
  87.     val lex = lexique.keys.filter(inf(_, cible))
  88.     val solutions = for {
  89.     bag1 <- lex
  90.     cible2 = sub(cible, bag1)
  91.     bag2 <- lex.filter(inf(_, cible2))
  92.     bag3 = sub(cible2, bag2)
  93.     if lexique contains bag3
  94.     } yield (bag1, bag2, bag3)
  95.        
  96.     println("affichage des phrases de trois mots")
  97.     for {
  98.       (bag1, bag2, bag3) <- solutions
  99.       mot1 <- lexique(bag1)
  100.       mot2 <- lexique(bag2)
  101.       mot3 <- lexique(bag3)
  102.     }  println(mot1 + " " + mot2 + " " + mot3)
  103.   }
  104.    
  105.   def soluce3stream = {
  106.     println("recherche des solutions en trois mots")
  107.     val cible = lettres("le scénario comique")
  108.     val lex = lexique.keys.toStream.filter(inf(_, cible))
  109.     val solutions = for {
  110.     bag1 <- lex
  111.     cible2 = sub(cible, bag1)
  112.     bag2 <- lex.filter(inf(_, cible2))
  113.     bag3 = sub(cible2, bag2)
  114.     if lexique contains bag3
  115.     } yield (bag1, bag2, bag3)
  116.    
  117.     println("affichage des phrases de trois mots")
  118.     for {
  119.       (bag1, bag2, bag3) <- solutions
  120.       espaces1 = " " * (bag1.values.sum - 1) + "|"  
  121.       espaces2 = " " * (bag2.values.sum - 1) + "|"
  122.       mots = lexique(bag1).zipAll(lexique(bag2)
  123.              .zipAll(lexique(bag3), espaces2, "|"), espaces1, ("",""))
  124.       u = println("")
  125.       (mot1, (mot2, mot3)) <- mots
  126.     }  println(mot1 + " " + mot2 + " " + mot3)
  127.   }
  128.  
  129.   //test1
  130.   //soluce1
  131.   soluce2stream
  132.   //soluce3stream
  133.   println("--------------")
  134. }

Télécharger

Recherche

Enseignement

Administration

Université Sorbonne Paris Nord Des services numériques pour étudier
Curriculum Vitæ [pdf]
Comment me contacter

Autres réalisations (logiciels, etc.)

Bluehats & UnivMobile , Présentation de la démarche design employée pour UnivMobile faite à la rencontre bluehats du 11 décembre 2019. [pdf, jpg]
Mon université en 2030, Texte d'une intervention que j'ai faite dans le cadre d'une soirée Cap 2030, organisée par le EdFab à Cap Digital le 27 février (...)
Thymio, Python et Asebamedulla
des QCM en ligne grâce à org-mode (et jQuery, et MathJax), org-mode [org, html, css]

Café

Expérience du désir
Enseigner la programmation
Revenu et logement, Je livre ici quelques éléments de comparaison concernant mon niveau de vie, pour couper court à quelques idées reçues, et un condensé de nombreuses (...)
Revenu et travail d’un enseignant-chercheur, Cet article complète l'article Revenu et logement, en détaillant un peu le budget de mon ménage, mon parcours d'enseignant-chercheur en terme de (...)
Paris 13 Villetaneuse, pas encore la vélorution !
Cybersyn (el systemo synco), Au café, mardi 5 avril 2011, j'ai bien vu que, mis à part Antoine Allombert, personne ne connaissait l'histoire de l'extraordinaire projet chilien (...) [jpg, jpg, png]

Divers

Affiche CiE 2016
Augmenter l’espace de stockage d’un hote GNU/Linux (VirtualBox etc.)
AperoTIC sur les réseaux sociaux
ADULLACT, Pour être un peu moins seul à défendre l'usage et le développement de logiciels libres dans mon travail (et autour), j'ai adhéré à l'ADULLACT en tant (...)
Hacker l’éducation (Open bidouille camp 2 // Fac lab de Gennevilliers)
Expo : et l’Homme… créa le robot
MathJax
Onglets dans un rapport $\LaTeX$ [gz, png, pdf, gz]
Logo LIPN et accessoires [svg, svg, png, tex, pdf, tif, zip, png, eps, svg]
Ventilo pour ibook (retrouvé) [jpg]