blocks|key|260572|text|可能有一些更短的东西，但这是有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|260573|Prelude>+import+Data.List
Prelude+Data.List>+map+(\x+->+(head+x,+length+x))+$+group+$+sort+"happy"
[('h',1),('a',1),('p',2),('y',1)]|code-block|syntax|javascript|260574|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There's probably something shorter, but this works:

<pre><code>Prelude&gt; import Data.List
Prelude Data.List&gt; map (\x -&gt; (head x, length x)) $ group $ sort "happy"
[('h',1),('a',1),('p',2),('y',1)]
</code></pre>

blocks|key|3158480|text|最简单的解决方案是使用Data.Map来存储从字符到频率的中间映射。然后，您可以使用fromListWith轻松地构造计数。由于Data.Map是经过排序的，因此您可以免费获得按ASCII码排序的它们。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3158481|λ>+:m+%2B+Data.Map
λ>+let+input+=+"happy"
λ>+toList+$+fromListWith+(%2B)+[(c,+1)+%7C+c+<-+input]
[('a',1),('h',1),('p',2),('y',1)]|code-block|syntax|javascript|3158482|3158483|那么这里发生了什么呢？|3158484|其思想是使用字符作为关键字，使用频率作为值来构建Data.Map+(树形映射)。|3158485|首先，我们获取输入字符串，并使用1为每个字符创建元组，以指示一个匹配项。|3158486|λ>+[(c,+1)+%7C+c+<-+input]
[('h',1),('a',1),('p',1),('p',1),('y',1)]|3158487|接下来，我们使用fromListWith通过重复地将每个键-值对插入到映射中来从这些键-值对构建排序映射。我们还为它提供了一个函数，当一个键已经存在于映射中时将使用该函数。在我们的例子中，我们使用(%2B)，这样当一个字符多次出现时，我们将计数与现有的和相加。|3158488|最后，我们使用toList将映射转换回一个键-值元组列表。|3158489|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/containers/docs/Data-Map.html|1|http://hackage.haskell.org/package/containers/docs/Data-Map-Lazy.html#v:fromListWith^0|B|8|16|C|1S|8|B|8|0|16|C|1|0|0|0|0|O|8|0|G|1|0|0|8|C|2Q|3|0|7|6|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@$9|1E|A|1F|1|1G]|$9|1H|A|1I|1|1J]]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1M|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|R|3|S|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|Y|$Z|$5|10|11|12|E|$13|14]]|15|$5|10|11|12|E|$13|16]]]]

The simplest solution is to use a <a href="http://hackage.haskell.org/package/containers/docs/Data-Map.html" rel="noreferrer"><code>Data.Map</code></a> to store the intermediate mapping from character to frequency. You can then construct the counts easily using <a href="http://hackage.haskell.org/package/containers/docs/Data-Map-Lazy.html#v:fromListWith" rel="noreferrer"><code>fromListWith</code></a>. Since <code>Data.Map</code> is sorted, you get them in ASCII order for free.

<pre><code>λ&gt; :m + Data.Map
λ&gt; let input = "happy"
λ&gt; toList $ fromListWith (+) [(c, 1) | c &lt;- input]
[('a',1),('h',1),('p',2),('y',1)]
</code></pre>

<hr>

So what's happening here?

The idea is to build a <code>Data.Map</code> (a tree map) using the characters as keys and the frequencies as values.

First, we take the input string and make tuples of each character with a <code>1</code> to indicate one occurrence.

<pre><code>λ&gt; [(c, 1) | c &lt;- input]
[('h',1),('a',1),('p',1),('p',1),('y',1)]
</code></pre>

Next, we use <code>fromListWith</code> to build a sorted map from these key-value pairs by repeatedly inserting each key-value pair into a map. We also give it a function which will be used when a key was already in the map. In our case, we use <code>(+)</code> so that when a character is seen multiple times, we add the count to the existing sum.

Finally we covert the map back into a list of key-value tuples using <code>toList</code>.

blocks|key|2944440|text|func+xs+=+map+(\a+->+(head+a,+length+a))+$+group+$+sort+xs|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2944441|entityMap^0|0|1M|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>func xs = map (\a -&gt; (head a, length a)) $ group $ sort xs</code>

blocks|key|3158520|text|我将一步一步地寻找解决方案。使用标准函数可以获得更短的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3158521|您需要一个排序的结果，因此|3158522|result+=+sort+cs
++++where|code-block|syntax|javascript|3158523|cs是一个元组列表，其中第一个元素是字符，第二个元素是它出现的次数。|3158524|++++++++cs+=+counts+"happy"
++++++++counts+[]+=+[]
++++++++counts+(c:cs)+=+(c,+length+otherc+%2B+1)+:+counts+nonc+where
+++++++++++++(otherc,+nonc)+=+partition+(c==)+cs|3158525|就这样。|3158526|有趣的是，counts适用于任何支持==运算符的项目列表。|3158527|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I'll scetch a solution step by step. A shorter solution is possible using standard functions.

You want a sorted result, therefore

<pre><code>result = sort cs
 where
</code></pre>

cs would be a list of tuples, where the first element is the character and the second element is the number of times it appears.

<pre><code> cs = counts "happy"
 counts [] = []
 counts (c:cs) = (c, length otherc + 1) : counts nonc where
 (otherc, nonc) = partition (c==) cs
</code></pre>

That's all.

Interestingly, counts works on any list of items that support the == operator.

blocks|key|3158568|text|import+Data.Array+(Ix,+accumArray,+assocs)

eltDist+::+(Bounded+a,+Ix+a,+Eq+b,+Num+b)+=>+[a]+->+[(a,+b)]
eltDist+str+=+filter+((/=0)+.+snd+)+$+
+++++assocs+(accumArray+(%2B)+0+(minBound,+maxBound)+[(i,+1)+%7C+i+<-+str])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3158569|"minBound“和"maxBound”将取决于为i推断的类型范围。对于Char，它将是0-+1,114,111，这是奢侈的，但不是不可能的。如果您正在计算Unicode字符，这将特别方便。如果你只对ASCII字符串感兴趣，那么(0,255)就可以了。数组的一个优点是，它们可以通过任何可以映射到整数的类型进行索引。请参阅Ix。|unstyled|offset|length|style|BOLD|3158570|assocs将索引和计数从数组中拉出到一个对列表中，并过滤掉未使用的对。|3158571|entityMap^0|0|11|4|4I|2|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]|$G|S|H|T|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>import Data.Array (Ix, accumArray, assocs)

eltDist :: (Bounded a, Ix a, Eq b, Num b) =&gt; [a] -&gt; [(a, b)]
eltDist str = filter ((/=0) . snd ) $ 
 assocs (accumArray (+) 0 (minBound, maxBound) [(i, 1) | i &lt;- str])
</code></pre>

"minBound" and "maxBound" are going to depend on the range of the type inferred for i. For Char it will be 0 - 1,114,111, which is extravagant but not impossible. It would be especially convenient if you were counting Unicode chars. If you are only interested in ASCII strings, then (0, 255) would do. A nice thing about arrays is that they can be indexed by any type that can be mapped to an integer. See Ix.

assocs pulls the indices and counts out of the array into a list of pairs and filter disposes of the unused ones.

blocks|key|259541|text|使用列表理解，不需要任何导入或排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|259542|[+(x,c)+%7C+x<-['A'..'z'],+let+c+=+(length.filter+(==x))+"happy",+c>0+]|code-block|syntax|javascript|259543|结果：|259544|[('a',1),('h',1),('p',2),('y',1)]|259545|上面是过滤和重写的(只有count+>0的字符)：|259546|[(x,(length.filter+(==x))+"happy"+)+%7C+x<-['A'..'z']]|259547|解释：|259548|259549|列出与给定字符(A..z)匹配的所有字符。|unordered-list-item|259550|对于每个字符，计算此列表(==length)的数量|259551|将此计数放入包含character|259552|的元组中|259553|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|T|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|T|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Use list comprehension, no need for any imports or sorting.

<pre><code>[ (x,c) | x&lt;-['A'..'z'], let c = (length.filter (==x)) "happy", c&gt;0 ]
</code></pre>

Result:

<pre><code>[('a',1),('h',1),('p',2),('y',1)]
</code></pre>

Above is the filtered and rewritten (only character with count > 0) from:

<pre><code>[(x,(length.filter (==x)) "happy" ) | x&lt;-['A'..'z']]
</code></pre>

Explanation:

<ul>
<li>Make a list of all characters that match a given character (A..z).</li>
<li>For each character, count this list (==length)</li>
<li>Put this count in a tuple with the character</li>
</ul>

blocks|key|259555|text|//Count+the+frequency+of+character+in+a+string+

package+waytocreateobject;
import+java.util.Scanner;
public+class+Freqchara+{

++++public+static+void+main(String[]+args)+{

++++++++int+c+=+0,+x+=+0,+loop+=+26,+space+=+0;
++++++++int+count[]+=+new+int[loop];
++++++++//Arrays.fill(count,+x);
++++++++Scanner+sc+=+new+Scanner(System.in);
++++++++String+str+=sc.nextLine();
++++++++char[]+charr+=+str.toCharArray();
++++++++int+aa+=+str.length();
++++++++//System.out.println(str.charAt(10));
++++++++//System.out.println(str.charAt(11));
++++++++for+(int+mm+=+0;+mm+<+aa;+mm%2B%2B)+{
++++++++++++if+(str.charAt(c)+!=+'\0')+{++++//Considering+characters+from+'a'+to+'z'+only+and+ignoring+others.
++++++++++++++++if+((str.charAt(c)+>=+'a')+&&+(str.charAt(c)+<=+'z'))+{
++++++++++++++++++++x+=+(int)+str.charAt(c)+-+(int)+'a';
++++++++++++++++++++//+System.out.println(x);
++++++++++++++++++++count[x]+=+count[x]+%2B+1;
++++++++++++++++}
++++++++++++++++c%2B%2B;
++++++++++++}+else+{}
++++++++}

++++++++//+printing+all+the+charcter
++++++++int+i+=+97;
++++++++for+(int+j+=+0;+j+<+loop;+j%2B%2B)+{
++++++++++++char+ch+=+(char)+(i+%2B+j);
++++++++++++System.out.println(ch+%2B+"++occurs++"+%2B+count[j]+%2B+"+times+in+the+string");
++++++++}
++++++++System.out.println("++occurs+"+%2B+space);
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|259556|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>//Count the frequency of character in a string 

package waytocreateobject;
import java.util.Scanner;
public class Freqchara {

 public static void main(String[] args) {

 int c = 0, x = 0, loop = 26, space = 0;
 int count[] = new int[loop];
 //Arrays.fill(count, x);
 Scanner sc = new Scanner(System.in);
 String str =sc.nextLine();
 char[] charr = str.toCharArray();
 int aa = str.length();
 //System.out.println(str.charAt(10));
 //System.out.println(str.charAt(11));
 for (int mm = 0; mm &lt; aa; mm++) {
 if (str.charAt(c) != '\0') { //Considering characters from 'a' to 'z' only and ignoring others.
 if ((str.charAt(c) &gt;= 'a') &amp;&amp; (str.charAt(c) &lt;= 'z')) {
 x = (int) str.charAt(c) - (int) 'a';
 // System.out.println(x);
 count[x] = count[x] + 1;
 }
 c++;
 } else {}
 }

 // printing all the charcter
 int i = 97;
 for (int j = 0; j &lt; loop; j++) {
 char ch = (char) (i + j);
 System.out.println(ch + " occurs " + count[j] + " times in the string");
 }
 System.out.println(" occurs " + space);
 }
}
</code></pre>

How can I count the frequency of characters in a string and then output them in sort of a table?

For example, if I input the word "happy" the result would be 

<pre><code>h 1 
a 1 
p 2 
y 1 
</code></pre>

If this could be ordered in ASCII order too that would be brilliant.

I know I need to use the count function, any other hints would be appreciated. 

EDIT: All the answers are brilliant, only I'm such a beginner at Haskell that I don't actually understand what they are doing.

How to find the frequency of characters in a string in Haskell?

我如何计算字符串中字符的频率，然后将它们输出到一个表中？例如，如果我输入单词"happy“，结果将是h 1  a 1  p 2  y 1  如果这也可以按ASCII顺序订购，那就太棒了。我知道我需要使用count函数，任何其他提示都将不胜感激。编辑：所有的答案都很精彩，只是我在Haskell还是个初学者，实际上我不知道...

问如何在Haskell中找到字符串中字符的频率？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Haskell中找到字符串中字符的频率？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Haskell中找到字符串中字符的频率？
EN