Letter frequency: Difference between revisions

Content added Content deleted

Inline

Revision as of 13:03, 19 September 2011

Open a text file and compute letter frequency.

The first 7 solutions (Aikido, C, J, OCaml, Pascal, Python, SIMPOL) moved here from the Array page. They might not all accomplish the same task.

J

The example task is the same: open a text file and compute letter frequency.
Input is a directory-path with filename. Result is 26 integers.

<lang j>require 'files' NB. define fread ltrfreq=: 3 : 0

 letters=. 4 u: 65+i.26   NB. upper case letters
 <: #/.~ (toupper fread y) (,~ -. -.) letters

)</lang>

Example use (based on a configuration file from another task):

<lang j> ltrfreq 'config.file' 28 9 5 10 33 12 5 12 28 0 0 15 11 21 23 2 0 17 22 26 10 3 2 0 1 0</lang>

OCaml

same task, open a text file and compute letter frequency <lang ocaml>let () =

 let ic = open_in Sys.argv.(1) in
 let base = int_of_char 'a' in
 let arr = Array.make 26 0 in
 try while true do
   let c = Char.lowercase(input_char ic) in
   let ndx = int_of_char c - base in
   if ndx < 26 && ndx >= 0 then
     arr.(ndx) <- succ arr.(ndx)
 done
 with End_of_file ->
   close_in ic;
   for i=0 to 25 do
     Printf.printf "%c -> %d\n" (char_of_int(i + base)) arr.(i)
   done</lang>

Here is the documentation of the module Array. (there is also a Bigarray module)

Python

Using collections.Counter

Works with: Python version 2.7+ and 3.1+

<lang python>import collections, sys

def filecharcount(openfile):

   c = collections.Counter()
   for line in openfile:
       c.update(line)
   return sorted(c.items())

f = open(sys.argv[1]) print(filecharcount(f))</lang>

Not using collections.Counter

<lang python>import string if hasattr(string, ascii_lowercase):

   letters = string.ascii_lowercase       # Python 2.2 and later

else:

   letters = string.lowercase             # Earlier versions

offset = ord('a')

def countletters(file_handle):

   """Traverse a file and compute the number of occurences of each letter
   """return results as a simple 26 element list of integers.
   results = [0] * len(letters)
   for line in file_handle:
       for char in line:
           char = char.lower()
           if char in letters:
               results[offset - ord(char)] += 1
               # Ordinal of 'a' minus ordinal of any lowercase ASCII letter -> 0..25
   return results

if __name__ == "__main__":

   sourcedata = open(sys.argv[1])
   lettercounts = countletters(sourcedata)
   for i in xrange(len(lettercounts)):
       print "%s=%d" % (chr(i + ord('a')), lettercounts[i]),</lang>

This example defines the function and provides a sample usage. The if ... __main__... line allows it to be cleanly imported into any other Python code while also allowing it to function as a standalone script. (A very common Python idiom).

Using a numerically indexed array (list) for this is artificial and clutters the code somewhat.

Using defaultdict

Works with: Python version 2.5+ and 3.x

<lang python>... from collections import defaultdict def countletters(file_handle):

   """Count occurences of letters and return a dictionary of them
   """
   results = defaultdict(int)
   for line in file_handle:
       for char in line:
           if char.lower() in letters:
               c = char.lower()
               results[c] += 1
   return results</lang>

Which eliminates the ungainly fiddling with ordinal values and offsets in function countletters of a previous example above. More importantly it allows the results to be more simply printed using:

<lang python>lettercounts = countletters(sourcedata) for letter,count in lettercounts.iteritems():

   print "%s=%s" % (letter, count),</lang>

Again eliminating all fussing with the details of converting letters into list indices.

SIMPOL

Example: open a text file and compute letter frequency. <lang simpol>constant iBUFSIZE 500

function main(string filename)

 fsfileinputstream fpi
 integer e, i, aval, zval, cval
 string s, buf, c
 array chars

 e = 0
 fpi =@ fsfileinputstream.new(filename, error=e)
 if fpi =@= .nul
   s = "Error, file """ + filename + """ not found{d}{a}"
 else
   chars =@ array.new()
   aval = .charval("a")
   zval = .charval("z")
   i = 1
   while i <= 26
     chars[i] = 0
     i = i + 1
   end while
   buf = .lcase(fpi.getstring(iBUFSIZE, 1))
   while not fpi.endofdata and buf > ""
     i = 1
     while i <= .len(buf)
       c = .substr(buf, i, 1)
       cval = .charval(c)
       if cval >= aval and cval <= zval
         chars[cval - aval + 1] = chars[cval - aval + 1] + 1
       end if
       i = i + 1
     end while
     buf = .lcase(fpi.getstring(iBUFSIZE, 1))
   end while

   s = "Character counts for """ + filename + """{d}{a}"
   i = 1
   while i <= chars.count()
     s = s + .char(aval + i - 1) + ": " + .tostr(chars[i], 10) + "{d}{a}"
     i = i + 1
   end while
 end if

end function s</lang>

As this was being created I realized that in [SIMPOL] I wouldn't have done it this way (in fact, I wrote it differently the first time and had to go back and change it to use an array afterward). In [SIMPOL] we would have used the set object. It acts similarly to a single-dimensional array, but can also use various set operations, such as difference, unite, intersect, etc. One of th einteresting things is that each unique value is stored only once, and the number of duplicates is stored with it. The sample then looks a little cleaner:

<lang simpol>constant iBUFSIZE 500

function main(string filename)

 fsfileinputstream fpi
 integer e, i, aval, zval
 string s, buf, c
 set chars

 e = 0
 fpi =@ fsfileinputstream.new(filename, error=e)
 if fpi =@= .nul
   s = "Error, file """ + filename + """ not found{d}{a}"
 else
   chars =@ set.new()
   aval = .charval("a")
   zval = .charval("z")
   buf = .lcase(fpi.getstring(iBUFSIZE, 1))
   while not fpi.endofdata and buf > ""
     i = 1
     while i <= .len(buf)
       c = .substr(buf, i, 1)
       if .charval(c) >= aval and .charval(c) <= zval
         chars.addvalue(c)
       end if
       i = i + 1
     end while
     buf = .lcase(fpi.getstring(iBUFSIZE, 1))
   end while

   s = "Character counts for """ + filename + """{d}{a}"
   i = 1
   while i <= chars.count()
     s = s + chars[i] + ": " + .tostr(chars.valuecount(chars[i]), 10) + "{d}{a}"
     i = i + 1
   end while
 end if

end function s</lang>

The final stage simply reads the totals for each character. One caveat, if a character is unrepresented, then it will not show up at all in this second implementation.

Tcl

<lang tcl>proc letterHistogram {fileName} {

   # Initialize table (in case of short texts without every letter)
   for {set i 97} {$i<=122} {incr i} {
       set frequency([format %c $i]) 0
   }
   # Iterate over characters in file
   set f [open $fileName]
   foreach c [split [read $f] ""] {
       # Count them if they're alphabetic
       if {[string is alpha $c]} {
           incr frequency([string tolower $c])
       }
   }
   close $f
   # Print the histogram
   parray frequency

}

letterHistogram the/sample.txt</lang>

@@ Line 56: / Line 56: @@
 )</lang>
-Example use (based on [[Read_a_configuration_file|config.file]]):
+Example use (based on [[Read_a_configuration_file|a configuration file from another task]]):
 <lang j>   ltrfreq 'config.file'