Scala рассчитывает символы в строковой логической ошибке

Давайте проанализируем вашу первоначальную попытку:

a.groupBy((c: Char) => a.count( (d:Char) => d == c))

Итак, вы группируете что-то, что есть что? результат a.count (...), поэтому ключ вашей Карты будет Int. Для char a мы получим 3 для символов b и c, мы получим 2.

Теперь исходная строка будет пройдена и для скопированных результатов char char.

Таким образом, после прохождения первого «ab» текущее состояние «2-> b, 3-> c». (Обратите внимание, что для каждого символа в строке вызывается .count (), который является нерациональным алгоритмом n², но в любом случае).

Строка проходит постепенно, а в конце накопленные результаты показано на рисунке. Как оказалось, 3 "a" были отправлены под клавишей «3», а b и c были отправлены на ключ «2» в порядке прохождения строки, что является порядком слева направо .

Теперь обычная groupBy в списке возвращает что-то вроде Map [T, List [T]], поэтому вы, возможно, ожидали List [Char]. Этого не происходит (потому что Repr для String - String), и ваш список символов эффективно рекомбибилизируется в String и предоставляется вам как таковой.

Следовательно, ваш конечный результат!

Напишите выражение, подобное

"abcabca".groupBy(identity).collect{
  case (k,v) => (k,v.length)
}

, которое даст результат как

res0: scala.collection.immutable.Map[Char,Int] = Map(b -> 2, a -> 3, c -> 2)

Заголовок вопроса читается как «Scala count chars в строковой логической ошибке». Но вы используете карту, и вы хотите считать как ключи. Равные клавиши не допускаются в объектах карты. Следовательно, равные ключи устраняются в полученной карте, сохраняя только одну, потому что не допускается дублирование ключей. То, что вы хотите, может быть Seq кортежей вроде (count, char), например List [Int, Char]. Попробуйте это.

 val x = "abcabca"
 x.groupBy(identity).mapValues(_.size).toList.map{case (x,y)=>(y,x)}

В Scal REPL:

scala> x.groupBy(identity).mapValues(_.size).toList.map{case (x,y)=>(y,x)}
res13: List[(Int, Char)] = List((2,b), (3,a), (2,c))

Вышеприведенный список содержит список и соответствующие символы в виде списка кортежей. Так вы действительно можете

Если вы попытаетесь преобразовать это в карту:

scala> x.groupBy(identity).mapValues(_.size).toList.map{case (x,y)=>(y,x)}.toMap
res14: scala.collection.immutable.Map[Int,Char] = Map(2 -> c, 3 -> a)

Так что это не то, что вы хотите явно.

Еще более сжато использовать:

x.distinct.map(v=>(x.filter(_==v).size,v))

scala> x.distinct.map(v=>(x.filter(_==v).size,v))
res19: scala.collection.immutable.IndexedSeq[(Int, Char)] = Vector((3,a), (2,b), (2,c))

Проблема с вашим подходом заключается в том, что вы сопоставляете количество символов с символами. Что есть: В случае

val str = abcabca

При перемещении строки str a имеет счет 3, b имеет счет 2, а c имеет счет 2 при создании карты (с использованием groupBy) он поместит все символы в значение, имеющее тот же самый ключ.

Map(3->aaa, 2->bc)

Именно по этой причине вы получаете такой вывод для своей программы.

Как вы можете видеть в определении функции groupBy:

def groupBy [K] (f: (A) ⇒ K): immutable.Map [K, Repr] Разделяет эту обходную коллекцию на карту пересекающихся коллекций в соответствии с некоторой дискриминаторной функцией. Примечание. Этот метод не переопределяется представлениями. Это означает, что при применении к виду он всегда будет заставлять представление и возвращать новую доступную коллекцию. K - тип ключей, возвращаемых функцией дискриминатора. f функция дискриминатора. возвращает карту из ключей в пересекающиеся коллекции, так что имеет место следующий инвариант: (xs groupBy f) (k) = xs filter (x => f (x) == k) То есть каждый ключ k связан с обходной коллекцией из тех элементов x, для которых f (x) равно k.

GroupBy возвращает карту, которая содержит следующий инвариант.

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Это означает, что он возвращает коллекцию элементов, для которых ключ такой же.