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

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 (...)
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]