Letter frequency: Difference between revisions

{{trans|Python}}

 

DefaultDict[Char, Int] results

L(char) s

:start:

L(letter, count) countletters(File(:argv[1]).read())

 

{{out}}

contained in the file.

 

putch: equ 2 ; Print a character

puts: equ 9 ; Print a string

numend: db 13,10,'$' ; a 16-bit number, plus newline.

 

 

=={{header|8th}}==

 

needs map/iter

print-results

bye ;

 

=={{header|ACL2}}==

(cond ((endp tbl) (list (cons key 1)))

((eql (car (first tbl)) key)

 

(defun letter-freq (str)

 

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

CARD ARRAY histogram(256)

 

LMARGIN=old ;restore left margin on the screen

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Letter_frequency.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

 

 

procedure Letter_Frequency is

end if;

end loop;

 

{{out}} (counting the characters of its own source code):

 

=={{header|Aikido}}==

 

var letters = new int [26]

foreach i letters.size() {

println (cast<char>('a' + i) + " " + letters[i])

 

=={{header|Aime}}==

Letters proper:

index x;

integer c;

o_form("%c: /w5/\n", c, x[c] += x[c + 'a' - 'A'] += 0);

c += 1;

All chars:

index x;

integer c, n;

for (c, n in x) {

o_form("%c: /w5/\n", c, n);

 

=={{header|ALGOL 68}}==

BEGIN

[0:max abs char]INT histogram;

FOR i FROM ABS "a" TO ABS "z" DO printf (($a3xg(0)l$, REPR i, histogram[i])) OD

END

{{out}} Counting letters in its own source code:

<pre>

 

=={{header|APL}}==

 

freq 0 1 2 3 2 3 4 3 4 4 4

l 2

o 2

 

The above solution doesn't do the "open a text file" part of the task. File I/O is implementation-dependent, but here's how to do it in Dyalog:

 

{{works with|Dyalog APL}}

 

... after which the above <tt>freq</tt> function can be applied to <tt>text</tt>.

This is probably best handled with vanilla AppleScript and ASObjC each each doing what it does best. The test text used here is the one specified for the [https://www.rosettacode.org/wiki/Word_frequency Word frequency] task.

 

use framework "Foundation"

use scripting additions

-- Test with the text file for the "Word frequency" task.

set theFile to ((path to desktop as text) & "135-0.txt") as alias

 

{{output}}

If we just want to get something up and running (and tabulating output) with a minimum of new code –

enough to read the frequencies of shortish texts – we can quickly click together a composition of generic functions.

use framework "Foundation"

use scripting additions

set my text item delimiters to dlm

return s

{{Out}}

<pre>SPACE -> 1330 p -> 138 " -> 28 k -> 5

we can do something a little faster with a list of simple regular expressions, again composing a solution from existing generic functions.

 

use framework "Foundation"

use scripting additions

end tell

end if

{{Out}}

<pre>e -> 332590

q -> 2533

z -> 1906</pre>

 

=={{header|Arturo}}==

 

The Red Death had long devastated the country.

No pestilence had ever been so fatal, or so hideous.

]

 

 

{{out}}

=={{header|AutoHotkey}}==

<br>This is the past version of this edit but made into a function, and now it only shows the letters that are in it, but not the ones with 0 letters

Loop, 26

{

var2 := "foo bar"

Msgbox, % LetterFreq(var)

{{out}}

<pre>

You can choose to use case sensitive search and if special chars should be searched too.

 

Func _Letter_frequency($Path, $fcase = True, $fspecial_chars = True)

Local $hFile, $sRead, $iupto, $iStart, $iCount

If $iCount > 0 Then ConsoleWrite(Chr($iStart + $i) & " : " & $iCount & @CRLF)

Next

 

{{out}}

 

=={{header|AWK}}==

# usage: awk -f letters.awk HolyBible.txt

 

{ for(i=1;i<=NF;i++) m[$i]++}

END { for(i in m) printf("%9d %-14s\n", m[i],i) }

 

=={{header|BaCon}}==

 

FOR x = 97 TO 122

PRINT CHR$(x-32), " ", CHR$(x), " : ", COUNT(txt$, x-32), " - ", COUNT(txt$, x)

NEXT

{{out}}

<pre>

 

=={{header|BBC BASIC}}==

file% = OPENIN("C:\unixdict.txt")

FOR c% = &41 TO &5A

PRINT CHR$(c%)CHR$(c%+32) ": " cnt%(c%)+cnt%(c%+32)

{{out}}

<pre>

 

=={{header|BCPL}}==

 

let start() be

endread()

{{out}}

<pre>Aa: 16421

Yy: 3633

Zz: 433</pre>

 

=={{header|Bracmat}}==

counts c

. fil$(!arg,r) {open file for reading}

 

lc$"valid.bra" {example: count letters in Bracmat's validation suite.}

+ 33*B

+ 37*C

+ 685*y

+ 211*z

 

=={{header|C}}==

int frequency[26];

int ch;

else if ('A' <= ch && ch <= 'Z') /* upper case */

frequency[ch-'A']++;

 

=={{header|C sharp}}==

using System.Collections.Generic;

using System.IO;

}

}

{{out}}

<pre> : 1

Declarative approach:

 

var freq = from c in str

where char.IsLetter(c)

foreach(var g in freq)

Console.WriteLine(g);

<pre>

C:2

 

=={{header|C++}}==

#include <iostream>

 

}

}

{{out}} when file contains "Hello, world!" (without quotes):

<pre>

 

=={{header|Clojure}}==

(frequencies (map #(java.lang.Character/toUpperCase %)

 

=={{header|Common Lisp}}==

(with-open-file (stream file)

(let ((str (make-string (file-length stream)))

(if (zerop (rem i 8)) #\newline #\tab))))))

 

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. Letter-Frequency.

END-PROGRAM.

 

{{out}}

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE LetterFrecuency;

IMPORT Files,StdLog,Strings;

END Do;

END LetterFrecuency.

Execute: ^Q LetterFrecuency.Do<br/>

{{out}}

 

=={{header|Cowgol}}==

include "argv.coh";

include "file.coh";

print_nl();

ch := ch + 1;

 

{{out}}

 

=={{header|D}}==

import std.stdio, std.ascii, std.algorithm, std.range;

 

 

writefln("%(%(%s, %),\n%)", frequency[].chunks(10));

{{out}}

<pre>16421, 4115, 8216, 5799, 20144, 2662, 4129, 5208, 13980, 430,

 

=={{header|Draco}}==

file() infile;

[256] char linebuf;

writeln(c, pretend(i | 32, char), ": ", n:5)

od

{{out}}

<pre>Aa: 16421

Yy: 3633

Zz: 433</pre>

 

=={{header|EchoLisp}}==

We use a property list - plist for short - which is a hash table, to store the pairs ( letter . count) .

;; bump count when letter added

(define (hash-counter hash key )

(map (curry hash-counter hash) (string->list string))

(list-sort hash-compare (symbol-plist hash)))

{{out}}

(define (file-stats file string)

(set-plist! 'file-stats null) ; reset counters

➛ Total letters: 212631

➛ Total lines: 4539

 

=={{header|Eiffel}}==

 

APPLICATION

 

end

end

{{out}} when file contains "Hello, Eiffel world!":

<pre>H: 1

 

=={{header|Elixir}}==

 

File.read!(file)

|> Enum.reduce(Map.new, fn c,acc -> Map.update(acc, c, 1, &(&1+1)) end)

|> Enum.sort_by(fn {_k,v} -> -v end)

 

{{out}}

Q 378

</pre>

 

=={{header|Erlang}}==

-module(letter_frequency).

-export([main/0, letter_freq/1]).

end

end, lists:seq(0, 222)).

{{out}}

<pre>"\n" : 5

 

Alternatively letter_freq/1 above can be replaced with

letter_freq( Data ) ->

Dict = lists:foldl( fun (Char, Dict) -> dict:update_counter( Char, 1, Dict ) end, dict:new(), Data ),

[io:fwrite( "~p : ~p~n", [[X], dict:fetch(X, Dict)]) || X <- dict:fetch_keys(Dict)].

 

=={{header|ERRE}}==

Using ERRE help file for testing.

 

DIM CNT[255]

 

END PROGRAM

 

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

-- LetterFrequency.ex

-- Count frequency of each letter in own source code.

 

if getc(0) then end if

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

['A'..'Z'] |> Set.ofList

 

 

for (letter, freq) in res do

 

=={{header|Factor}}==

IN: count-letters

 

utf8 [ count-from-stream ] with-file-reader

print-counts ;

 

=={{header|FBSL}}==

The result of the first evaluation of ASC() is retained in the symbol ASC for later use. This is a standard feature of FBSL functions. The ascii array is dynamic. Command(1) is the name of the script file.

 

 

'Open a text file and count the occurrences of each letter.

 

PAUSE

 

=={{header|Forth}}==

 

: freq ( filename -- )

loop ;

 

 

=={{header|Fortran}}==

Using the configuration file (which has changed since the example was documented) of the J example, compilation and output of this program on a gnu/linux system is

-*- mode: compilation; default-directory: "/tmp/" -*-

Compilation started at Sat May 18 18:09:46

 

Compilation finished at Sat May 18 18:09:46

And here's the FORTRAN90 program source. The program reads stdin and writes the result to stdout. Future enhancement: use block size records.

! count letters from stdin

program LetterFrequency

write(6, *) a

end program LetterFrequency

 

=={{header|FreeBASIC}}==

 

Dim a(65 to 90) As Integer ' array to hold frequency of each letter, all elements zero initially

Print

Print "Press any key to quit"

 

{{out}}

 

How many other languages in this page do all or any of this correctly?

{{out}}

<pre>

ñ 2

</pre>

 

=={{header|Gambas}}==

Dim sData As String = File.Load("data.txt")

Dim iCount, iSpaces, iLetters, iOther As Integer

Message("Text contains " & Len(sData) & " characters\n" & iLetters & " Letters\n" & iSpaces & " Spaces\n" & iOther & " Punctuation, newlines etc.")

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

func (lfs lfList) Swap(i, j int) {

lfs[i], lfs[j] = lfs[j], lfs[i]

{{out}}

<pre>

 

=={{header|Groovy}}==

 

frequency(new File('frequency.groovy').text).each { key, value ->

println "'$key': $value"

{{out}}

<pre>'d': 1

 

=={{header|Harbour}}==

LOCAL s := hb_MemoRead( Left( __FILE__ , At( ".", __FILE__ )) +"prg")

LOCAL c, n, i

END

 

 

{{Out}} (counting the printable characters of its own source code):

=={{header|Haskell}}==

Short version:

 

or, as an alternative to sorting and grouping the whole string, we could use some kind of container as the accumulator for a single fold, for example:

 

import qualified Data.Map.Strict as M

import Data.Ord (comparing)

(flip $ comparing snd)

. M.toList

{{Out}}

<pre>(' ',516452)

=={{header|Icon}} and {{header|Unicon}}==

The example below counts (case insensitive) letters and was run on a version of this source file.

 

procedure main(A)

every c := key(T) do

printf("%s - %d\n",c,T[c])

 

{{libheader|Icon Programming Library}}

n - 28

v - 4</pre>

 

=={{header|IS-BASIC}}==

110 NUMERIC LETT(65 TO 90)

120 FOR I=65 TO 90

290 CLOSE #1

300 CONTINUE

 

=={{header|J}}==

<br>Input is a directory-path with filename. Result is 26 integers representing counts of each letter, in alphabetic order (a's count is first).

 

letters=. u: 65 + i.26 NB. upper case letters

<: #/.~ letters (, -. -.~) toupper fread y

 

Example use (based on [[Read_a_configuration_file|a configuration file from another task]]):

 

 

=={{header|Java}}==

{{works with|Java|5+}}

import java.io.FileReader;

import java.io.IOException;

System.out.println(Arrays.toString(countLetters("filename.txt")));

}

{{works with|Java|7+}}

In Java 7, we can use try with resources. The <code>countLetters</code> method would look like this:

int[] freqs = new int[26];

try(BufferedReader in = new BufferedReader(new FileReader(filename))){

}

return freqs;

{{works with|Java|8+}}

In Java 8, we can use streams. This code also handles unicode codepoints as well. The <code>countLetters</code> method would look like this:

return Files.lines(Paths.get(filename))

.flatMapToInt(String::chars)

.boxed()

.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

 

=={{header|JavaScript}}==

we can still use core JavasScript (ES5 in the example below), to count the characters in a text once it has been read from a file system.

 

 

var cs = txt.split(''),

with a large party. Nothing could be more delightful! To be fond of\

dancing was a certain step towards falling in love; and very lively\

 

{{Out}}

 

["B", 3], ["H", 2], ["L", 2], ["M", 3], ["N", 2], ["S", 1], ["T", 2], ["W", 1],

["a", 53], ["b", 13], ["c", 17], ["d", 29], ["e", 82], ["f", 17], ["g", 16], ["h", 36],

["i", 44], ["j", 1], ["k", 3], ["l", 34], ["m", 11], ["n", 41], ["o", 40], ["p", 8],

 

===ES6===

Using the 'JavaScript for Automation' embedding of a JSContext on macOS, for access to the file system:

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>[" ",516452]

["A",7359]

["œ",7121]

["H",6605]

["M",6208]

(note that this version omits the opening of a text file which is specified in the task description):

 

'use strict';

 

null, 2

);

 

Using the spread operator, you get the unicode characters rather than the UTF-16 code units.

 

=={{header|jq}}==

# Input: an array of strings.

# Output: an object with the strings as keys,

| keys | sort[] | [., $counter[.] ]

 

{{Out}}

<pre>["\n",12]

 

=={{header|Julia}}==

function letterfreq(file::AbstractString; fltr::Function=(_) -> true)

display(letterfreq("src/Letter_frequency.jl"; fltr=isletter))

<pre>

DataStructures.OrderedDict{Char,Int64} with 29 entries:

 

=={{header|K}}==

 

Example: The file "hello.txt" contains the string "Hello, world!"

 

c:+(?a;#:'=a:,/0:`hello.txt)

 

{{out}}

Sort on decreasing occurrences:

 

c@>c[;1]

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.io.File

val sum = letterMap.values.sumBy { it.size }

println("\nTotal letters = $sum")

 

{{out}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

[[ ${ch} == ?(\S) ]] && print -- "${ch} ${freqCnt[${ch}]}"

done

{{out}}

Counts the characters of the source code file

In this entry we choose to show how lambdatalk can use any existing javascript code (say the #Javascript entry in this page), and build an interface to use it as a standard lambdatalk function. So, applied to any string the W.frequency primitive returns a pair structure containing the array of chars and the corresponding array of frequencies.

 

 

{script

 

 

 

=={{header|langur}}==

for[=h{}] .s2 in split(replace(.s, RE/\P{L}/)) {

_for[.s2; 0] += 1

 

val .counts = .countLetters(readfile "./fuzz.txt")

 

{{out}}

 

=={{header|Lasso}}==

str = 'Hello world!',

freq = map

with elem in #freq->keys do => {^

'"'+#elem+'": '+#freq->find(#elem)+'\r'

 

=={{header|Liberty BASIC}}==

Un-rem a line to convert to all-upper-case.

Letter freq'y is printed as percentages.

open "text.txt" for input as #i

txt$ =input$( #i, lof( #i))

 

end

 

=={{header|Lua}}==

This solution counts letters only, which could be changed by altering the pattern argument to 'gmatch' on line 31. It also treats upper and lower case letters as distinct, which could be changed by changing everything to upper or lower case with string.upper() or string.lower() before tallying.

function readFile (filename)

local file = assert(io.open(filename, "r"))

-- Main procedure

local letterCount = tally()

letterCount(letter)

end

for k, v in pairs(letterCount()) do

print(k, v)

Output from running this script on itself:

<pre>i 24

f 16

R 2

v 2

s 14

t 54

C 3

A 1

F 2

 

=={{header|M2000 Interpreter}}==

document file1$={Open a text file and count the occurrences of each letter.

Some of these programs count all characters (including punctuation), but some only count letters A to Z

print #Console, Export$

clipboard Export$

 

{{out}}

 

=={{header|Maple}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

 

=={{header|MATLAB}} / {{header|Octave}}==

if ischar(t)

t = abs(t);

A = sparse(t+1,1,1,256,1);

printf('"%c":%i\n',[find(A)-1,A(A>0)]')

 

=={{header|Nanoquery}}==

characters = list()

amounts = list()

for i in range(0, len(characters) - 1)

println format("%-20s %d", characters[i], amounts[i])

{{out}}

<pre>$ java -jar ../nanoquery-2.3_1462.jar -b letterfreq.nq sherlock-holmes.txt

=={{header|NetRexx}}==

{{trans|REXX}}

* 22.05.2013 Walter Pachl translated from REXX

**********************************************************************/

end

 

 

=={{header|Nim}}==

 

var t = initCountTable[char]()

for c in l:

t.inc(c)

 

=={{header|Objeck}}==

use IO;

 

}

}

 

=={{header|Objective-C}}==

 

 

int main (int argc, const char *argv[]) {

}

return 0;

 

=={{header|OCaml}}==

We open a text file and compute letter frequency. Other characters than [a-z] and [A-Z] are ignored, and upper case letters are first converted to lower case before to compute letter frequency.

 

let ic = open_in Sys.argv.(1) in

let base = int_of_char 'a' in

for i=0 to 25 do

Printf.printf "%c -> %d\n" (char_of_int(i + base)) arr.(i)

 

If we want to compute all characters in an UTF8 file, we must use an external library, for example Batteries. The following function takes as input a string that contains the path to the file, and prints all the characters together with their frequencies, ordered by increasing frequencies, on the standard output.

 

open Batteries

 

@@ List.sort (fun (_,v) (_,v') -> compare v v')

@@ Hashtbl.fold (fun k v l -> (Text.of_uchar k,v) :: l) freq []

 

=={{header|Ol}}==

(define source (bytes->string (file->bytestream "letter_frequency.scm"))) ; utf-8

(define dict (lfold (lambda (ff char)

(print))

(ff->alist dict))

{{Out}}

<pre>NEWLINE --> 27

 

=={{header|OxygenBasic}}==

indexbase 0

 

print pr

'putfile "CharCount.txt",pr

 

=={{header|PARI/GP}}==

U=readvec("foo.txt");

for(i=1,#U,u=Vecsmall(U[i]);for(j=1,#u,if(u[j]>64&&u[j]<91,v[u[j]-64]++,u[j]>96&&u[j]<123,v[u[j]-96]++)));

 

=={{header|Pascal}}==

{{works with|Extended Pascal}}

var

chart: array[char] of 0..maxInt value [otherwise 0];

{ now, chart[someLetter] gives you the letter’s frequency }

 

=={{header|Perl}}==

Counts letters in files given on command line or piped to stdin. Case insensitive.

 

=={{header|Phix}}==

<del>Counts own source or supplied filename</del> Now counts words in unixdict.txt of 17 letters or more (to make it js compatible)

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">lc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">#7E</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

"unixdict.txt" "r" fopen var file

endfor

file fclose

 

=={{header|PHP}}==

print_r(array_count_values(str_split(file_get_contents($argv[1]))));

 

=={{header|Picat}}==

Sorting on the frequency (decreasing).

% removing '\n' first

Chars = delete_all(read_file_chars("unixdict.txt"),'\n'),

sort_map(Map,values) = [K=V:_=(K=V) in sort([V=(K=V): K=V in Map])].

sort_map(Map,keys) = sort([KV : KV in Map]).

 

{{out}}

 

=={{header|PicoLisp}}==

(in "file.txt"

(while (char) (accu 'Freq @ 1)) )

For a "file.txt":

<pre>abcd

 

=={{header|Pike}}==

string all = Stdio.read_file("README.md");

mapping res = ([]);

res[char]++;

write("%O\n", res);

{{Out}}

<pre>

 

=={{header|PL/I}}==

frequencies: procedure options (main);

declare tallies(26) fixed binary static initial ((26) 0);

put skip list (substr(alphabet, i, 1), tallies(i));

end;

Data:

<pre>

 

=={{header|PowerShell}}==

function frequency ($string) {

$arr = $string.ToUpper().ToCharArray() |where{$_ -match '[A-KL-Z]'}

$file = "$($MyInvocation.MyCommand.Name )" #Put the name of your file here

frequency $(get-content $file -Raw)

<b>Output:</b>

<pre>

Only alphabetic codes are computed in uppercase state. <br>

Uses '''packlist/2''' defined there : [[Run-length encoding#Prolog]] <br>

read_file_to_codes(File, Code, []),

 

run(Var,[Other|RRest], [1,Var],[Other|RRest]):-

dif(Var,Other).

{{out}} for this file

<pre>Number of A : 63

=={{header|PureBasic}}==

Alphabetic codes are converted to uppercase before being used and no other codes are used as part of the calculations. <br>

;counts only letters A -> Z, uses index 0 of letterCounts() to keep a total of all counts

Protected i, lineLength = Len(textLine), letter

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>File: D:\_T\Text\dictionary.txt

====Using collections.Counter====

{{works with|Python|2.7+ and 3.1+}}

 

def filecharcount(openfile):

 

f = open(sys.argv[1])

 

====As a fold====

Character counting can be conveniently expressed in terms of fold/reduce. See the example below, which also generates column-wrapped output:

{{Works with|Python|3}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Descending order of frequency:

===Procedural===

====Without using collections.Counter====

if hasattr(string, 'ascii_lowercase'):

letters = string.ascii_lowercase # Python 2.2 and later

lettercounts = countletters(sourcedata)

for i in xrange(len(lettercounts)):

 

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 defaultdict====

{{works with|Python|2.5+ and 3.x}}

from collections import defaultdict

def countletters(file_handle):

c = char.lower()

results[c] += 1

 

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:

 

for letter,count in lettercounts.iteritems():

 

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

=={{header|Quackery}}==

 

 

[ char A char Z 1+ within ] is ischar ( c --> b )

join fail ]

countchars

 

'''Testing in Quackery shell:'''

=={{header|Quick Basic/QBASIC/PDS 7.1/VB-DOS}}==

This version counts valid letters from A to Z (including Ñ in Spanish alphabet) or characters in a file. Takes in account accented vowels. It runs in QB, QBASIC, PDS 7.1 and VB_DOS as is.

' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '

' Program CountCar '

' ---End of main program cycle

 

 

Output:

=={{header|R}}==

===Using summary===

{

file <- paste(readLines(filename), collapse = '')

chars <- strsplit(file, NULL)[[1]]

summary(factor(chars))

 

Usage on itself:

 

> letter.frequency('letter.frequency.r')

- , . ' ( ) [ ] { } < = 1 a c d e f h i l L m n N o p q r s t u U y

===Using table===

R's table function is more idiomatic. For variety, we will use read.delim rather than readLines and show how to only count letters. It is worth noting that readLines is prone to counting empty lines. This may be undesirable.

{

txt <- read.delim(filename, header = FALSE, stringsAsFactors = FALSE, allowEscapes = FALSE, quote = "")

count <- table(strsplit(paste0(txt[,], collapse = ""), ""))

if(lettersOnly) count[names(count) %in% c(LETTERS, letters)] else count

{{out}}

For fun, we'll use this page for input. However, HTML rarely parses well and the variety of text here is so large that I suspect inaccurate output.

 

=={{header|Racket}}==

#lang racket

(require math)

 

(letter-frequencies (open-input-string "abaabdc"))

{{out}}

<pre>

 

Using input from a text file:

(letter-frequencies (open-input-file "somefile.txt"))

 

=={{header|Raku}}==

</div>

 

 

sub ws ($pair) {

?? ($pair.key.uniname => $pair.value)

!! $pair

{{Out|Output when fed the same Les Misérables text file as used in the [[Word_frequency#Raku|Word frequency]] task}}

<pre>SPACE => 522095

 

=={{header|Raven}}==

{ } as $wordHash [ ] as $keys [ ] as $vals

$words each chr

"test.dat" as $file

$file read as $all_data

 

=={{header|REXX}}==

===version 1===

 

All characters are still counted, whether a letter or not, including non-displayable characters.

/* Latin alphabet letters are uppercased for also counting {Latin} letters (both cases).*/

/*════════════════════════════════════~~~~~~~~~~════════════════════════════════════════*/

say /*not a good place for dithering: ░▒▓█ */

say pad pad9 '☼ end─of─list ☼' /*show we are at the end of the list. */

'''output''' &nbsp; when using the (above) REXX program for the input file:

 

 

===Version 2 (for TSO)===

* Adapted version 1 for TSO (EXECIO instead of linein)

* No translation to uppercase takes place

end

end

Output:

<pre>

 

=={{header|Ring}}==

textData = read("C:\Ring\ReadMe.txt")

ln =len(textData)

if charCount[i] > 0 see char(i) + " = " + charCount[i] + " " + (charCount[i]/totCount)*100 + " %" + nl ok

next

 

=={{header|Ruby}}==

letters = 'a' .. 'z'

File.read(file) .

end

 

example output, using the program file as input:

<pre>$ ruby letterFrequency.rb letterFrequency.rb

 

===Ruby 2.0===

freq = Hash.new(0)

file.each_char.lazy.grep(/[[:alpha:]]/).map(&:upcase).each_with_object(freq) do |char, freq_map|

letter_frequency(ARGF).sort.each do |letter, frequency|

puts "#{letter}: #{frequency}"

 

note that this version *should* use less memory, even on a gigantic file. This is done by using lazy enumerables, which ruby 2.0 introduces.

===Ruby 2.7===

Ruby 2.7 introduced "tally", which delivers a tally on anything enumerable.

 

=={{header|Run BASIC}}==

textData$ = input$(#f, lof( #f))

ln =len(textData$)

for i = 32 to 255

if charCount(i) > 0 then print "Ascii:";using("###",i);" char:";chr$(i);" Count:";using("#######",charCount(i));" ";using("##.#",(charCount(i) / totCount) * 100);"%"

 

Output uses this program to count itself:

=={{header|Rust}}==

Works with all UTF-8 characters

use std::{env, process};

use std::io::{self, Read, Write};

writeln!(&mut io::stderr(), "{}", msg).expect("Could not write to stderr");

process::exit(code)

 

Output when run on source file:

=={{header|S-BASIC}}==

Because S-BASIC lacks an EOF function, some extra care is required to avoid reading beyond the end of file. (CP/M text files are normally terminated with a Ctrl-Z byte, but not all text editors enforce this convention if the file would otherwise end on a sector boundary.)

$constant EOF = 1AH rem normal end-of-file marker

 

9_exit

end

{{out}}

With Lincoln's Second Inaugural Address used as input

=={{header|Scala}}==

 

 

def letterFrequencies(filename: String) =

 

=={{header|Scheme}}==

Note that this prints the scheme representations of characters in no particular order.

 

 

(define (char-freq port table)

(format-table (char-freq (open-input-file filename) '())))

 

 

Output when reading own source:

An implementation for CHICKEN scheme:

 

(with-input-from-string "foobar"

(lambda ()

'()

read-char)))

 

which shows: ((#\f . 1) (#\o . 2) (#\b . 1) (#\a . 1) (#\r . 1))

 

=={{header|Seed7}}==

const type: charHash is hash [char] integer;

writeln(ch <& " " <& numberOfChars[ch]);

end for;

 

Output when the program uses itself as input:

 

=={{header|SenseTalk}}==

put file "~/Documents/addresses.csv" into source

 

put char 1 of theChar & " —> " & count

end repeat

Output:

<pre>

 

=={{header|Sidef}}==

file.read.chars.grep{.match(/[[:alpha:]]/)} \

.group_by {|letter| letter.downcase} \

var top = letter_frequency(File(__FILE__))

{{out}}

<pre>

=={{header|SIMPOL}}==

Example: open a text file and compute letter frequency.

 

function main(string filename)

end while

end if

 

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:

 

 

function main(string filename)

end while

end if

 

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.

Make it a bag of characters and get the counts:

{{works with|Smalltalk/X}}

bag sortedCounts

select:[:assoc | assoc value isLetter ]

If the file is huge, you may not want to read it in as a big string first, but feed the chars linewise into the bag:

'someFile' asFilename readingLinesDo:[:eachLine | bagOfChars addAll:eachLine].

 

To show all counts (as opposed to selecting the letter counts only), replace the "select:thenDo:" by a simple "do:", as in:

or even shorter:

{{out}}

<pre>27->e

...</pre>

If you prefer seeing the character first, followed by the count, replace the do-loop's action with:

{{out}}

<pre>e -> 27

=={{header|Swift}}==

 

 

let dictPath: String

for (char, count) in counts {

print("\(char): \(count)")

 

=={{header|Tcl}}==

# Initialize table (in case of short texts without every letter)

for {set i 97} {$i<=122} {incr i} {

}

 

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

words = REQUEST ("http://www.puzzlers.org/pub/wordlists/unixdict.txt")

 

*{frequency}

Output:

<pre style='height:30ex;overflow:scroll'>

===TXR Extraction Language plus TXR Lisp===

 

@(repeat)

@(coll :vars ())@\

@(end)

@(do (dohash (key value h)

 

{{out}}

===TXR Lisp===

 

(chrs [keep-if* chr-isalpha (gun (get-char s))])

(h [group-reduce (hash) chr-toupper (op succ @1) chrs 0]))

(dohash (key value h)

 

=={{header|Vala}}==

{{libheader|Gee}}

Counts every character except new line character.

using Gee;

 

}

}

 

Sample output (run on its own source code) with several lines omitted:

=={{header|VBA}}==

 

Public Sub LetterFrequency(fname)

'count number of letters in text file "fname" (ASCII-coded)

Close

End Sub

 

Output:

 

=={{header|VBScript}}==

filepath = "SPECIFY FILE PATH HERE"

 

Set objfso = Nothing

Set objdict = Nothing

 

=={{header|Vedit macro language}}==

 

Update()

 

#2 = Search(@103, BEGIN+ALL+NOERR)

Message(@103) Num_Type(#2)

 

Example output:

</pre>

 

 

struct LetterFreq {

rune int

println('${u8(f.rune).ascii_str()} ${f.rune} $f.freq')

}

{{out}}

 

=={{header|Whitespace}}==

 

 

 

 

; Initialize a slot in the heap for each ASCII character.

0:

4:

pop

 

{{out}}

{{libheader|Wren-fmt}}

As we have a copy to hand, we count the number of letters in the MIT 10000 word list which apparently contains nothing other than lower case letters.

 

var text = File.read("mit10000.txt")

Fmt.print(" $5d 100.00", totalFreq)

 

 

{{out}}

character ($1A). Usage: count <filename.ext

 

int A(256), C, I;

[for C:= 0 to 256-1 do A(C):= 0;

if (I&7) = 7 then [CrLf(0); C:= C-8*16+1];

];

 

Example output of count.xpl counting itself:

 

=={{header|Yabasic}}==

 

f = open("unixdict.txt", "r")

next

close #f

 

=={{header|zkl}}==

letters:=["a".."z"].pump(List().write,0); // array of 26 zeros

textInBitBucket.howza(0).pump(Void,'wrap(c){ // pump text as ints

 

ccnt(Data(0,Int,"This is a test"));

{{out}}

<pre>

 

=={{header|Zoea}}==

program: letter_frequency

input: 'cbcacb' # can be literal value, stdin or file url at runtime

derive: [[a,1],[b,2],[c,3]]

output: 'a : 1\nb : 2\nc : 3\n'

 

=={{header|Zoea Visual}}==