Java: Come trovare la stringa più probabile in un elenco di stringhe?

Question

Ho un elenco di stringhe in Java contenente il nome di una persona con ortografie dissimili (non del tutto diversa).Ad esempio, John può essere scritto come Jon, Jawn, Jaun ecc. Come dovrei recuperare la stringa più appropriata in questo elenco.Se qualcuno può suggerire un metodo come utilizzare Sounex in questo caso, sarà di grande aiuto.

Answer 1

Hai usato corrispondenza approssimativa delle stringhe algoritmo, ci sono diverse strategie per implementare questo.La sfocatura è un'implementazione Java basata su trie della corrispondenza delle stringhe approssimative in base alla distanza di parola Levenshtein. Puoi trovare l'implementazione a GitHub qui

C'è un'altra strategia per implementare il suo algoritmo corrispondente a corda approssimativa da Boyer-Moore. Ecco il codice Java per quello

L'approccio abituale per risolvere questi problemi utilizzando questo algoritmo e la distanza di parola di Levenshtein è di confrontare l'ingresso alle eventuali uscite e scegliere quella con la distanza più piccola dall'uscita desiderata.

Answer 2

C'è un file JAR per la corrispondenza della stringa approssimativa ..

Vai tramite link e scarica frej.jar

http://sourceforge.net/projects/frej/files/ C'è un metodo all'interno di questo file JAR

Fuzzy.equals("jon","john");

.

restituirà true in questo tipo di stringa approssimativa.

Answer 3

solr può fare questo, se si utilizza il Filtro fonetico fabbrica durante l'indicizzazione del testo.

È la specialità di solr da cercare.E cerca parole da suonamento simili.Tuttavia, se lo vuoi solo, e non vuoi altre caratteristiche offerte da solr, puoi usare la fonte disponibile Qui .

Answer 4

Ci sono molte teorie e metodi per Stima La partita di 2 stringhe

Dare un contundente risultato true / falso sembra strano poiché "Jon" non è molto uguale a "John", è vicino ma non corrisponde

Un grande lavoro accademico che implementa un bel po 'di metodi di stima è chiamato "Secondstring.jar" - link del sito .

I metodi più implementati danno un punteggio alla partita, questo punteggio dipende dal metodo utilizzato

Esempio: Definiamo "Modifica distanza" come il numero di cambiamenti di caratteri richiesti in STR1 per arrivare a STR2 In questo caso "Jon" -> "John" richiede 1 informi Naturalmente per questo metodo un punteggio più basso è meglio

Answer 5

Questo articolo fornisce una spiegazione dettagliata e un codice completo su un'implementazione Java basata su trie della corrispondenza delle stringhe approssimative: Distanza di Levenshtein veloce e facile con un trie .

La funzione di ricerca restituisce un elenco di tutte le parole che sono inferiori al dato

Distanza massima dalla parola di destinazione

def Search (Word, MaxCost):

# build first row
currentRow = range( len(word) + 1 )

results = []

# recursively search each branch of the trie
for letter in trie.children:
    searchRecursive( trie.children[letter], letter, word, currentRow, 
        results, maxCost )

return results

.

Questo helper ricorsivo viene utilizzato dalla funzione di ricerca sopra.Assume che

La precedenteRow è già stata compilata.

Def SearchRecursive (nodo, lettera, parola, precedenteRow, risultati, maxcost):

columns = len( word ) + 1
currentRow = [ previousRow[0] + 1 ]

# Build one row for the letter, with a column for each letter in the target
# word, plus one for the empty string at column 0
for column in xrange( 1, columns ):

    insertCost = currentRow[column - 1] + 1
    deleteCost = previousRow[column] + 1

    if word[column - 1] != letter:
        replaceCost = previousRow[ column - 1 ] + 1
    else:                
        replaceCost = previousRow[ column - 1 ]

    currentRow.append( min( insertCost, deleteCost, replaceCost ) )

# if the last entry in the row indicates the optimal cost is less than the
# maximum cost, and there is a word in this trie node, then add it.
if currentRow[-1] <= maxCost and node.word != None:
    results.append( (node.word, currentRow[-1] ) )

# if any entries in the row are less than the maximum cost, then 
# recursively search each branch of the trie
if min( currentRow ) <= maxCost:
    for letter in node.children:
        searchRecursive( node.children[letter], letter, word, currentRow, 
            results, maxCost )

.