La génération d'une fréquence de la carte pour une chaîne en Scala

1) Qu'est - p veux dire?

groupBy prend une fonction qui associe à un des éléments clés de type K. Lorsqu'elle est appelée sur un certain prélèvement Coll, il renvoie une Map[K, Coll] qui contient les mappages de touches K à tous les éléments qui mappé sur la même touche.

Donc, dans votre cas, str.groupBy(_.toChar) donne une carte de la cartographie à partir d'une clé k (qui est un caractère) à une chaîne avec tous les éléments (personnages) c tels que k == c.toChar.
Vous obtenez ceci:

Map(e -> "e", h -> "h", l -> "ll", o -> "o")

Un Map est un objet iterable de paires de clés et de valeurs. Dans ce cas, chaque paire est un personnage et une chaîne d'éléments. L'appel de la map opération sur un Map implique de cartographie sur ces paires, p est une paire dont p._1 est un personnage, et p._2 est la chaîne associée (sur lequel vous pouvez appeler length, comme vous l'avez fait ci-dessus).

2) Comment faire idiomatique

Ci-dessus est de savoir comment le faire idiomatique - à l'aide de groupBy et map. Alternativement, vous pouvez utiliser un immuable la carte et la récursivité sur la longueur de la chaîne pour calculer les fréquences, ou immuable carte et une foldLeft.

3) des caractéristiques de Performance

Mieux pour référence pour voir les différences.
Voici un couple de microbenchmark pour un très répétitif chaîne (~3GHz iMac, JDK7, Scala 2.10.0 tous les soirs):

object Imperative extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    var counts = new scala.collection.mutable.HashMap[Char,Int]
    var i = 0
    val until = str.length
    while (i < until) {
      var c = str(i)
      if (counts.contains(c))
        counts.put(c, counts(c) + 1)
      else
        counts.put(c, 1)
      i += 1
    }

    //println(f)
  }
}


object Combinators extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    val f = str.groupBy(_.toChar).map(p => (p._1, p._2.length))
  }
}


object Fold extends testing.Benchmark {
  val str = "abc" * 750000

  def run() {
    val f = str.foldLeft(Map[Char, Int]() withDefaultValue 0){(h, c) => h.updated(c, h(c)+1)}
  }
}

Résultats:

• Impératif: $ 103 57 53 58 53 53 53 53 53 53

• Combinators: $ 72 51 63 56 53 52 52 54 53 53

• Fois: $ 163 62 71 62 57 57 57 58 57 57

Notez que la modification de l'impératif de la version à utiliser withDefaultValue:

var counts = new scala.collection.mutable.HashMap[Char,Int].withDefaultValue(0)
var i = 0
val until = str.length
while (i < until) {
  var c = str(i)
  counts.put(c, counts(c) + 1)
  i += 1
}

apparemment, est terriblement lent en raison de la redirection de chaque put appel:

• withDefaultValue: $ 133 87 109 106 101 100 101 100 101 101

Conclusion: le boxing et unboxing de caractères dans ce cas est suffisante, de sorte que les différences de performance entre ces approches sont difficiles à observer.

EDIT:

Mise à jour: Vous pouvez utiliser ScalaMeter inline benchmarking en place de la Benchmark trait.

Votre exemple sur ruby peut être presque directement traduit à la Scala à l'aide de foldLeft et immuable Map.

Ici est l'une des solutions possibles:

str.foldLeft(Map[Char, Int]() withDefaultValue 0){(h, c) => h.updated(c, h(c)+1)}

En fait, si vous êtes ok avec local de la mutabilité, vous pouvez faire quelque chose comme ceci:

def charFrequencies(str: String): collection.Map[Char, Int] = {
  val hash = collection.mutable.HashMap.empty[Char, Int] withDefaultValue 0
  str foreach { hash(_) += 1 }
  hash
}

Expression hash(_) += 1 sera délactosé à c => hash(c) = hash(c) + 1 puis à c => hash.update(c, hash.apply(c) + 1)

Cette solution devrait être plus efficace que fonctionnelle, car il ne créez pas d'intermédiaire collections. Aussi parce que la méthode retourne immuable collection.Map[Char, Int], le résultat sera traitée comme immuable (tant que personne ne sera à effectuer dangereux de passer sur elle).