Counting Letters in a String

Question

Write a program or function that takes in a string and outputs a count of each modern English alphabet letter in the string, case-insensitive.

Input: A string consisting of printable ASCII characters (code points 32-126).

Output: A list of pairs, where each pair consists of a letter and its count in the string. The list should be sorted in alphabetical order by letter. The list shall omit letters occurring zero times.

Test Cases

Input: "hello world"
Output: [('d', 1), ('e', 1), ('h', 1), ('l', 3), ('o', 2), ('r', 1), ('w', 1)]

Input: "The quick brown fox jumps over the lazy dog"
Output: [('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 3), ('f', 1), ('g', 1), ('h', 2), ('i', 1), ('j', 1), ('k', 1), ('l', 1), ('m', 1), ('n', 1), ('o', 4), ('p', 1), ('q', 1), ('r', 2), ('s', 1), ('t', 2), ('u', 2), ('v', 1), ('w', 1), ('x', 1), ('y', 1), ('z', 1)]

Code Golf Specifics:

Your goal is to write the shortest possible code in bytes that correctly solves the problem. Your code must be able to handle any valid input within the given constraints. Note that your code should treat uppercase and lowercase letters as equivalent.

Good luck!

Answer 1

Python, 60 bytes

lambda s:{c:s.lower().count(c)for c in s.lower()if'`'<c<'{'}

Attempt This Online!

Returns a dictionary. Suggested by @JonathanAllan.

Python, 70 bytes

lambda s:sorted((c,s.lower().count(c))for c in{*s.lower()}if'`'<c<'{')

Attempt This Online!

Returns a sorted list of tuples.

Python, 75 bytes

lambda s:sorted({*zip(x:=[*filter(str.isalpha,s.lower())],map(x.count,x))})

Attempt This Online!

Returns a sorted list of tuples.

Commented

lambda s: sorted(          # Define an anonymous function which takes a string, s,
                           # and returns a sorted version of the following:
  (c, s.lower().count(c))  #  a tuple of the character, c, and its count
                           #  in the lowercase version of s
  for c in {*s.lower()}    #  for each character, c, in the lowercase version of s uniquified
  if '`' < c < '{' )       #  but only keep it if it is between the characters
                           #  '`' (right before 'a') and '{' (right after 'z')
                           #  i.e., it's alphabetic

lambda s: sorted(          # Define an anonymous function which takes a string, s,
                           # and returns a sorted version of the following:
  {*zip(                   #  a uniquified version of two iterables zipped together:
    x := [*filter(         #   filter by
      str.isalpha,         #   is the character in the alphabet
      s.lower()            #   apply to a lowercase version of s
    )],                    #   and store in x
    map(x.count, x) )})    #   the counts of each character in x

Answer 2

Vyxal, 4 bytes

ǍɽĊs

Try it Online!

How it works:

ǍɽĊs
Ǎɽ    Remove non-alphabetical chars and lowercase
  Ċ   Count of each element
   s  Sorted 

Answer 3

jq, 66 bytes

ascii_downcase|reduce match("[a-z]";"g").string as $c({};.[$c]+=1)

Try it online!

reduce is just too good.

Answer 4

Java (JDK), 151 142 135 bytes

s->{var m=new java.util.TreeMap();for(var c:s.replaceAll("[^a-zA-Z]","").toCharArray())m.merge(c|=32,1,(a,b)->(int)a+(int)b);return m;}

Try it online!

Saved 15 bytes thanks to Kevin Cruijssen.

Answer 5

Perl 5 -n, 37 bytes

for$l(a..z){/$l/i&&say"$l ".s/$l//gi}

Try it online!

Answer 6

Excel, 85 82 bytes

^{Saved 3 bytes thanks to JvdV}

=LET(c,CHAR(ROW(65:90)),q,LEN(A1)-LEN(SUBSTITUTE(UPPER(A1),c,)),FILTER(c&"="&q,q))

The LET() function allows you to assign variables to values and reference them by name later. Every term is a pair except the last which is the output.

• c,CHAR(ROW(65:90)) creates an array of the strings A through Z.
• q,LEN(a)-LEN(SUBSTITUTE(UPPER(a),c,)) creates an array of how many times each letter appears by measuring the length of the input vs. the length if we replace that letter with nothing. SUBSTITUTE() is case-sensitive so we transform the input to uppercase.
• FILTER(c&"="&q,q) combines the array of letters with the count of each character and then filter for just those where the count (q) was truthy (anything not zero).

Answer 7

PowerShell Core, 62 bytes

$args-match'[a-z]'|%{"$_"|% *l*r}|group|%{,($_.Name,$_.Count)}

Try it online!

$args-match'[a-z]'        # For each character argument, exclude non letters characters
|%{"$_"|% *l*r}           # Converts to lowercase
|group                    # Groups them
|%{,($_.Name,$_.Count)}   # build pairs of letters and counts

Answer 8

C (gcc), 97 94 87 bytes

• -3 thanks to Unrelated String
• -7 thanks to c--

Uses uppercase as the challenge only states case-insensitive.

f(char*s){for(int a[96]={},i=64;i<90;)*s?a[*s++&95]++:a[++i]&&printf("%c:%d ",i,a[i]);}

Try it online!

Ungolfed:

f(char*s){
  for(int a[96]={},i=64;
      i<90;) // for all characters in string, then from 'A' to 'Z':
    *s? // done processing string?
      a[*s++&95]++: // no, uppercase letter and increment count
      a[++i]&&printf("%c:%d ",i,a[i]); // yes, print counts
}

Answer 9

Pascal (FPC), 185 ... 134 bytes

var c,d:char;s:string;i:word;begin;read(s);for c:=^to^do begin;i:=0;for d in upcase(s)do i+=ord(c=d);if i>0then writeln(c,i)end;end.

Try it online! (134b, courtesy of @michael-tkach)

 _{150b  155b  160b  161b  162b  185b}

Iterates over the alphabet and the input string s, comparing chars d and c. The for <char> in <string> syntax was handy. Implemented some of the Pascal golfing tips.

Answer 10

JavaScript, 68 bytes

s=>s.toLowerCase(m={}).match(/[a-z]/g).sort().map(l=>m[l]=-~m[l])&&m

Try it:

f=s=>s.toLowerCase(m={}).match(/[a-z]/g).sort().map(l=>m[l]=-~m[l])&&m

;[
  'hello world',
  'The tuick brown fox jumps over the lazy dog'
].forEach(s=>console.log(f(s)))

UPD 73 -> 68

Thanks to Shaggy for the tips (one, two) to reduce bytes count

Answer 11

05AB1E, 9 6 bytes

álТøê

Try it online!

Input as a list of characters.

Alternative 6 bytes answer with input as a string: (suggested by @KevinCruijssen)

ál{Åγø

Try it online!

-3 thanks to @KevinCruijssen

Explanation

á       # Filter for alphabetic characters only
 lÐ     # Convert to lowercase and triplicate
   ¢    # Count the occurences of each character
    øê  # Zip, sort, and uniquify

á       # Filter for alphabetic characters only
 l{     # Convert to lowercase and sort
   Åγ   # Run-length encode the string
     ø  # Zip

Answer 12

Ruby, 48 bytes

->s{[*s.upcase.chars.tally.slice(*?A..?Z).sort]}

Attempt This Online!

Answer 13

Retina 0.8.2, 38 29 bytes

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

Try it online! Output includes trailing newlines. Saved 9 bytes thank to @FryAmTheEggman. Explanation:

T`Llp`ll_

Convert letters to lower case and delete all other printable ASCII.

O`.

Sort the characters.

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

Output the count of each letter.

Previous 38-byte version worked with any input, not just printable ASCII:

T`L`l
O`.
M!`([a-z])\1*
(.)\1*
$1, $.&

Try it online! Explanation:

T`L`l

Lowercase the input string.

O`.

Sort the characters.

M!`([a-z])\1*

Extract the runs of identical letters.

(.)\1*
$1, $.&

Output the count of each letter.

31 30 bytes in Retina 1:

.
$L
O`.
L$`([a-z])\1*
$1, $.&

Try it online! Explanation:

.
$L

Lowercase the input.

O`.

Sort the characters.

L$`([a-z])\1*

For each run of identical letters...

$1, $.&

... output the count of each letter.

Answer 14

Pip, 21 23 bytes

YSSLCaFiUQy@XL;Pi.(iNy)

How?

YSSLCaFiUQy@XL;Pi.(iNy)  : One arg; str
     a                   : First input
   LC                    : To lowercase
 SS                      : Sort
Y                        : Yank
      Fi                 : For i in
        UQy              : Unique values of y
           @XL           : Only lowercase alphabet characters
               P           : Print
                i          : Letter
                 .         : Concatenated with
                   iN      : Letter in
                     y     : Input

Try It Online!

Answer 15

Mathematica (Wolfram Language), 34 bytes

KeySort@*LetterCounts@*ToLowerCase

TIO.run is in the comments below. Edited to save 4 bytes thanks to a suggestion from ZaMoC.

Answer 16

Arturo, 34 bytes

$=>[match lower&{/\pL}|tally|sort]

Try it

Answer 17

Charcoal, 15 bytes

⭆¹ΦＥβ⟦λ№↧θλ⟧§λ¹

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

    β           Predefined variable lowercase alphabet
   Ｅ            Map over letters
      λ         Current letter
     ⟦     ⟧    Make into tuple with
       №        Count of
          λ     Current letter in
         θ      Input string
        ↧       Lowercased
  Φ             Filtered where
            §λ¹ Count was nonzero
⭆¹              Pretty-print

Answer 18

J9.4, 35 bytes

'\pL'(~.,:<@#/.~)@/:~@rxall tolower

J903, 37 bytes

'[a-z]'(~.,:<@#/.~)@/:~@rxall tolower

Attempt This Online!

Explanation is the same, but the PCRE engine was updated which makes the regex 2 bytes shorter.

'\pL'(~.,:<@#/.~)@/:~@rxall tolower
                            tolower  NB. lowercase the input
'\pL'                 rxall          NB. match every letter
                  /:~@               NB. then sort
     (          )@                   NB. then invoke a monadic fork
            #/.~                     NB. count the occurrences of each letter
          <@                         NB. then box each result
      ~.                             NB. uniquify the matches
        ,:                           NB. stack matches on top of counts

Answer 19

Thunno, \$18\log_{256}(96)\approx\$ 14.82 bytes

UgAzsAqkztcsZZZUz:

Attempt This Online!

Explanation

U           # Lowercase
 gAzsAqk    # Alphabetic characters only
        zt  # Triplicate
cs          # Counts of each
  ZZ        # Zip
    ZU      # Uniquify
      z:    # Sort

Answer 20

JavaScript (ES6), 82 bytes

Probably takes a list of pairs a bit too literally... ¯\_(ツ)_/¯

s=>[...s.toLowerCase()].sort().join``.match(/([a-z])\1*/g).map(s=>[s[0],s.length])

Try it online!

Answer 21

J, 32 bytes

(u:97+i.26)(e.#[;"+1#.=/)tolower

Attempt This Online!

u:97+i.26 A character vector of all lowercase letters.
tolower Input converted to lowercase.
(u:97+i.26)(...)tolower Apply inner function with lowercase alphabet as left argument and lowercased string as right argument.
=/ Equality table.
1#. Sum each row. This gives a vector of length 26 with the count of each letter in the input.
[;"+ Pair up each letter with its count.
e.# Only keep the pairs where the letter is an element of the input.

Answer 22

Jelly, 8 bytes

ŒlḟŒuṢŒr

Try it online!

At least slightly less boring than if I'd used Øa. Feels ever so vaguely beatable, still...

Œl          The lowercased input,
  ḟŒu       with elements of the uppercased input filtered out.
     ṢŒr    Sort and run-length encode.

Answer 23

Japt v2.0a0, 15 13 bytes

v r\L ü ËÎ+DÊ

Try it

-2 by Shaggy

Outputs a list of “ab” strings where a is the character and b is the number of occurrences

Japt, 7 bytes

ü ËÎ+DÊ

Try it

Doesn’t remove non-letters

Made on My iPhone

ü ËÎ+DÊ # input string
ü       # list of same characters grouped together
  Ë     # map each string of same char to:
   Î    #   the character
    +DÊ #   append length of group

Answer 24

Common Lisp, 110 bytes

(lambda(s)(reduce(lambda(s c &aux(e(assoc c s)))(if e(prog1 s(incf(cdr e)))(acons c 1 s)))s :initial-value()))

The ungolfed version is:

(defun frequencies (string)
  (reduce (lambda (map char)
            (let ((entry (assoc char map)))
              (if entry
                  (prog1 map
                    (incf (cdr entry)))
                  (acons char 1 map))))
          string
          :initial-value nil))

For example:

> (frequencies "abcbad")
((#\d . 1) (#\c . 1) (#\b . 2) (#\a . 2))

Answer 25

Pascal, 590 358 bytes

This full program requires a processor supporting features of ISO standard 10206 “Extended Pascal”. Furthermore,

• the implementation-dependent behavior of the selection order in a for … in set member iteration statement must be ascending,
• the implementation-defined default TotalWidth for integer-type write arguments must be sufficiently large in order to leave some space between a character and the number, and
• the implementation-defined set of available characters contains both upper and lowercase characters.

The GPC (GNU Pascal Compiler) fulfills these conditions on an x86‑64 Linux system if compiling with the ‑‑extended-pascal option.

program p(input,output);var c:char;f:array[char]of integer value[otherwise 0];begin while not EOF do begin read(c);c:=(c+'ABCDEFGHIJKLMNOPQRSTUVWXYZ')[index('abcdefghijklmnopqrstuvwxyz',c)+1];f[c]:=f[c]+1 end;for c in['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']do if 0<f[c]then writeLn(c,f[c])end.

Ungolfed:

program letterFrequency(input, output);
    var
        c: char;
        letterFrequency: array[char] of integer value [otherwise 0];
    begin
        while not EOF(input) do
        begin
            { `read(input, c)` is equivalent to `c := input^; get(input)`. }
            read(input, c);
            
            { There is no built-in “change case” function as Pascal does not
              guarantee the coexistence of lower and uppercase letters. The EP
              function `index(source, pattern)` returns the index of the first
              occurence of `pattern` in `source`. If `pattern` is not found,
              zero is returned. Remember, `string` indices are 1-based, thus
              add `1` to select the prepended value of `c`. }
            c := (c + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
                [index('abcdefghijklmnopqrstuvwxyz', c) + 1];
            
            letterFrequency[c] := letterFrequency[c] + 1;
        end;
        
        for c in ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] do
        begin
            if letterFrequency[c] > 0 then
            begin
                writeLn(c, letterFrequency[c]);
            end;
        end;
    end.

See also FreePascal implementation.

Answer 26

CJam, 19 bytes

el_'{,97>--$e`{W%}%

Try it online!

Returns strings in the form of {char}{count}

Explanation

el_'{,97>--$e`{W%}% # a function taking an input string
el_      --         # remove all elements of the input which do not occur in
   '{,97>           # the character range lowercase a-z
           $        # sort
            e`      # run-length encode (1h1e2l as an example)
              {W%}% # to meet the output specification of {char}{count} and not {count}{char}
                    # we reverse each of the arrays in this sorted array

Answer 27

Haskell, 75 71 bytes

-4 bytes thanks to Lynn

f s=[(l,n)|(u,l)<-zip['A'..'Z']['a'..],n<-[sum[1|c<-s,l==c||u==c]],n>0]

Attempt This Online!

Explanation

List comprehensions seem to be shorter than map and filter.

f s=

Define our function, f, which takes a string s.

zip['A'..'Z']['a'..]

Create a list of (uppercase letter, lowercase letter) tuples.

(u,l)<-___

For each uppercase letter u and lowercase letter l in that list...

,n<-sum[1|c<-s,l==c||u==c]

Let n be the number of characters c in s for which c equals one of l and u...

[(l,n)|____,n>0]

Return a list of tuples of l and the corresponding n where n is greater than 0.

---

A solution using toLower from Data.Char comes in at 76 bytes:

import Data.Char
f s=[(l,n)|l<-['a'..'z'],n<-[sum[1|c<-s,l==toLower c]],n>0]

Answer 28

Julia 1.0, 51 bytes

~s=(x='A':'Z';[email protected](in(x=>x+32),s);(x.=>y)[y.>0])

Try it online!

• Thanks to MarcMush for the following:
  1. replace sum(==(x),uppercase(s)) with sum(in(x=>x+32),s)
  2. replace Tuples with Pairs (e.g., (a,b) vs. a=>b).

54 byte solution

~s=(y='A':'Z'.|>x->x=>sum(in(x=>x+32),s))[@.last(y)>0]

Try it online!

55 byte solution

~s=[x=>y for x='A':'Z' for y=sum(in(x=>x+32),s) if y>0]

Try it online!

• Thanks to Kirill L. for suggesting comprehensions and generator expressions!

Answer 29

Excel (ms365), 87 bytes

Formula in B1:

=LET(x,CHAR(ROW(97:122)),y,LEN(A1)-LEN(SUBSTITUTE(LOWER(A1),x,)),FILTER(HSTACK(x,y),y))

And 83 bytes if you don't want tupples, but a concatenation would do:

=LET(x,CHAR(ROW(97:122)),y,LEN(A1)-LEN(SUBSTITUTE(LOWER(A1),x,)),FILTER(x&"-"&y,y))

Answer 30

Java 16+ (JDK), 166 bytes

Tried to use only inline stream as a different approach, but couldn't beat the best Java answer.

s->s.toLowerCase().chars().distinct().filter(e->e>96&e<123).sorted().mapToObj(e->new String[]{(char)e+"",s.toLowerCase().chars().filter(o->o==e).count()+""}).toList()

JDoodle   (because TIO currently only supports Java up to v12)