Dizeler için İyi Karma İşlevi

Dizeler için iyi bir karma işlevi düşünmeye çalışıyorum. Ve dizede ilk beş karakter için unicode değerlerini özetlemek iyi bir fikir olabileceğini düşünüyordum (beş olduğu varsayılarak, aksi takdirde bittiği yerde dur). Bu iyi bir fikir mi yoksa kötü bir fikir mi?

Bunu Java'da yapıyorum, ancak bunun çok fazla fark yaratacağını hayal edemezdim.

Genellikle toplamları yapmazdı sağlamalarının, aksi stopve potsaynı karma sahip olacaktır.

ve bunu ilk n karakterle sınırlamazsınız çünkü aksi takdirde ev ve evler aynı hash'a sahip olurdu.

Genellikle hash değerleri alır ve bir asal sayı ile çarpar (benzersiz hash üretme olasılığını artırır) Böylece şöyle bir şey yapabilirsiniz:

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

Bu bir güvenlik şeyiyse, Java kripto kullanabilirsiniz:

import java.security.MessageDigest;

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

Muhtemelen String.hashCode () kullanmalısınız .

Gerçekten hashCode'u kendiniz uygulamak istiyorsanız:

Performansı artırmak için bir nesnenin önemli bölümlerini karma kod hesaplamasının dışında bırakmaya çalışmayın - Joshua Bloch, Etkili Java

Yalnızca ilk beş karakteri kullanmak kötü bir fikirdir . URL'ler gibi hiyerarşik adları düşünün: hepsinin aynı karma kodu olacaktır (çünkü hepsi "http: //" ile başlar, bu da korkunç bir performans gösteren karma bir haritada aynı grup altında depolandıkları anlamına gelir.

İşte " Effective Java " dan String hashCode üzerinde açıklanmış bir savaş hikayesi :

1.2'den önceki tüm sürümlerde uygulanan String sağlama işlevi, ilk karakterle başlayarak dize boyunca eşit aralıklarla en fazla on altı karakteri inceledi. URL'ler gibi büyük hiyerarşik ad koleksiyonları için bu karma işlevi korkunç davranışlar gösterdi.

Bunu Java ile yapıyorsanız neden yapıyorsunuz? Sadece .hashCode()dizeyi arayın

Guava'nınHashFunction ( javadoc ) iyi kripto-güçlü karmaşasını sağlar.

Nick tarafından sağlanan bu işlev iyidir, ancak String'e dönüşüm yapmak için yeni String (bayt [] bayt) kullanırsanız, başarısız oldu. Bunu yapmak için bu işlevi kullanabilirsiniz.

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());
}

Belki bu birine yardım edebilir

// 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;
}

kaynak djb2 ​​karma fonksiyon arkasında Mantık - SO

FNV-1'in dizeler için iyi bir sağlama işlevi olduğu söylenir.

Uzun dizeler için (örneğin, yaklaşık 200 karakterden daha uzun), MD4 karma işlevinden iyi performans elde edebilirsiniz . Kriptografik bir işlev olarak, yaklaşık 15 yıl önce kırıldı, ancak kriptografik olmayan amaçlar için hala çok iyi ve şaşırtıcı derecede hızlı. Java bağlamında, 16 bit chardeğerleri 32 bit kelimelere dönüştürmeniz gerekir , örneğin bu değerleri çiftler halinde gruplandırarak. Java'da MD4'ün hızlı bir şekilde uygulanması sphlib'de bulunabilir . Muhtemelen bir sınıf ödevi bağlamında aşırıya kaçmak, ama aksi halde denemeye değer.

Endüstri standardı uygulamaları görmek istiyorsanız, java.security.MessageDigest'e bakarım .

"İleti özetleri, rasgele boyutlu veriler alan ve sabit uzunluklu bir karma değer çıkaran tek yönlü güvenli işlevlerdir."

İşte birçok farklı hash fonksiyonunu açıklayan bir bağlantı , şimdilik sizin özel probleminiz için ELF hash fonksiyonunu tercih ediyorum. Girdi olarak gelişigüzel uzunlukta bir dize alır.

sdbm: bu algoritma sdbm (ndbm'nin ortak etki alanı yeniden uygulaması) veritabanı kitaplığı için oluşturuldu

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();
}

Dize için iyi bir hast işlevi geliştirmeye çalışırken tek sayı ile çalışmak iyi bir fikirdir. bu işlev bir dize alır ve bir dizin değeri döndürür, şimdiye kadar çalışması oldukça iyi. ve daha az çarpışma var. endeks 0 - 300 arasında değişebilir belki daha da fazla, ama ben şimdiye kadar "elektromekanik mühendisliği" gibi uzun kelimelerle daha da yükselmedim

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;
}

Yapabileceğiniz başka bir şey de "ayı" (0 * b) + (1 * e) + (2 * a) + (3 * r) kelimesi gibi arttıkça her karakter int ayrıştırma dizini ile çarpmaktır. oynamak için bir int değeri. yukarıdaki ilk hash fonksiyonu "burada" ve "duymak" ile çarpışır, ancak yine de bazı eşsiz değerler verir. Aşağıdaki karakter "burada" ve "duymak" ile çarpışmaz, çünkü her karakteri arttıkça indeksle çarparım.

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;
}

İşte oluşturduğum bir karma tablo için kullandığım basit bir karma işlevi. Temelde bir metin dosyası almak ve her kelimeyi alfabetik sırayı temsil eden bir dizinde saklamak içindir.

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

Bunun temel olarak yaptığı şey, ilk harflerine göre sözcüklerin özetlenmesidir. Yani, 'a' ile başlayan kelime 0 hash anahtarını alır, 'b' 1 ve benzerlerini alır ve 'z' 25 olur. Sayılar ve semboller 26 hash anahtarına sahip olur. ; Belirli bir kelimenin hash tablosunda, alfabetik sıraya göre dizine ekleneceği yeri kolayca ve hızlı bir şekilde hesaplayabilirsiniz, şuna benzer: Kod burada bulunabilir: https://github.com/abhijitcpatil/general

Aşağıdaki metni girdi olarak vermek: Atticus bir gün Jem'e, “Arka bahçedeki teneke kutulara ateş etmeyi tercih ederim, ama kuşların peşinden gideceğini biliyorum. Onlara vurabilirsen, istediğin tüm mavi alakargaları vur ama alaycı kuşu öldürmenin günah olduğunu unutma. ” Atticus'un bir şeyler yapmanın günah olduğunu söylediğini duyduğum tek zamandı ve Bayan Maudie'den bunu sordum. “Baban haklı,” dedi. “Alaycı kuşlar müzik dinlemekten başka bir şey yapmıyorlar. İnsanların bahçelerini yemiyorlar, mısır beşiklerinde yuva yapmıyorlar, tek bir şey yapmıyorlar ama kalplerini bizim için söylüyorlar. Bu yüzden alaycı kuşu öldürmek günahtır.

Bu çıktı:

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

Bu herhangi bir çarpışmayı önleyecek ve biz de hesaplamalarda kaymayı kullanana kadar hızlı olacaktır.

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