Soundex: Difference between revisions

 

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

{{works with|ALGOL 68G|Any - tested with release 2.2.0}}

Note: The only non-standard prelude functions used are to lower, is alpha, and is digit.

BEGIN

PROC encode = (CHAR c) CHAR:

printf(($g, 1x, g, 1x$, expected output OF soundex test[i], output));

printf(($b("ok", "not ok"), 1l$, output = expected output OF soundex test[i]))

=={{header|AutoHotkey}}==

{{trans|VBScript}}

If c in B,F,P,V

return 1

}

 

=={{header|C}}==

Some string examples and rules from [[http://www.archives.gov/research/census/soundex.html]].

#include <stdlib.h>

#include <string.h>

}

 

/* returns a static buffer; user must copy if want to save

result across calls */

{

int c, prev, i;

 

{

int i;

{"Soundex", "S532"},

{"Example", "E251"},

 

return 0;

 

=={{header|Clipper/XBase++}}==

 

 

/*

RETURN(nMatch)

 

--[[User:Clippersolutions|Clippersolutions]] 23:14, 4 November 2010 (UTC)--[[User:Clippersolutions|Clippersolutions]] 23:14, 4 November 2010 (UTC)

 

=={{header|Clojure}}==

(case c

(\B \F \P \V) 1

(remove nil? ,)

(take 4 ,)

 

Bug here? The distinct function eliminates duplicates. What is needed in Soundex is to eliminate consecutive duplicates.

 

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

(case c

((#\B #\F #\P #\V) #\1)

for cp = #\Z then cg

when (and cg (not (eql cg cp))) do

finally

 

=={{header|D}}==

The D standard library (Phobos) contains a soundex function:

import std.string: soundex;

 

assert(soundex("Ashcroft") == "A261");

assert(soundex("Tymczak") == "T522");

It works according to this document:

http://www.archives.gov/publications/general-info-leaflets/55.html

So soundex("Ashcraft") is A-261 instead of A-226.

 

This version uses dynamic heap allocations in some places (replace, toupper, several string join) to allow a higher level style of coding, but this function may also be written to perform zero heap allocations. It may even return a char[4] by value, or use a given buffer like the C version.

 

 

Soundex is a phonetic algorithm for indexing names by

sound, as pronounced in English. See:

http://en.wikipedia.org/wiki/Soundex

*/

// Adapted from public domain Python code by Gregory Jorgensen:

// http://code.activestate.com/recipes/52213/

 

}

 

 

 

 

}

 

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

uses

 

begin

<pre>

S532

=={{header|Erlang}}==

This implements the US Census rules, where W and H are ignored but, unlike vowels, are not separators.

-export([soundex/1]).

 

$0

end.

=={{header|Forth}}==

This implements the US Census rules, where W and H are ignored but, unlike vowels, aren't separators. Further corner cases welcome...

 

 

alpha-table soundex-code

s" Burroughs" soundex cr type \ B620

s" Burrows" soundex cr type \ B620 (W test) (any Welsh names?)

 

=={{header|Go}}==

WP article rules, plus my interpretation for input validation.

 

import (

)

 

 

func soundex(s string) (string, error) {

var sxi int

for i, c := range s {

switch {

continue

case c >= 'A' && c <= 'Z':

case c >= 'a' && c <= 'z':

default:

return "", errors.New("non-ASCII letters unsupported")

}

if i == 0 {

sxi = 1

continue

}

case '7', lastCode:

case '0':

"bump\t", // ASCII control characters disallowed

} {

fmt.Println("soundex", s, "=", x)

} else {

}

}

<pre>

soundex Robert = R163

 

=={{header|Groovy}}==

def soundex(s) {

def code = ""

println(soundex("Example"))

println(soundex("Ekzampul"))

 

=={{header|Haskell}}==

{{libheader|Text.PhoneticCode.Soundex}}

("Example","E251")

("Sownteks","S532")

 

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

every write(x := !arglist, " => ",soundex(x))

end

while name[upto('.',name)] := "" # kill .

return left(name,4,"0")

{{libheader|Icon Programming Library}} implements [http://www.cs.arizona.edu/icon/library/procs/soundex.htm soundex]. The above version is an adaptation of that procedure

 

=={{header|J}}==

'''Solution'''

codes =: ;: 'BFPV CGJKQSXZ DT L MN R HW'

if. 0=# k=.toupper y do. '0' return. end.

({.k), ,": ,. 3 {. 0-.~ }. removeDups 7 0:`(I.@:=)`]} , k >:@I.@:(e. &>)"0 _ codes

'''Usage'''

soundexNames=: 'L300 W422 D540 B625 W452 A226 E460 E460 G200 G200 H416 H416 K530 K530 L300 L222 L222'

 

B625

W452

'''Test'''

 

=={{header|Java}}==

{{trans|VBScript}}

System.out.println(soundex("Soundex"));

System.out.println(soundex("Example"));

String code, previous, soundex;

code = s.toUpperCase().charAt(0) + "";

for(int i = 1;i < s.length();i++){

String current = getCode(s.toUpperCase().charAt(i));

soundex = (code + "0000").substring(0, 4);

return soundex;

<pre>S532

E251

S532

E251</pre>

=={{header|JavaScript}}==

r = '',

codes = {

r: 6

};

a

 

 

=={{header|MUMPS}}==

;Converts a string to its Soundex value.

;Empty strings return "0000". Non-alphabetic ASCII characters are ignored.

KILL UP,LO,PREFIX,X1,X2,Y2,C,DX,XD

QUIT Y

<p>Examples:<pre>

USER>W $$SOUNDEX^SOUNDEX("")

USER>W $$SOUNDEX^SOUNDEX("ghoti")

G300</pre></p>

 

=={{header|OCaml}}==

Here is an implementation:

 

| 'B' | 'F' | 'P' | 'V' -> "1"

| 'C' | 'G' | 'J' | 'K' | 'Q' | 'S' | 'X' | 'Z' -> "2"

match dbl [] (List.rev !cl) with

| c::rem -> (String.make 1 c) ^ (soundex_aux rem)

 

Test our implementation:

 

"Soundex", "S532";

"Example", "E251";

let status = if code1 = code2 then "OK " else "Arg" in

Printf.printf " \"%s\" \t %s %s %s\n" word code1 code2 status

 

Word Code Found Status

"Soundex" S532 S532 OK

"Burrows" B620 B620 OK

"O'Hara" O600 O600 OK

 

See [[Soundex/OCaml]] for a version that can switch the language (English, French...) with a type which definition is hidden in the interface.

 

=={{header|Perl}}==

The <tt>Text::Soundex</tt> core module supports various soundex algorithms.

print soundex("Soundex"), "\n"; # S532

print soundex("Example"), "\n"; # E251

print soundex("Sownteks"), "\n"; # S532

 

 

=={{header|PHP}}==

PHP already has a built-in <tt>soundex()</tt> function:

echo soundex("Soundex"), "\n"; // S532

echo soundex("Example"), "\n"; // E251

echo soundex("Sownteks"), "\n"; // S532

echo soundex("Ekzampul"), "\n"; // E251

 

=={{header|PicoLisp}}==

(pack

(pad -4

(<> Last C)

(setq Last C) ) )

 

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

declare pword character (*) varying, value character (length(pword)) varying;

declare word character (length(pword));

return ( left(value, 4, '0') ); /* Pad, if necessary. */

 

=={{header|PureBasic}}==

Protected getCode.s = ""

word = UCase(word)

code = Mid(word,1,1)

For i = 2 To (Len(word) + 1)

current = getCode(Mid(word, i, 1))

 

PrintN (soundex("Lukasiewicz"))

 

=={{header|Python}}==

 

def soundex(word):

sdx3 = sdx2[0:4].ljust(4,'0')

return sdx3

S532

>>>print soundex("example")

C532

>>>print soundex("ekzampul")