Character Frequency in a String [duplicate]

Question

Given a string of printable ASCII, output the frequency of each character in that string.

The Challenge

• Input is given as a string of printable ASCII characters (decimal [32-126] inclusive).
• Output the frequency of each character, in ASCII order.
• The output must have a format similar to [character][separator][count]. Provided that there is a single, non-newline separating string between the character and its frequency, it is a valid output.
• Output can be a single string, multiple strings, list of 2-tuples, array of tuples, etc.
• Input and output can be given using any convenient method.
• Standard loopholes are forbidden.
• This is code-golf, so shortest in bytes wins.

Sample I/O

abcd
//outputs
a: 1
b: 1
c: 1
d: 1

Over 9001!
//outputs
  [ 1
! [ 1
0 [ 2
1 [ 1
9 [ 1
O [ 1
e [ 1
r [ 1
v [ 1

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
//outputs (as 2-tuples)
(+,14),(-,13),(.,13),(<,21),(>,13),([,2),(],2)

Su3OH39IguWH
//outputs (as 2d array)
[[3,2],[9,1],[H,2],[I,1],[O,1],[S,1],[W,1],[g,1],[u,2]]

Answer 1

Python 3, 50, 43, 41 bytes

lambda s:{c:s.count(c)for c in sorted(s)}

Try it online!

Answer 2

Ohm v2, 2 bytes

SÖ

Try it online!

      implicit input
S     sort string
 Ö    run-length encoding
      implicitly print

Answer 3

Python 3, 41 bytes

lambda s:sorted({*zip(s,map(s.count,s))})

Try it online!

Answer 4

J, 13 bytes

({.;#)/.~@/:~

Try it online!

• @/:~ sort the input and...
• /.~ partition it into groups of like items. Apply the following to each group...
• ({.;#) take the first element {. and link it ; to the number of items in the group #

Answer 5

Brachylog, 2 bytes

ọo

Try it online!

ọ     Occurrences,
 o    sorted.

It's essentially the same as using an RLE builtin with the sorting requirement, but if the output could be in any order it would just be ọ.

Answer 6

APL (Dyalog Extended), 5 bytes^SBCS

Anonymous tacit prefix function, returning a two-column table, which by default prints with space as separator between character and count, and line break after each entry.

,∘≢⌸∧

Try it online!

, character followed

∘ by

≢ its tally

⌸ for each unique character

∧ in ascending order

Answer 7

Haskell, 52 49 bytes

-3 bytes thanks to cole!

import Data.List
map((,).nub<*>length).group.sort

Try it online!

I know this is too long (especially that import), but I'm new at Haskell golfing and hoping to get better! Outputs as a list of tuples of (character, count) (note the character is String, not a Char).

Answer 8

Perl 6, 15 bytes

*.comb.Bag.sort

Try it online!

Anonymous code block that takes a string and returns a list of pairs, where the key is the character and the value is the number of occurrences.

Explanation:

*.comb           # Decompose into characters
      .Bag       # Group into unordered bag of character => occurrences
          .sort  # Sort by character

Answer 9

CJam, 8 4 bytes

$e`p

Try it online!

-3 bytes thanks to Jonah, and -1 byte from rule interpretation.

A perfect challenge for CJam. I had hoped that the RLE encode operator would output [char, count], but the order was reversed. Otherwise it would have been a 5-byter. After Jonah's comment, I switched the order of the output. I'm not sure if the first read should be counted, since the standard rules permit input to be on the stack at the start of the program. If that's the case, this answer is one byte shorter. From this meta discussion, I concluded that the read could be placed in the header. Otherwise I could modify the script to be a function without changing the byte count.

Explanation

 $       sort string
  e`     RLE-encode (transforms "aabc" to [[2, "a"], [1, "b"], [1, "c"]]
    p    print

Open question: would something like this be allowed if transforming the answer to a function, or should the brackets be included in the byte count?

Answer 10

Pyth, 3 bytes

r8S

Try it online!

Simply run-length encodes (r8) the sorted (S) input. Output is a list of tuples of [frequency, character].

Answer 11

Jelly, 6 3 bytes

ṢŒr

Try it online!

A monadic link taking the string as its argument. Returns a list of lists, each one containing the character and count. The footer formats this as a grid.

Answer 12

Bash, ^{27 22} 20 bytes

fold -1|sort|uniq -c

Try it online!

-5 bytes thanks to Neil

-2 bytes thanks to Digital Trauma

Answer 13

PHP, 57 bytes

foreach(count_chars($argn,1)as$a=>$b)echo chr($a)," $b
";

Try it online!

Input via STDIN, run with php -F:

$ echo Su3OH39IguWH|php -F cc.php
3 2
9 1
H 2
I 1
O 1
S 1
W 1
g 1
u 2

Fun fact: this challenge is basically the Example 1 on the PHP docs for count_chars().

Answer 14

T-SQL 2008 query, 130 bytes

DECLARE @ varchar(2000)='kabcdda'

SELECT w,sum(1)FROM(SELECT
substring(@,number+1,1)FROM
spt_values WHERE type='P'and
number<len(@))x(w)GROUP BY w
ORDER BY ascii(w)

Try it online

Answer 15

C (gcc), 94 91 bytes

Thanks to Ourous and ceilingcat for their suggestions.

To get the non-newline separator, I'm making use of the fact that negative numbers get a "-" for free! :-)

f(char*s){char c[255]={},i=31;for(;*s;)c[*s++]--;for(;++i>0;)c[i]&&printf("%c%d ",i,c[i]);}

Try it online!

Answer 16

PowerShell, 27 22 21 19 bytes

$args[0]|sort|group

Try it online!

Exactly what it says on the tin. Takes input $args[0] via splatting (manifests on TIO as a [char[]]), sorts it, then group-object it into a grouping.

-8 bytes thanks to mazzy

Answer 17

JavaScript, 58 bytes

s=>[...s].sort().flatMap(c=>c>p?[p=[c,1]]:p[1]++&&[],p=[])

Try it online!

Thanks Shaggy, -1 byte.

---

Retina, 18 bytes

O`.
(.)\1*
$1,$.&¶

Try it online!

I don't speak Retina. I just translated above JavaScript answer to Retina with some searching.

Thanks to Cows quack, -3 bytes.

Answer 18

Wolfram Language (Mathematica), 34 bytes

KeySortBy[ToCharacterCode]@*Counts

Try it online!

Returns an association.

---

SortBy[ToCharacterCode@@#&]@*Tally

Try it online!

Returns a list.

Answer 19

C# (Visual C# Interactive Compiler), 63 61 bytes

s=>s.OrderBy(c=>c).GroupBy(c=>c).Select(g=>(g.Key,g.Count()))

Try it online!

Thanks to Expired Data for pointing me towards the C# Interactive Compiler and for showing me the power of dynamics.

Answer 20

K4, 9 bytes

Solution:

#:'=x@<x:

Example:

q)k)#:'=x@<x:"Over 9001!"
 | 1
!| 1
0| 2
1| 1
9| 1
O| 1
e| 1
r| 1
v| 1

Explanation:

#:'=x@<x: / the solution
       x: / store input as x
      <   / indices to sort ascending
    x@    / apply (@) to x
   =      / group same values
#:'       / count (#:) each (')

Answer 21

APL(NARS), 26 chars, 52 bytes

{m,¨+/¨{w=⍵}¨m←k[⍋k←∪w←⍵]}

test:

  ⎕fmt{m,¨+/¨{w=⍵}¨m←k[⍋k←∪w←⍵]}'is, this good or not?'
┌12─────────────────────────────────────────────────────────────────────────────────┐
│┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐│
││   4│ │ , 1│ │ ? 1│ │ d 1│ │ g 1│ │ h 1│ │ i 2│ │ n 1│ │ o 4│ │ r 1│ │ s 2│ │ t 2││
│└+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘ └+───┘2
└∊──────────────────────────────────────────────────────────────────────────────────┘

  {m,¨+/¨{w=⍵}¨m←k[⍋k←∪w←⍵]}
                     k←∪w←⍵     copy the argument in w, k is the argument that has unique elements
               m←k[⍋       ]    copy k order, in m, (so m is argument unique ordered)
         {w=⍵}¨m                see each element of m in w, so each element of m generate a len(w) bit list 
      +/¨                       sum each bit list above obtain the number of element of m in w
   m,¨                          make couples

Answer 22

brainfuck, 128 114 bytes

->>,[[-[>>+<<-]>>]>+<+[-<<+]->>,]+[+>[<--.++<<+++++++[>++++++++<-]>++.[-]++++++[>>++++++++<<-]>>.[-].]<[>>+<<-]>>]

Try it online!

How it works:

-                                          sets cell 0 to 255, which is used to move back to cell 2 later on
>>                                         moves to cell 2
,[                                         we load our first input and loop until there are no more characters to load
[-[>>+<<-]>>]                              keeps moving forward skipping every other cell until it has moved forward the ASCII value of the most recently loaded character  
>+<                                        adds one to the next cell for the purpose of later looking at to see how many of that character was entered
+[-<<+]->>                                 goes back to cell 2
,]                                         loads in next character and repeats process if there are remaining characters

+[+>[                                      checks IF the next cell has a value other than 0
<--.                                       then, if true, it prints the ASCII value of the previous cells contents
++<<+++++++[>++++++++<-]>++.               then print ":"
[-]++++++[>>++++++++<<-]>>.                then print the number value of the contents of the current cell
[-].]                                      then print a null character and leaves the if statement
<[>>+<<-]>>]                               continues the same process skipping every other cell, until it repeats 255 times

Thanks to Jo King, -14 bytes.

This is my second brainfuck program, first being hello world, and first time golfing, so please let me know what I can do to improve my program and answer!

Answer 23

Clean, 60 bytes

import StdEnv
$s=sort[(c,sum[1\\k<-s|k==c])\\c<-removeDup s]

Try it online!

Defines the function $ :: [Char] -> [(Char, Int)] giving the result as a list of 2-Tuples.
Uses the element-wise behavior of < and thus sort on Tuples to ensure codepoint ordering.

Answer 24

Charcoal, 13 bytes

ＥΦγ№θι⁺⁺ι №θι

Try it online! Link is to verbose version of code. Explanation:

  γ             Printable ASCII
 Φ              Filtered where non-zero
   №            Count of
     ι          Current character in
    θ           Input string
Ｅ               Map over filtered characters
        ι       Current character
       ⁺        Plus a space
      ⁺         Plus
          №     Count of
            ι   Current character in
           θ    Input string
                Implicitly output on separate lines

Answer 25

JavaScript, 57 bytes

Outputs a 2D-Array. Had to implement a quick & dirty fix for the sorting so I'll need to come back to try to golf that.

s=>[...s].map(o=x=>o[x]=-~o[x])&&Object.entries(o).sort()

Try It Online!

Answer 26

Kotlin, 75 bytes

fun String.c()=toCharArray().sorted().map{Pair(it,count{s->it==s})}.toSet()

Try it online!

Answer 27

Japt, 7 bytes

¬ü ®âZl

Test it online!

Answer 28

Haskell, 46 bytes

f x=[(c,sum[1|d<-x,d==c])|c<-[' '..],elem c x]

Try it online!

Answer 29

Ruby -n, 43 bytes

p$_.chars.uniq.sort.map{|c|[c,$_.count(c)]}

Try it online!

Answer 30

sfk, 124 87 84 bytes

xed -i
+chars
+count -same -case
+xed "_?????*x*[white]?_[parts 6,3,1]_"
+sort -case

Try it online!

Gives output in the form [character]x[count] with count padded to 5 digits.