Buona funzione hash per archi

Sto cercando di escogitare una buona funzione hash per le stringhe. E stavo pensando che potrebbe essere una buona idea riassumere i valori unicode per i primi cinque caratteri nella stringa (supponendo che abbia cinque, altrimenti fermati dove finisce). Sarebbe una buona idea o è una cattiva?

Lo sto facendo in Java, ma non immaginerei che farebbe molta differenza.

Di solito gli hash non farebbero somme, altrimenti stope potsavranno lo stesso hash.

e non lo limiteresti ai primi n personaggi perché altrimenti house e houses avrebbero lo stesso hash.

Generalmente gli hash prendono i valori e li moltiplicano per un numero primo (aumenta la probabilità di generare hash univoci) Quindi potresti fare qualcosa del tipo:

int hash = 7;
for (int i = 0; i < strlen; i++) {
    hash = hash*31 + charAt(i);
}

Se è una cosa di sicurezza, puoi usare Java crypto:

import java.security.MessageDigest;

MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
messageDigest.update(stringToEncrypt.getBytes());
String encryptedString = new String(messageDigest.digest());

Probabilmente dovresti usare String.hashCode () .

Se vuoi davvero implementare hashCode da solo:

Non essere tentato di escludere parti significative di un oggetto dal calcolo del codice hash per migliorare le prestazioni - Joshua Bloch, Java efficace

Usare solo i primi cinque personaggi è una cattiva idea . Pensa ai nomi gerarchici, come gli URL: avranno tutti lo stesso codice hash (perché iniziano tutti con "http: //", il che significa che sono archiviati sotto lo stesso bucket in una mappa hash, esibendo prestazioni terribili.

Ecco una storia di guerra parafrasata sul String hashCode di " Effective Java ":

La funzione hash String implementata in tutte le versioni precedenti alla 1.2 esaminava al massimo sedici caratteri, distribuiti uniformemente su tutta la stringa, a partire dal primo carattere. Per grandi raccolte di nomi gerarchici, come gli URL, questa funzione hash ha mostrato un comportamento terribile.

Se lo stai facendo in Java, allora perché lo fai? Basta chiamare .hashCode()la stringa

GuavaHashFunction ( javadoc ) offre un discreto hashing non cripto-forte.

Questa funzione fornita da Nick è buona, ma se usi la nuova stringa (byte [] byte) per effettuare la trasformazione in stringa, non è riuscita. È possibile utilizzare questa funzione per farlo.

private static final char[] hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

public static String byteArray2Hex(byte[] bytes) {
    StringBuffer sb = new StringBuffer(bytes.length * 2);
    for(final byte b : bytes) {
        sb.append(hex[(b & 0xF0) >> 4]);
        sb.append(hex[b & 0x0F]);
    }
    return sb.toString();
}

public static String getStringFromSHA256(String stringToEncrypt) throws NoSuchAlgorithmException {
    MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
    messageDigest.update(stringToEncrypt.getBytes());
    return byteArray2Hex(messageDigest.digest());
}

Può essere questo può aiutare qualcuno

// djb2 hash function
unsigned long hash(unsigned char *str)
{
    unsigned long hash = 5381;
    int c;

    while (c = *str++)
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

    return hash;
}

sorgente logica dietro la funzione hash djb2 - SO

Si dice che FNV-1 sia una buona funzione hash per le stringhe.

Per stringhe lunghe (più lunghe, per esempio, di circa 200 caratteri), puoi ottenere buone prestazioni dalla funzione hash MD4 . Come funzione crittografica, è stata interrotta circa 15 anni fa, ma per scopi non crittografici, è ancora molto buona e sorprendentemente veloce. Nel contesto di Java, è necessario convertire i charvalori a 16 bit in parole a 32 bit, ad esempio raggruppando tali valori in coppie. Una rapida implementazione di MD4 in Java può essere trovata in sphlib . Probabilmente eccessivo nel contesto di un compito in classe, ma per il resto merita una prova.

Se vuoi vedere le implementazioni standard del settore, darei un'occhiata a java.security.MessageDigest .

"I digest dei messaggi sono funzioni hash unidirezionali sicure che accettano dati di dimensioni arbitrarie e producono un valore hash di lunghezza fissa."

ecco un link che spiega molte diverse funzioni hash, per ora preferisco la funzione hash ELF per il tuo problema specifico. Prende come input una stringa di lunghezza arbitraria.

sdbm: questo algoritmo è stato creato per la libreria di database sdbm (reimplementazione di dominio pubblico di ndbm)

static unsigned long sdbm(unsigned char *str)
{   
    unsigned long hash = 0;
    int c;
    while (c = *str++)
            hash = c + (hash << 6) + (hash << 16) - hash;

    return hash;
}

         public String hashString(String s) throws NoSuchAlgorithmException {
    byte[] hash = null;
    try {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        hash = md.digest(s.getBytes());

    } catch (NoSuchAlgorithmException e) { e.printStackTrace(); }
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < hash.length; ++i) {
        String hex = Integer.toHexString(hash[i]);
        if (hex.length() == 1) {
            sb.append(0);
            sb.append(hex.charAt(hex.length() - 1));
        } else {
            sb.append(hex.substring(hex.length() - 2));
        }
    }
    return sb.toString();
}

È una buona idea lavorare con un numero dispari quando si cerca di sviluppare una buona funzione hast per la stringa. questa funzione prende una stringa e restituisce un valore di indice, finora ha funzionato abbastanza bene. e ha meno collisioni. l'indice varia da 0 a 300 forse anche più di così, ma finora non sono andato più in alto, anche con parole lunghe come "ingegneria elettromeccanica"

int keyHash(string key)
{
    unsigned int k = (int)key.length();
    unsigned int u = 0,n = 0;

    for (Uint i=0; i<k; i++)
    {
        n = (int)key[i];
        u += 7*n%31;
    }
    return u%139;
}

un'altra cosa che puoi fare è moltiplicare ogni carattere int per l'indice man mano che aumenta come la parola "orso" (0 * b) + (1 * e) + (2 * a) + (3 * r) che ti darà un valore int con cui giocare. la prima funzione di hash sopra si scontrano su "qui" e "ascolta", ma è comunque eccezionale nel dare dei buoni valori unici. quello qui sotto non si scontra con "qui" e "ascolta" perché moltiplico ogni carattere con l'indice man mano che aumenta.

int keyHash(string key)
{
    unsigned int k = (int)key.length();
    unsigned int u = 0,n = 0;

    for (Uint i=0; i<k; i++)
    {
        n = (int)key[i];
        u += i*n%31;
    }
    return u%139;
}

Ecco una semplice funzione hash che uso per una tabella hash che ho creato. Fondamentalmente è per prendere un file di testo e memorizza ogni parola in un indice che rappresenta l'ordine alfabetico.

int generatehashkey(const char *name)
{
        int x = tolower(name[0])- 97;
        if (x < 0 || x > 25)
           x = 26;
        return x;
}

Ciò che sostanzialmente fa è che le parole sono tratteggiate secondo la loro prima lettera. Quindi, la parola che inizia con 'a' otterrebbe una chiave hash di 0, 'b' otterrebbe 1 e così via e 'z' sarebbe 25. Numeri e simboli avrebbero una chiave hash di 26. C'è un vantaggio che fornisce ; Puoi calcolare facilmente e rapidamente dove una determinata parola verrebbe indicizzata nella tabella hash dato che è tutto in un ordine alfabetico, qualcosa del genere: Il codice può essere trovato qui: https://github.com/abhijitcpatil/general

Dando il seguente testo come input: Atticus un giorno disse a Jem: “Preferirei che sparassi alle lattine nel cortile di casa, ma so che inseguirai gli uccelli. Spara a tutti i ghiandaie blu che vuoi, se riesci a colpirli, ma ricorda che è un peccato uccidere un uccello beffardo. " Quella è stata l'unica volta in cui ho sentito Atticus dire che era un peccato fare qualcosa, e ho chiesto a Miss Maudie a riguardo. "Tuo padre ha ragione", disse. “I mockingbirds non fanno nulla se non fare musica per farci divertire. Non mangiano nei giardini della gente, non nidificano nei presepi di mais, non fanno nulla ma cantano il loro cuore per noi. Ecco perché è un peccato uccidere un mockingbird.

Questo sarebbe l'output:

0 --> a a about asked and a Atticus a a all after at Atticus
1 --> but but blue birds. but backyard
2 --> cribs corn can cans
3 --> do don’t don’t don’t do don’t do day
4 --> eat enjoy. except ever
5 --> for for father’s
6 --> gardens go
7 --> hearts heard hit
8 --> it’s in it. I it I it’s if I in
9 --> jays Jem
10 --> kill kill know
11 --> 
12 --> mockingbird. music make Maudie Miss mockingbird.”
13 --> nest
14 --> out one one only one
15 --> people’s
16 --> 17 --> right remember rather
18 --> sin sing said. she something sin say sin Shoot shot said
19 --> to That’s their thing they They to thing to time the That to the the tin to
20 --> us. up us
21 --> 
22 --> why was was want
23 --> 
24 --> you you you’ll you
25 --> 
26 --> “Mockingbirds ” “Your ‘em “I’d

Ciò eviterà qualsiasi collisione e sarà veloce fino a quando non utilizzeremo lo spostamento nei calcoli.

 int k = key.length();
    int sum = 0;
    for(int i = 0 ; i < k-1 ; i++){
        sum += key.charAt(i)<<(5*i);
    }