Orsdxy

I'm trying to find the most frequent letter in a list of words. I'm struggling with the algorithm because I need to count the letter frequency in a word only once skipping duplicates, so I need help finding a way to count the frequency of the letters in the entire list with only one occurrence per word, ignoring the second occurrence.

For example if i have:

words=["tree","bone","indigo","developer"]

The frequency will be:

letters={a:0, b:1, c:0, d:2, e:3, f:0, g:1, h:0, i:1, j:0, k:0, l:1, m:0, n:2, o:3, p:1, q:0, r:2, s:0, t:1, u:0, v:1, w:0, x:0, y:0, z:0}

As you can see from the letters dictionary: 'e' is 3 and not 5 because if 'e' repeats more than once in the same word it should be ignored.

This is the algorithm that I came up with, it's implemented in Python:

for word in words:

    count=0;



    for letter in word:

        if(letter.isalpha()):

            if((letters[letter.lower()] > 0  && count == 0) ||

               (letters[letter.lower()] == 0 && count == 0)):



                    letters[letter.lower()]+=1

                    count=1



            elif(letters[letter.lower()]==0 && count==1):   

                letters[letter.lower()]+=1

But it still requires work and I can't think about anything else, I'd be glad to anyone who will help me to think about a working solution.

A variation on @Primusa answer without using update:

from collections import Counter



words = ["tree", "bone", "indigo", "developer"]

counts = Counter(c for word in words for c in set(word.lower()) if c.isalpha())

Output

Counter({'e': 3, 'o': 3, 'r': 2, 'd': 2, 'n': 2, 'p': 1, 'i': 1, 'b': 1, 'v': 1, 'g': 1, 'l': 1, 't': 1})

Basically convert each word to a set and then iterate over each set.

Create a counter object and then update it with sets for each word:

from collections import Counter

c = Counter()



for word in wordlist:

    c.update(set(word.lower()))

One without Counter

words=["tree","bone","indigo","developer"]

d={}

for word in words:         # iterate over words

    for i in set(word):    # to remove the duplication of characters within word

        d[i]=d.get(i,0)+1

Output

{'b': 1,

 'd': 2,

 'e': 3,

 'g': 1,

 'i': 1,

 'l': 1,

 'n': 2,

 'o': 3,

 'p': 1,

 'r': 2,

 't': 1,

 'v': 1}

Comparing speed of the solutions presented so far:

def f1(words):

    c = Counter()

    for word in words:

        c.update(set(word.lower()))

    return c



def f2(words):

    return Counter(

        c

        for word in words

        for c in set(word.lower()))



def f3(words):

    d = {}

    for word in words:

        for i in set(word.lower()):

            d[i] = d.get(i, 0) + 1

    return d

My timing function (using different sizes for the list of words):

word_list = [

    'tree', 'bone', 'indigo', 'developer', 'python',

    'language', 'timeit', 'xerox', 'printer', 'offset',

]



for exp in range(5):

    words = word_list * 10**exp



    result_list = 

    for i in range(1, 4):

        t = timeit.timeit(

            'f(words)',

            'from __main__ import words,  f{} as f'.format(i),

            number=100)

        result_list.append((i, t))



    print('{:10,d} words | {}'.format(

        len(words),

        ' | '.join(

            'f{} {:8.4f} sec'.format(i, t) for i, t in result_list)))

The results:

        10 words | f1   0.0028 sec | f2   0.0012 sec | f3   0.0011 sec

       100 words | f1   0.0245 sec | f2   0.0082 sec | f3   0.0113 sec

     1,000 words | f1   0.2450 sec | f2   0.0812 sec | f3   0.1134 sec

    10,000 words | f1   2.4601 sec | f2   0.8113 sec | f3   1.1335 sec

   100,000 words | f1  24.4195 sec | f2   8.1828 sec | f3  11.2167 sec

The Counter with list comprehension (here as f2()) seems to be the fastest. Using counter.update() seems to be a slow point (here as f1()).