Jaro-Winkler distance: Difference between revisions

{{trans|Python}}

 

V MISSPELLINGS = [‘accomodate’,

‘definately’,

print("\nClose dictionary words ( distance < 0.15 using Jaro-Winkler distance) to \" "STR" \" are:\n Word | Distance")

L(w) within_distance(0.15, STR, 5)

 

{{out}}

=={{header|Elm}}==

Author: zh5

 

 

else

result

 

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

<br>

Prints the 6 closest matches regarddless of their distance (i.e. we don't restrict it to matches closer that 0.15).

IF STRING s1 = sp1[ AT 0 ];

STRING s2 = sp2[ AT 0 ];

print( ( newline ) )

OD

{{out}}

<pre>

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

{{trans|Swift}}

#include <cstdlib>

#include <fstream>

}

return EXIT_SUCCESS;

 

{{out}}

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

This task uses [http://www.rosettacode.org/wiki/Jaro_distance#F.23 Jaro Distance (F#)]

// Calculate Jaro-Winkler Similarity of 2 Strings. Nigel Galloway: August 7th., 2020

let Jw P n g=let L=float(let i=Seq.map2(fun n g->n=g) n g in (if Seq.length i>4 then i|>Seq.take 4 else i)|>Seq.takeWhile id|>Seq.length)

["accomodate";"definately";"goverment";"occured";"publically";"recieve";"seperate";"untill";"wich"]|>

List.iter(fun n->printfn "%s" n;fN n|>Array.take 5|>Array.iter(fun n->printf "%A" n);printfn "\n")

{{out}}

<pre>

=={{header|Go}}==

This uses unixdict and borrows code from the [[Jaro_distance#Go]] task. Otherwise it is a translation of the Wren entry.

 

import (

fmt.Println()

}

 

{{out}}

Implementation:

 

Eq=. (x=/y)*(<.<:-:x>.&#y)>:|x -/&i.&# y

xM=. (+./"1 Eq)#x

simj=. x jaro y

-.simj + l*p*-.simj

 

Task example:

 

words=. <;._2 fread '/usr/share/dict/words'

for_word. ;:'accomodate definately goverment occured publically recieve seperate untill wich' do.

0.0533333 winch

0.0533333 witch

=={{header|Java}}==

{{trans|C++}}

import java.util.*;

 

}

}

 

{{out}}

This entry, which uses unixdict.txt, borrows the implementation in jq of the Jaro similarity measure as defined at

[[Jaro_similarity#jq]]; since it is quite long, it is not repeated here.

 

def length_of_common_prefix($s1; $s2):

(.[] | "\(.[0] | lpad(21)) : \(.[-1] * 1000 | round / 1000)") ;

 

{{out}}

Invocation: jq -rRn -f program.jq unixdict.txt

 

=={{header|Julia}}==

const words = read("linuxwords.txt", String) |> split .|> strip

 

end

end

<pre>

Close dictionary words ( distance < 0.15 using Jaro-Winkler distance) to 'accomodate' are:

 

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

JWD[a_][b_]:=Experimental`JaroWinklerDistance[a,b]

dict=DictionaryLookup[];

TakeSmallestBy[dict->{"Element","Value"},JWD["seperate"],5]//Grid

TakeSmallestBy[dict->{"Element","Value"},JWD["untill"],5]//Grid

{{out}}

<pre>accommodate 0.0181818

=={{header|Nim}}==

{{trans|Go}}

 

func jaroSim(s1, s2: string): float =

echo &"{c.dist:0.4f} {c.word}"

if i == 5: break

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use List::Util qw(min max head);

printf "%15s : %0.4f\n", $_, $J{$_}

for head 5, sort { $J{$a} <=> $J{$b} or $a cmp $b } grep { $J{$_} < 0.15 } keys %J;

{{out}}

<pre style="height:40ex">Closest 5 dictionary words with a Jaro-Winkler distance < .15 from 'accomodate':

=={{header|Phix}}==

Uses jaro() from [[Jaro_distance#Phix]] (reproduced below for your convenience) and the standard unix_dict()

<span style="color: #008080;">function</span> <span style="color: #000000;">jaro</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">str1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">str2</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">str1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">str1</span><span style="color: #0000FF;">))</span>

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

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

Output identical to <del>Go/Wren</del> Algol68

 

=={{header|Python}}==

Test Jaro-Winkler distance metric.

linuxwords.txt is from http://users.cs.duke.edu/~ola/ap/linuxwords

for w in within_distance(0.15, STR, 5):

print('{:>14} | {:6.4f}'.format(w, jaro_winkler_distance(STR, w)))

<pre>

Close dictionary words ( distance < 0.15 using Jaro-Winkler distance) to " accomodate " are:

using the unixdict.txt file from www.puzzlers.org

 

 

return 0 if $s eq $t;

 

printf "%15s : %0.4f\n", .key, .value for %result.grep({ .value < .15 }).sort({+.value, ~.key}).head(5);

{{out}}

<pre>Closest 5 dictionary words with a Jaro-Winkler distance < .15 from accomodate:

=={{header|Rust}}==

{{trans|Python}}

use std::io::{self, BufRead};

 

Err(error) => eprintln!("{}", error),

}

 

{{out}}

=={{header|Swift}}==

{{trans|Rust}}

 

func loadDictionary(_ path: String) throws -> [String] {

} catch {

print(error.localizedDescription)

 

{{out}}

=={{header|Typescript}}==

{{trans|Java}}

var fs = require('fs')

 

}

main();

{{out}}

<pre>

=={{header|Vlang}}==

{{trans|Go}}

 

fn jaro_sim(str1 string, str2 string) f64 {

println('')

}

 

{{out}}

{{libheader|Wren-sort}}

This uses unixdict and borrows code from the [[Jaro_distance#Wren]] task.

import "/fmt" for Fmt

import "/sort" for Sort

for (c in closest.take(6)) Fmt.print("$0.4f $s", c[1], c[0])

System.print()

 

{{out}}