Most frequent k chars distance: Difference between revisions

| last1 = SEKER | first1 = Sadi E. | author1-link = Sadi Evren SEKER

| last2 = Altun | first2 = Oguz

| publisher = [[wp:International Association of Computer Science and Information Technology Press (IACSIT Press)]]

| title = [[wp:International Journal of Machine Learning and Computing (IJMLC)]]

| year = 2014}}.</ref>

 

 

 

{|class="wikitable"

|-

|-

|'night'

'nacht'

|-

|'my'

'a'

|10

|-

|‘research’

‘research’

|-

|-

|‘significant’

‘capabilities’

|}

 

<pre>

</pre>

 

 

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

#include <vector>

#include <map>

return 0 ;

}

{{out}}

<pre>MostFreqKHashing( s1 , 2 ) = L9T8

MostFreqKHashing( s2 , 2 ) = F9L8

</pre>

 

=={{header|Haskell}}==

where

import Data.List ( nub , sortBy )

mostFreqKSDF :: String -> String -> Int ->Int

mostFreqKSDF s t n = mostFreqKSimilarity ( mostFreqKHashing s n ) (mostFreqKHashing t n )

{{out}}

<pre>mostFrequentKHashing "LCLYTHIGRNIYYGSYLYSETWNTGIMLLLITMATAFMGYVLPWGQMSFWGATVITNLFSAIPYIGTNLV" 2

 

=={{header|J}}==

mfksDF =: {:@:[ - (mfks@:(mfkh&.>)~ {.)~

 

NB. No need to fix mfksDF

mfkh =: mfkh f.

 

fkh =. ;@:,@:(":&.>) NB. format k hash

 

'pass'

)

'''Notes''': As of press time, there are significant discrepancies between the task description, its pseudocode, the test cases provided, and the two other existing implementations. See the [[Talk:Most frequent k chars distance#Prank_Page.3F|talk page]] for the assumptions made in this implementation to reconcile these discrepancies (in particular, in the scoring function).

 

=={{header|Java}}==

Translation of the pseudo-code of the Wikipedia article [[wp:Most frequent k characters]] to [[wp:java]] implementation of three functions given in the definition section are given below with [[wp:JavaDoc]] comments:

 

import java.util.Comparator;

import java.util.HashMap;

}

 

 

=={{header|Kotlin}}==

 

I have no idea what NULL0 is supposed to mean so I've ignored that.

 

fun mostFreqKHashing(input: String, k: Int): String =

s2 = s1.reversed()

mostFreqKSDF(s1, s2, 2, 100)

 

{{out}}

SDF(input1, input2, 2, 100) = 88

</pre>

 

=={{header|Perl}}==

use strict ;

use warnings ;

print "MostFreqKHashing ( " . '$firststring , 2)' . " is " . mostFreqHashing( $firststring , 2 ) . "\n" ;

print "MostFreqKHashing ( " . '$secondstring , 2)' . " is " . mostFreqHashing( $secondstring , 2 ) . "\n" ;

{{out}}

<pre>MostFreqKHashing ( $firststring , 2) is L9T8

MostFreqKHashing ( $secondstring , 2) is F9L8</pre>

 

 

=={{header|Python}}==

{{works with|Python|2.7+}}

'''unoptimized and limited'''

def MostFreqKHashing(inputString, K):

occuDict = collections.defaultdict(int)

 

def MostFreqKSDF(inputStr1, inputStr2, K, maxDistance):

 

'''optimized'''

 

A version that replaces the intermediate string with OrderedDict to reduce the time complexity of lookup operation:

def MostFreqKHashing(inputString, K):

occuDict = collections.defaultdict(int)

 

def MostFreqKSDF(inputStr1, inputStr2, K, maxDistance):

Test:

str2 = "EWIWGGFSVDKATLNRFFAFHFILPFTMVALAGVHLTFLHETGSNNPLGLTSDSDKIPFHPYYTIKDFLG"

K = 2

print("%s:"%dict2)

print(''.join(c + str(cnt) for c, cnt in dict2.items()))

{{out}}

<pre>

=={{header|Racket}}==

 

 

(define (MostFreqKHashing inputString K)

;; (Should add more tests, but it looks like there's a bunch of mistakes

;; in the given tests...)

 

=={{header|Ring}}==

# Project : Most frequent k chars distance

 

load "stdlib.ring"

next

return aList

Output:

<pre>

 

=={{header|Sidef}}==

 

var seen = Hash()

}

}

}

 

MostFreqKSDF(s, t, k, limit),

)

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

proc MostFreqKHashing {inputString k} {

set h2 [MostFreqKHashing $inputStr2 $k]

expr {$limit - [MostFreqKSimilarity $h1 $h2]}

Demonstrating:

set str2 "EWIWGGFSVDKATLNRFFAFHFILPFTMVALAGVHLTFLHETGSNNPLGLTSDSDKIPFHPYYTIKDFLG"

puts [MostFreqKHashing $str1 2]

puts [MostFreqKHashing $str2 2]

{{out}}

<pre>

;A more efficient metric calculator

This version is appreciably more efficient because it does not compute the intermediate string representation “hash”, instead working directly on the intermediate dictionaries and lists:

set c1 [set c2 {}]

foreach ch [split $inputStr1 ""] {dict incr c1 $ch}

}

return [expr {$limit - $s}]

It computes the identical value on the identical inputs.

 

;References