यह प्रतियोगिता समाप्त हो गई है।

पुलिस चुनौती में कोई शेष जवाब नहीं है।

क्रिप्टोग्राफिक हैश गोल्फ का साथी धागा

एक चेतावनी के रूप में, यहाँ मुख्य चुनौती से लुटेरों के लिए नियम हैं:

कार्य

दो संदेश: धागा 'लुटेरों में निम्नलिखित पोस्ट करके प्रस्तुतियाँ' पुलिस के किसी भी क्रैक एम और एन में मैं ऐसा है कि एच (एम) = एच (एन) और एम ≠ एन ।

स्कोरिंग

प्रत्येक पुलिस सबमिशन को क्रैक करने से आपको एक अंक मिलता है। सबसे अधिक अंक के साथ डाकू जीतता है।

एक टाई के मामले में, सबसे लंबे समय तक सबमिशन जीत को क्रैक करने वाला बंधे हुए डाकू।

अतिरिक्त नियम

प्रत्येक पुलिस सबमिशन केवल एक बार क्रैक किया जा सकता है।

यदि एक पुलिस सबमिशन कार्यान्वयन-परिभाषित या अपरिभाषित व्यवहार पर निर्भर करता है, तो आपको केवल एक दरार ढूंढनी होगी जो आपकी मशीन पर काम करती है (पूरी तरह से)।

प्रत्येक दरार लुटेरों के धागे में एक अलग उत्तर से संबंधित है।

अमान्य क्रैकिंग प्रयास पोस्ट करने से आप उस विशेष सबमिट को 30 मिनट के लिए क्रैक कर सकते हैं।

आप अपनी खुद की सबमिशन क्रैक नहीं कर सकते हैं।

उदाहरण
Python 2.7, 22 बाइट्स user8675309 द्वारा
1
तथा
18

लीडरबोर्ड

eBusiness: 3 दरारें, 393 बाइट्स
मार्टिन ब्यूटनर: 3 दरारें, 299 बाइट्स
jimmy23013: 3 दरारें, 161 बाइट्स
Sp3000: 3 दरारें, 44 बाइट्स
tucuxi: 2 दरारें, 239 बाइट्स
Vi: 2 दरारें, 87 बाइट्स
feersum: 1 दरार, 216 बाइट्स
गणितमदन: 1 दरार, 139 बाइट्स
स्क्वीमिश ऑसफ्रीज: 1 दरार, 134 बाइट्स

— डेनिस
स्रोत

5

सी, 122 बाइट्स - द्वारा: श्री लामा

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

दोनों तार हैश करने के लिए bb66000000000000d698000000000000

जैसे "सी, 128 बाइट्स - बाय: स्क्विश ओस्सिफ्रेज" उच्चतर ऑर्डर बिट्स कभी भी निचले ऑर्डर बिट्स को प्रभावित नहीं करते हैं, इसका फायदा उठाया जा सकता है।

कोड

विजुअल C ++, " असुरक्षित " स्ट्रिंग ऑपरेशन का उपयोग करता है

#include "stdafx.h"
#include <string>
#include <iostream>
#include <fstream>

long long x, y;

//Original hash function (not used for cracking).
void h(char inp[]){
    long long c;
    int index = 0;
    int len = strlen(inp);
    x = 0;
    y = 0;
    long long p = 0;
    for (c = 9; c ; c = (index<len?inp[index++]:-1) + 1) {
        for (++p; c--;) {
            x = x*'[3QQ' + p;
            y ^= c*x;
            y ^= x ^= y;
        }
    }
    printf("%016llx%016llx\n", x, y);
}

//Partial hash, takes a string and a starting point in the stream.
//The byte 0x08 must be prepended to a string in order to produce a full legal hash.
void hp(char inp[],long long p){
    long long c;
    int index = 0;
    int len = strlen(inp);
    x = 0;
    y = 0;
    for (index = 0; index<len; index++) {
        c = inp[index] + 1;
        for (++p; c--;) {
            x = x*'[3QQ' + p;
            y ^= c*x;
            y ^= x ^= y;
        }
    }
}

//Reverse partial hash, backtracks the inner state.
void hprev(char inp[], long long p){
    long long c;
    long long clim;
    int index = 0;
    int len = strlen(inp);
    p += len + 1;
    x = 0;
    y = 0;
    for (index = len-1; index>=0; index--) {
        clim = inp[index] + 1;
        c = 0;
        for (--p; c<clim;c++) {
            y ^= x;
            x ^= y;
            y ^= c*x;
            x -= p;
            x = x * 17372755581419296689;
            //The multiplicative inverse of 1530089809 mod 2^64.
        }
    }
}
const int rows = 163840;
const int maprows = 524288;

//Store for intermediate input strings, row 0 contains 64 columns with 3-char strings,
//row 1 contain 32 columns with 6-char strings and so forth, the final strings will
//contain one string from each column, in order.
char store[7][rows][512];

//Storage for a hashmap, used for matching n strings with n string in O(n) time.
char map[maprows][512];

int _tmain(int argc, _TCHAR* argv[])
{
    char alpha[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int row;
    int col;
    int layer;
    int a=0, b=0, c=0;
    int colzero;
    //Produce some starting strings.
    for (row = 0; row < rows; row++){
        //All column 0 strings begin with 0x08 in order to imitate the hash.
        store[0][row][0] = 8;
        colzero = 1;
        for (col = 0; col < 64; col++){
            store[0][row][col * 8 + colzero] = alpha[a];
            store[0][row][col * 8 + colzero + 1] = alpha[b];
            store[0][row][col * 8 + colzero + 2] = alpha[c];
            store[0][row][col * 8 + colzero + 3] = 0;
            colzero = 0;
        }
        a++;
        if (a >= 52){
            b++;
            a = 0;
            if (b >= 52){
                c++;
                b = 0;
            }
        }
    }
    //Layer for layer, column for column, build strings that preserve successively
    //more zero bits. Forward calculated partial hashes are matched with backwards
    //calculated partial hashes.
    for (layer = 1; layer < 7; layer++){
        int slayer = layer - 1;
        int swidth = 1 << (slayer + 3);
        int width = 1 << (layer + 3);
        int slen = 3 << slayer;
        int len = 3 << layer;
        int colnum;
        int layershift=slayer*8;
        for (col = 0,colnum=0; col < 512; col+=width,colnum++){
            printf("Layer: %i, column: %i\n",layer,colnum);
            memset(map, 0, sizeof map);
            int col2 = col + swidth;
            for (row = 0; row < rows; row++){
                hprev(store[slayer][row] + col2, 1 + slen*(1 + colnum * 2));
                x = (x >> layershift) & 255;
                y = (y >> layershift) & 255;
                int index = (x << 3) | (y << 11);
                for (a = 0; a < 8; a++){
                    if (map[index + a][0] == 0){
                        strcpy_s(map[index + a], store[slayer][row] + col2);
                        break;
                    }
                }
            }
            int destrow = 0;
            for (row = 0; row < rows && destrow < rows; row++){
                hp(store[slayer][row] + col, !!colnum + slen*(colnum * 2));
                x = (x >> layershift) & 255;
                y = (y >> layershift) & 255;
                int index = (x << 3) | (y << 11);
                for (a = 0; a < 8 && destrow < rows; a++){
                    if (map[index + a][0]){
                        strcpy(store[layer][destrow] + col, store[slayer][row] + col);
                        strcat(store[layer][destrow] + col, map[index + a]);
                        destrow++;
                    }
                }
            }
        }
    }
    memset(map, 0, sizeof map);
    char temp[1000];
    std::ofstream myfile;
    myfile.open("hashout.txt");
    for (row = 0; row < rows; row++){
        hp(store[6][row], 0);
        sprintf(temp, "%016llx%016llx", x, y);
        myfile << store[6][row] <<" " << temp << "\n";
    }
    myfile << "\n";
    //The final hash set has 96 of 128 output bits set to 0, I could have gone all
    //the way, but this is enough to find a collision via the birthday paradox.
    for (row = 0; row < rows; row++){
        hp(store[6][row], 0);
        long long xc = x;
        long long yc = y;
        int pos = (xc >> 45 | ((yc >> 48) & 7)) & (maprows-1);
        while (map[pos][0]!=0){
            hp(map[pos], 0);
            if (x == xc && y == yc){
                myfile << store[6][row] << "\n" << map[pos] << "\n";
                sprintf(temp,"%016llx%016llx", x, y);
                myfile << temp << "\n\n";
            }
            pos = (pos + 1) % maprows;
        }
        strcpy_s(map[pos], store[6][row]);
    }
    myfile.close();
    printf("done");
    getchar();
    return 0;
}

— aaaaaaaaaaaa
स्रोत

बहुत बढ़िया! मैं वास्तव में एक अजीब तरह से चापलूसी कर रहा हूँ! : D

— श्री ललाम

इसके अलावा, मेरी अपनी व्यक्तिगत शिक्षा के लिए, जब आप कहते हैं कि उच्चतर ऑर्डर बिट्स कभी भी निचले लोगों को प्रभावित नहीं करते हैं, तो आपका क्या मतलब है? इनपुट स्ट्रिंग के उच्च क्रम बिट्स, या हैश राज्य के?

— श्री ललाम

@ Mr.Llama हैश राज्य में, x और y के ऊपरी बिट्स कभी भी निचले बिट्स को प्रभावित नहीं करेंगे, इसलिए उदाहरण के लिए यदि आप गणना के दौरान मध्य बिट्स पर फ्लिप करते हैं तो हैश का निचला हिस्सा अभी भी सही निकलेगा। यह मुझे सब कुछ लेकिन हैश राज्य के सबसे कम बिट्स को अनदेखा करना शुरू कर देता है, फिर जब मेरे पास पूर्ण नियंत्रण होता है तो मैं बिट्स की अगली परत पर आगे बढ़ता हूं, और इसके बाद।

— आआआआआआआआआ आआआआआ

ठंडा! स्पष्टीकरण के लिए धन्यवाद!

— श्री ललाम

लुटेरों की चुनौती पर जीत की बधाई!

— डेनिस

12

पायथन, Sp3000 द्वारा 109 बाइट्स

ध्यान दें कि मार्टिन पहले फटा था, इसलिए मुझे यकीन नहीं है कि अगर यह हकदार है। दूसरी ओर, मैंने एक साधारण टक्कर के बजाय प्रिमिज अटैक किया - एक बहुत मजबूत परिणाम। इसका मतलब है कि आप इसे एक मनमाना हैश मान दे सकते हैं, और यह एक इनपुट का निर्माण करेगा जो कि हैश मान उत्पन्न करता है।

M = 2**128

# The hash to crack.
def jenkins(n):
    h = 42
    while n:
        h += n & (M - 1)
        n >>= 128
        h *= 1025
        h ^= h >> 6
        h %= M

    h *= 9
    h ^= h >> 11
    h *= 32769

    return h % M

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)

def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('modular inverse does not exist')
    else:
        return x % m

def invxorshift(h, s):
    r = h >> s
    while r:
        h ^= r
        r >>= s
    return h

def moddiv(a, b):
    return (a * modinv(b, M)) % M

def jenkins_crack(h):
    h = moddiv(h, 32769)
    h = invxorshift(h, 11)
    h = moddiv(h, 9)
    h = invxorshift(h, 6)
    h = moddiv(h, 1025)
    h -= 42
    return h

और यह दिखाने के लिए कि यह काम करता है:

>>> from crack import *
>>> n = 2**128 + 1337
>>> h = jenkins(n)
>>> n2 = jenkins_crack(h)
>>> h2 = jenkins(n2)
>>> n != n2
True
>>> h == h2
True

और एक विशेष संख्या देने के लिए जो टकराते हैं:

N: 2**128
M: 43617

— orlp
स्रोत

3

सैंडबॉक्स में मेरा प्रारंभिक प्रस्ताव टकराव, प्रिमेज और (थोड़ा ओवरसाइप्लाइजिंग चीजों) लंबाई विस्तार हमलों के लिए अंक प्रदान करता है, लेकिन मैंने स्कोरिंग को सरल रखने का फैसला किया। जब मैंने उन हिस्सों को संपादित किया, तो यह तथ्य कि हर सबमिशन केवल एक बार क्रैक हो सकता है (जो कि आमतौर पर पुलिस और लुटेरे काम करते हैं) किसी तरह खो गए। आपके जवाब को देखकर मुझे लगता है कि काश मैंने पहले हमले किए होते ...

— डेनिस

9

पायथन, Sp3000 द्वारा 109 बाइट्स

340282366920938463463374607431768211414

तथा

113982837842983129870077688367927159293402923522160868689804433865221255200726

दोनों उपज

132946164914354994014709093261515948032

एल्गोरिथ्म इनपुट को 128 बिट्स के विखंडू में विभाजित करता है, और 42अंत में कुछ अतिरिक्त हैशिंग करने से पहले, बार-बार प्रत्येक चंक के साथ हैश (सीडेड ) को संशोधित करता है । टकराव खोजने के लिए, हमारा लक्ष्य दो संख्याओं को खोजना है जो प्रत्येक चंक पर निम्नलिखित छद्म कोड चलाने के बाद समान परिणाम देते हैं:

hash += chunk
hash += (hash << 10)
hash ^= (hash >> 6)
hash %= 2**128

चूंकि हैश को मॉड 2 ¹²⁸ लिया जाता है, हम उन संख्याओं की तलाश करना चाहते हैं जो इस बिट रेंज के बाहर सभी दिलचस्प सामान को स्थानांतरित करते हैं। लेकिन हैश को वरीयता दी जाती है 42ताकि उसके साथ कुछ महत्वपूर्ण-महत्वपूर्ण बिट्स शुरू हो सकें:

000000000000000000000000 ... 000000000000000000101010

मेरा विचार उन चूतड़ों से छुटकारा पाना था, जब पहली बार चोदना था। तो चलिए कोशिश करते हैं 2 ¹²⁸ -42:

           000000000000000000000000 ... 000000000000000000101010     hash = 42
           111111111111111111111111 ... 111111111111111111010110     chunk = 2**128 - 42
          1000000000000000000000000 ... 000000000000000000000000     hash += chunk
10000000001000000000000000000000000 ... 000000000000000000000000     hash += hash << 10
10000010001000001000000000000000000 ... 000000000000000000000000     hash ^= hash >> 6
           000001000000000000000000 ... 000000000000000000000000     hash %= 2**128

यह काफी सरल है तो आइए इसे दो संख्याओं में से एक के रूप में उपयोग करने का प्रयास करें। (वास्तव में, मेरे द्वारा उपयोग की जाने वाली टक्कर की पहली संख्या 2 ¹²⁸ -42 है।

अब हम उसी परिणाम के साथ दूसरी संख्या कैसे खोज सकते हैं? खैर एक चलना के बाद हैश 42कोई और नहीं है , लेकिन 2**122जैसा कि हमने अभी दिखाया है। अब हमारे इनपुट नंबर में एक दूसरा हिस्सा जोड़कर, हम एक और पुनरावृत्ति चला सकते हैं। हम इस एक के रूप में एक ही तर्क द्वारा दूसरा हिस्सा चुन सकते हैं, यानी हम 2 ¹²⁸ -2 ¹²² चाहते हैं । तब के बाद मध्यवर्ती परिणाम hash += chunkसमान होगा और हम अंत में उसी परिणाम के साथ समाप्त होते हैं।

तो हम टकराव की दो संख्याओं की गणना कर सकते हैं:

>>> 2**128-42
340282366920938463463374607431768211414L
>>> 2**128-42 + ((2**128-2**122)<<128)
113982837842983129870077688367927159293402923522160868689804433865221255200726L

हम इस तरह के कई और टकराव आसानी से उत्पन्न कर सकते हैं।

— मार्टिन एंडर
स्रोत

मैं यह भी फटा था - लगभग पूरा किया। क्या यह पश्चिम की प्रतियोगिता में सबसे तेज़ बंदूक है या क्या मुझे इसे पोस्ट करने के लिए अभी भी अंक मिल सकते हैं?

— orlp

@orlp आम तौर पर केवल पहले डाकू को एक बिंदु मिलता है। अन्यथा, लोगों को केवल लाखों अतिरिक्त दरारें उत्पन्न हो सकती हैं, जब पहली दरार पोस्ट की गई थी।

— मार्टिन एंडर

1

लंगड़ा = / सोचो मैं इस चुनौती को करना बंद कर दूंगा। मैं दूसरों के खिलाफ रेसिंग का आनंद नहीं लेता - मैं सिर्फ पहेली करना चाहता हूं। क्या पहली बार प्रति व्यक्ति केवल 1 दरार के साथ, दरारें के लिए कुछ समय खिड़की नहीं हो सकती है?

— orlp

@orlp सैंडबॉक्स में मूल संस्करण में पुलिस को क्रैक करने के तीन अलग-अलग तरीके थे, और तीनों को स्वतंत्र रूप से पोस्ट किया जा सकता था। मुझे लगता है कि यह किसी बिंदु पर जांच करने के लिए एक दिलचस्प मॉडल है। लेकिन अभी तक पिछले CnR में कई दरारें देने की अनुमति हमेशा चुनौती को तोड़ देती थी, जितना कि यह बेहतर होता।

— मार्टिन एंडर

1

टक्कर के बजाय

— प्रिमेज

8

मैथेमेटिका, लीजनमैमल 978 द्वारा 89 बाइट्स

तथा

दोनों उपज 0।

इस पुलिस का सिद्धांत एक "यादृच्छिक" बाइनरी 1-डी सेलुलर ऑटोमेटन को "यादृच्छिक" प्रारंभिक स्थिति से "यादृच्छिक" संख्याओं के लिए विकसित करना है, और फिर पूर्णांक के रूप में परिणाम की पहली 128 कोशिकाओं की व्याख्या करना है।

समस्या यह है कि नियम केवल द्वारा निर्धारित किया जाता है Mod[#^2,256], जैसे कि 16 में से कोई भी नियम देता है 0, जो कि तुच्छ नियम है जहां सभी कोशिकाएं हमेशा शून्य होती हैं। यदि इनपुट 99 से विभाज्य नहीं है, तो हम कम से कम 1 चरण विकसित करेंगे, इसलिए आउटपुट हमेशा शून्य है। इसलिए जो भी दो गुणक 99 के गुणक नहीं हैं वे निश्चित रूप से टकराते हैं। हालाँकि, इनपुट 0 भी 0 देता है (नियम का उपयोग नहीं करने के बावजूद), क्योंकि प्रारंभिक स्थिति केवल इनपुट का द्विआधारी प्रतिनिधित्व है (जो इस मामले में सभी शून्य है)।

एक तरफ के रूप में, हम अन्य टकराव पा सकते हैं जो नियम से पूरी तरह से स्वतंत्र हैं। जैसा कि ऊपर उल्लेख किया गया है, 99 में से कई का मतलब है कि सेलुलर ऑटोमेटन बिल्कुल भी विकसित नहीं हुआ है, इसलिए इसका परिणाम प्रारंभिक स्थिति का केवल पहला (सबसे महत्वपूर्ण) 128 बिट्स है ... जो कि केवल इनपुट नंबर है। इसलिए यदि हम दो गुणकों को लेते हैं जो पहले 128 बिट्स (शून्य के साथ दाईं ओर गद्देदार) में भिन्न नहीं होते हैं, तो हमें एक टक्कर भी मिलती है। इस का सबसे सरल उदाहरण है M = 99, N = 99*2 = 198।

— मार्टिन एंडर
स्रोत

8

जे, 39 बाइट्स

पहली संख्या है:

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000

यानी 1000000064 बार दोहराया गया। दूसरा नंबर है, प्लस वन यानी

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000001

दोनों उपज

322124197561777885386414076216564234267

व्याख्या

के साथ शुरू करते हैं x := H 10000000 = 146018215378200688979555343618839610915, और y := 2^128। बल्कि खोजने से a, bहै कि इस तरह a == b mod y, हम के लिए गौर करेंगे a, bऐसी है कि x^a == x^b mod y, एल्गोरिथ्म में बिजली टावरों का इस्तेमाल कर रही।

लेकिन कुछ kऐसे भी होने चाहिए x^k == 1 mod y, जो कि x, yनकल हैं, और इसके लिए kहमारे पास होना चाहिए a == b mod k। तो हम 1 मॉड का असतत लघुगणक पा सकते हैं y, और पहले चरण के लिए

x ^ (k = 85070591730234615865843651857942052864) == 1 mod 2^128

इसलिए अब हम a, bऐसे दो नंबर ढूंढना चाहते हैं a == b mod k। ऐसा करने के लिए, हम yहोना चाहते हैं kऔर फिर से a, bऐसा खोजने की कोशिश करते हैं x^a == x^b mod y। उसी तर्क का उपयोग करते हुए, हम असतत लघुगणक को फिर से लेते हैं और प्राप्त करते हैं

x ^ (k = 21267647932558653966460912964485513216) == 1 mod 85070591730234615865843651857942052864

हम इसे तब तक दोहराते हैं जब तक कि हम एक छोटे से न मिल जाएं y, जिस बिंदु पर दो संख्याओं का पता लगाना तुच्छ है, जो एक ही चीज़ के लिए हैश है y। 63 पुनरावृत्तियों के बाद y = 4, जिस बिंदु पर मूल रूप से कोई भी दो नंबर काम करते हैं।

असतत लॉग चेन जेनरेट करने के लिए यहां मैथमेटिका कोड दिया गया है:

k = 0; x = 146018215378200688979555343618839610915; y = 2^128; While[y > 10, y = MultiplicativeOrder[x, y]; k++; Print[k, " ", y]];

यह निम्न आउटपुट देता है ।

— Sp3000
स्रोत

थोड़ा कम संस्करण यह है कि यदि पहले कुछ सैकड़ों अंक समान हैं, तो यह असंभव है कि शेष इनपुट किसी भी तरह से कुछ भी हो। वास्तव में इसे तोड़ने के लिए गणित करना अधिक कठिन है।

— आआआआआआआआआ आआआआ

@eBusiness यह सच है। यह पता चला कि यह यहाँ ज्यादा मायने नहीं रखता था, लेकिन शुरू में मुझे 2^(2^30)सीमा से अधिक चिंता थी , इसलिए जाँच की।

— Sp3000

दरअसल, मुझे संदेह है कि स्ट्रिंग को बनाना असंभव हो सकता है जहां 512 वें अंक से परे कुछ भी हो। आप सबसे खराब स्थिति का उत्पादन करने में कामयाब रहे। सबसे बड़ी दरार आंतरिक अग्रणी शून्य का लाभ उठाने के लिए होनी चाहिए: "100000001" "1000000001"।

— आआआआआआआआआआ आआआआ

7

पायथ, फ्राइअमईएग्गमैन द्वारा 8 बाइट्स

99999999999999999999999999

तथा

99999999999999999999999998

इसके लिए फ़्लोटिंग पॉइंट सटीक पर्याप्त बड़ा नहीं है।

— Sp3000
स्रोत

मुझे वास्तव में इसके लिए अलग-अलग परिणाम मिल रहे हैं, लेकिन मुझे विश्वास है कि यह रणनीति वैसे भी काम करेगी, इसलिए मैं इसे दरार के रूप में चिह्नित करूंगा। तेजी से काम: पी

— फ्रैमएग्मैन

हम्म अजीब। मैं 437409784163148दोनों के लिए मिलता हूं । मुझे आश्चर्य है कि अंतर क्यों है ...

— Sp3000

आप शायद अजगर 3.5 सही उपयोग कर रहे हैं? मैं अभी तक अद्यतन नहीं किया है, अभी भी 3.4 पर शायद यह है?

— FryAmTheEggman

@FryAmTheEggman मैं ऑनलाइन दुभाषिया का उपयोग कर रहा हूँ, वास्तव में ...

— Sp3000

वास्तव में हाँ, मुझे मिलता है 437409784163148और 37409784163148इसलिए मुझे लगता है कि यह किसी कारण से अंतिम अंक खो गया है, लेकिन 99 ... 997 999 ... 98 के समान उत्तर देता है।

— FryAmTheEggman

6

CJam, 44 बाइट्स, उपयोगकर्ता jimmy23013

संख्याएं पोस्ट करने के लिए बहुत बड़ी हैं, इसलिए यहां वे पास्टबिन पर हैं: संख्या 1 , संख्या 2 ।

पहला नंबर 600^2 = 360000वालों का है। निम्नलिखित परिवर्तनों को छोड़कर दूसरी संख्या समान है:

Positions to change to "2": 605, 1811, 3001, 6603
Positions to change to "4": 1805, 3003, 57348, 208895
Positions to change to "5": 602, 1201, 2405, 3004
Positions to change to "6": 1203, 1802
Positions to change to "7": 12, 609, 5401, 7200
Positions to change to "8": 1, 2, 4, 6, 600, 1200, 1808, 2400, 3600, 4803

दोनों को हैश 271088937720654725553339294593617693056।

व्याख्या

आइए कोड के पहले भाग पर एक नज़र डालें:

lW%                e#  Read input number as string, and reverse
600/               e#  Split every 600 digits, forming a 2D array
_z                 e#  Duplicate and zip, swapping rows and columns
{           }%     e#  For both arrays...
 JfbDb             e#  Find sum of S[i][j]*13^i*19^j, where S are the character values
                   e#  and the indices are from right to left, starting at 0.
      GK#          e#  Take modulo 16^20

         ...  ...  e#  (Rest of code irrelevant)

इसलिए यदि हम दो इनपुट नंबर पा सकते हैं ताकि प्रारंभिक 600-वाइड एरे और ज़िप्ड ऐरे दोनों के लिए S[i][j]*13^i*19^jएक ही मॉडुलो एक ही 16^20हो।

चीजों को थोड़ा आसान बनाने के लिए, हम केवल 600^2 = 360000-डिजिट इनपुट संख्याओं पर विचार करेंगे , ताकि 600-वाइड सरणी अंकों के 600 से 600 वर्ग के बराबर हो। यह चीजों को कल्पना करना आसान बनाता है, और तब से मान्य है 10^360000 ~ 2^(2^20.19) < 2^(2^30)। आगे भी चीजों को सरल बनाने के लिए, हम केवल ऐसे इनपुट स्ट्रिंग्स पर विचार करेंगे जिनके अंक वर्ग मुख्य विकर्ण के साथ सममित है, ताकि मूल सरणी और ज़िपित सरणी समान हो। यह हमें शुरुआती स्ट्रिंग रिवर्सल और राइट-टू-लेफ्ट इंडेक्स नंबरिंग को अनदेखा करने की भी अनुमति देता है, जो एक दूसरे को रद्द करते हैं।

हमें शुरू करने के लिए, हम पहले नंबर पर जा 360000सकते हैं। दूसरे नंबर को प्राप्त करने के लिए, हम कुछ अंकों को बदलकर इसे संशोधित करना चाहते हैं, ताकि अंक 16^20वर्ग के समरूपता को संरक्षित करते हुए रकम एक ही मॉड्यूल हो । हम इसे तीनों की सूची प्राप्त करके पूरा करते हैं (i, j, k)ताकि

sum of k*(13^i 19^j + 19^i 13^j) == 0 mod 16^20

कहां 1 <= k <= 8से अंक 1 को बढ़ाने की राशि है (यानी 2 से 9 तक एक अंक में बदलकर - हम 0 को शामिल कर सकते हैं लेकिन हमें इसकी आवश्यकता नहीं थी) और 0 <= i < j < 600सूचकांक जोड़े हैं।

एक बार जब हम है (i, j, k)तीनो, हम से कम अंक बदलने (i, j)और (j, i)करने के लिए 1+kदूसरा नंबर पाने के लिए। ट्रिपल को लालची बैकग्राउंडिंग एल्गोरिथ्म का उपयोग करते हुए पाया गया, और अंक वर्ग के ऊपर दूसरे नंबर के लिए ऐसा दिखता है:

188181811111711 ...
815112111711111 ...
851611111111111 ...
116114118112111 ...
811115111111111 ...
121451111111111 ...
811111111111111 ...
111111111111111 ...
111811111111111 ...
171111111111111 ...
111111111111111 ...
111211111111111 ...
711111111111111 ...
111111111111111 ...
111111111111111 ...

............... .
...............  .
...............   .

उदाहरण के लिए, (i, j, k) = (0, 1, 7)अंकों (0, 1)(स्थिति 600*0 + 1 = 1) और (1, 0)(स्थिति 600*1 + 0 = 600) को बदलने से मेल खाती है 1 + 7 = 8।

यहां पायथन 3 में बैकट्रैकर है, हालांकि निकट निरीक्षण से पता चला है कि हम बहुत भाग्यशाली थे, क्योंकि वास्तव में कोई बैकट्रैकिंग नहीं हुई थी:

n = 16**20
L = [(k *(pow(13,i,n)*pow(19,j,n) + pow(19,i,n)*pow(13,j,n)) % n, i, j, k)
     for i in range(600) for j in range(600) for k in range(1, 9) if i < j]

L.sort(reverse=True)
stack = [(n, 0, [])]

while stack:
    k, index, result = stack.pop()

    if k == 0:
        print(result)
        break

    if index == len(L):
        continue

    stack.append((k, index+1, result)) # Don't include triplet

    if L[index][0] <= k:
        stack.append((k - L[index][0], index+1, result + [L[index][1:]])) # Include

एक बोनस के लिए, यहाँ पायथन 3 में हैश का एक नहीं-तो-कुशल बंदरगाह है। यह बेकार था।

— Sp3000
स्रोत

5

PHP 4.1, इस्माइल मिगुएल द्वारा 66 बाइट्स

$ A=0111129112911291111111111111111111111111 php hash.php 2> /dev/null ; echo
0100038003800381129111111111111111111111
$ A=0111129112911291129111111111111111111111 php hash.php 2> /dev/null ; echo
0100038003800381129111111111111111111111
$ cat hash.php 
<? $a = getenv("A"); for($l=strlen($b.=$a*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

1 से शुरू होने वाले साधारण iterated हैशिंग का उपयोग कर पाया:

$ i=1; while true; do i=$(A=$i php hash.php  2> /dev/null); echo $i; done | head -n 10
0111111111111111111111111111111111111111
0100000000000001129111111111111111111111
0111129111111111111111111111111111111111
0100038000000001129111111111111111111111
0111129112911111111111111111111111111111
0100038003800001129111111111111111111111
0111129112911291111111111111111111111111
0100038003800381129111111111111111111111
0111129112911291129111111111111111111111
0100038003800381129111111111111111111111

— Vi।
स्रोत

हाँ, यह एक दरार है। वहाँ पहुँचने में कितना समय लगा?

— इस्माइल मिगुएल

दूसरी कोशिश। पहली कोशिश पहले 100 हैश के मूल्यों को देख रही थी, दूसरी कोशिश हैश चेन (यानी hash(hash(hash(...(hash(1)...)))) बना रही थी । पहली श्रृंखला लगभग तुरंत एक लूप में परिवर्तित हो गई। मुझे अपने मल्टीथ्रेडेड हैश क्रैकर को लाने की भी आवश्यकता नहीं थी।

— वि।

अनुवाद: बहुत कमजोर हैश?

— इस्माइल मिगुएल

यं

— । Vi

5

पायथन 3 (216) Sp3000 द्वारा

मेरे संदेश हैं

5012053369354645637214643587103597313576086380250249302980438772005248488380915054746146050001036696049972235875591571028140916001206596142280971107479334216535925703480968283657357930602076844092875640359192729378384507238123245417656548512647301639542279794868512420586823155070914644206130805893968511673770843170450832829657206145931885656157628306896903719624729809643572222159364893644113710867223921580178741177106141068298067479650611992859787419779579962211254029169589775046869542029842374359998053713002047081002506346875804341770199884355810931652447801492691887376948615365487982834690942054717077615539311699691010938426302886867891090301248321702485904291177813145565144089044261424329155436660979948932491709511914065619715728353376578192548334780893602675684085757434059540582004872746967999949306946618036846307799677491651967418565531672392468089533111553281620101129322575737949904022139471688252420467041529301533363008476437812216585923822571793353317799365005036029476865
5012053369354645637214643587103103086948976188724715498910865650846170784131001427390927276355140411160919276493388206817700368694224128444524223814513348177926532982330730066315320819293979046126543806115318009892783577432467861426768883700930779409885418980853424256180864755881414774514084197887594253752179391098292488771920695965135791582218083012144604515253506370334133858904659263953147111654656123599460222236152128559750436960308887683690915261431659087040402402092795259541564130228515353133867041828417398395559815392177084002004583988047406317670433664624642858480970640416500369367395538257341309676777745698712896295462462064271676447460293684100001583256400774270688958051470568447233589146620275159126426142305307007744396679875427883384557759778766330566230012377845843842097372663092379922300568052486301863154557664156185573021849420011058607321977550938866119133331529852821217331665195832442542012455132139770813510559894254061471149750738447764616026512400623344132554752

मैंने उन्हें उत्पन्न करने के लिए इस पायथन 2 कोड का उपयोग किया:

a,b = 14460445391122031029,16815296360833931837 #http://www.numberempire.com/numberfactorizer.php
pr = ~-a * ~-b

m0 = reduce(long.__or__, [long(b) << 26*i for i,b in enumerate(bin(pr)[2:])])
m1 = 1 << 26*i-1
m0 |= m1

#print m0, m1
print f(m0), f(m1)

बड़ा मापांक दो प्राइमों का एक उत्पाद था aऔर b। मुझे लगता है कि यह आशा थी कि यह सेमीप्राइम कारक के लिए हमारे लिए एनपी-असंभव होगा, लेकिन मुझे लगता है कि 128 बिट बहुत छोटा है क्योंकि कुछ वेबपेज ने मुझे तुरंत जवाब दिया।

गुणक समूह मोडुलो abमें आदेश होगा (a - 1) (b - 1) जिसका अर्थ है कि यदि हम उस शक्ति को कोई संख्या बढ़ाते हैं तो इसका परिणाम 0 या (आमतौर पर) 1 होगा। इसलिए मैंने 1 बिट्स को उन स्थानों पर रखा है, जिसके परिणामस्वरूप 2 ^{(ए -1) (बी -1)} हैश में गुणा किया जा रहा है। तब दूसरा संदेश मूल रूप से 0 है, लेकिन मैंने लंबाई को समान बनाने के लिए प्रत्येक संख्या में एक दूसरे को सेट किया।

मुझे लगता है कि यह अधिक कष्टप्रद रहा होगा कि सभी अपराधों का उपयोग करने के बाद ही हर बिट पर हैश स्क्वर्ट किया गया। तब उनके लिए मनमाने प्रतिपादक बनाना इतना सरल नहीं था।

— feersum
स्रोत

अच्छा काम :) हाँ, मेरे मन में जो भेद्यता थी, वह मूल रूप से अर्धविराम कोड में दिखाई दे रही है, और मुझे एहसास हुआ कि गणितज्ञ इसे तुरंत कारक बना सकते हैं।

— Sp3000

+1 आपका कोड पढ़ना मुश्किल है, लेकिन अन्यथा एक अच्छा और शिक्षाप्रद दरार।

— आआआआआआआआआ आआआआआ

5

सी, 128 बाइट्स - बाय: स्क्विश ओस्सिफ्रेज

निम्नलिखित दो तार दोनों सभी शून्य को हैश करते हैं:

dddl|lddH4|@dhxdxXdh0TXPdhhdx(dTxtlpdd@4Lhd|hdDpdhDdXLdXP4(PdddL|ldXdD(lddX4|0hddp4|ddP4Lxdp0dP@dhpTxPdhXdXxdhHDxHdllLttdhPT8pd(pT8Pdd0TL8dlLLTtddPtl8dP@DPPdhhDxhd804(pdh0Txpd@DDpLdhL4xtdXXdHXdd04lXht40dlddh4|@ddPTLXdhhDXHhtPH40dh0t8pd(pt80dhPtX0dhLtXtdhLT8thlLplTdhpt80dh0txpdhHDX(hdX8txdhhdxHdp|d@tdhlTx4dlptdxdh0T8PdT@t|Hdd@tL(ht(8DhdhHD8(hpHHP8dhLtXtdX8dhxdhpt8Pd@(D@Hdd@tLhdtxTLPdd0tlxhhL8X|dd8t|0dT04|Xddxt|phxxxhhdhpt8PhhxX8hdhlTX4dd4l||dd@TLHdXlTHtdhHd8hdX0THPdh(D8(d8xdh8dhp4xPd0HDp(dhl4xTdxlthtdhlTx4d8lT(TdhhdXHdphdP(dhp4x0d0Xd0XddTl||d88DH8dhhdxhdx|tHDdhLT8Thll0lTddPTlXdxXd(xdd0Tlxdhp480dhp4x0dd|LltdhPt80dtll|dddPTlXdxXd(xdd0Tlxdhp480dhp4x0dd|LltdhPt80dtll|dddP4Lxd|ptT8dhddxldH|4xDdhp4x0dDdl|LdhtD8|hhHx88ddpTL8hhphx@dhtd8|dphDP(dh0tx0hhDHx4dhpt8Pd@(D@HddLLLDhh|xxldhl4xTdhL4x4dhPt8Pd(HDx(dh(D8Hd4PT|8ddH4|@hh4H8ddhxd8XdDP4lxdhHd8hdl04d8ddXT|phdh8Thdd@TlHdhXdxxdllL44dD@4lHdhxdxXhd8XtxddLlLddT@T|(dhxdXXd|P44Xdhpt8pdlHDT0dhL4Xtd@ldpDdddl|LdXP4h0dhltXtdX8d(Xdh|tXdhhLXX|dhxd8XdP@D0PdhXDxXhtpHtPdd84|pddtl||dh(dx(d88Dh8ddx4|PhtT0DLdd@tL(hdX8Txdhp480d08d08dlll44d4dLLldhTdX|hh8Xxhdh048pd08d08ddPtL8d4H4l@dhhdxHd|pt4Xddp4lXhp(hPxdh|48DdxhDh(ddLlldd8XdH8dddl|LdLHDT0dhpt8pdlHDT0dh(d8hdTHtl@ddptl8dt84LPdh8dxxdlptD8dd04lxhhH8XxddDl|ldP|D@4ddTl||d|ptT8dh(dXhhd8X48dhPtXpd(8DxXdh@TX@dDP4L8dhpTX0d4@4|hdhHdxHdX8DHxdhPT8PhllplTdh0TXPhlXHLXddp4lXhtHXD(dhP4X0htH8dhdhLTx4hpxHPHdhhd8(dX8DHxdhpt80hhdHxTdlll44d@Hd@(dhhDxhdh0t8Pddh4|@ddh4|@dhptx0dpPD0@ddPtlxdhPT8pdhhdX(htTpDLdd@4L(dLHDtpdhxd8xdt84lPdlpTdxdDPTLXddLLLDdxlThtdlhd4PdXLTh4ddptLxd|@44(dhhd8HdtDLLlddxt|pd|hDd0ddPtLXhl@H|pdhDD8ld8dDhLdhXDXxdDxT|PdhHD8hdp8dpxdhp480d@XD@xddpTLXdHhD8(ddllLDdD|LL4dhpt80d@LdPDdh|4xDdP8dpXddLllddl8d4@dhptXpdd(4|@dhltx4d0Dd@LdhptxphdPHdpdhl4xTdxlthtdhHD8HdTdllldhLtX4dXP4(PdhLTxTd4X4LpddlllDdlpTD8dllltTdL(dtPdhDDxLdhLTx4dhptx0d|0T4Xdhl4xTdHL4XtdhpTXpdLp4dxddHt|@dHL484dhHDXHdHLtxtdhDdXldxL4H4dh|TxDhh8xX(dhLt8td8Lt(TdhHDx(d4DlLlddXT|PdHHD8(dlll44dlP4dxdd@tL(dL@4dhdd0tLxd4X4l0dhhdxhdDlLldddLLlddD04l8ddPtlxd(hd8hdd(T|@hdDp4|ddP4Lxdp0dP@dhptXpd(p4X0dhhd8(d8pT(0dh8d8Xhd(XT(dhddxLd@XD@8dd@tlhd@ld0ddhTD8|hhPH8@ddtl||dH0Tx0ddLlLddhp480dhHdxhd4lL|DdhXD8xdhhDX(dh048pd4Ll|ddddl|LdXP4h0dlll4thhdhxtddP4LXdhXdxXdhpTX0hdXXtxddlLLddx0Th0ddTl||hlhhlHdd|Ll4dHDdXldhhDX(hpxh0HdhDDXLdXDDhLdlhDTpht8Xdxdhpt8phhHXX8dd(t|@dHl4xtddp4LXhxhXH8dhDDxldDXt|PdhTDX|d|0ttxdhdDXLdDLLLddd84|PdT84LpdlhDTphl8hlxdhXD8xdHpt8Pdlhd40ddHT|@dhxdX8dhlT84dh|T8dhlXHLxdhxDxXdT4lL|dlllttd@xd@xdhhDXHhtXXD8dh(d8(d4p4|8dd04lxdxPThpdhHD8Hhdhx4hdhl4xthl|pLDdhltX4dhP4XPdd0Tlxdl@tDhddP4lXd0xD0xdhHD8Hd@8D@xdh0T8Pd0XDpxddPtl8dP@DPPdhhDxhd804(pdd04L8hpxHphdhDdxLdppD0@dd@tl(d88dHXdh0txpdXhDhHdd@Tlhdx8DHXdh0tXPdxxdH8dhPT8Pd484LPdlhD4pdxxdHxdd|Lltdhptx0dhlTx4hp8HPhdhPt8pdt4lL|ddtl||dH0Tx0dhxd8xhl@H|pddLllDhldP||dhdD8ldXLTHTdlhDTpddllLddd04lxhhH8Xxdh|48DdP8d0XddLLldd|@44hdhhd8hd4x4L0dhltXthh4H8Ddh4DX|dD@Tlhdh0tXpd8|T(ddhtDX|dlhdTPdd@tLhdThTl@dh8D8xdT(TL@dd@Tl(d8Hd(hdhXdxxhtHXdhdd0tl8d|HDDPdd8T|PdH04xPdd@Tl(d|@4t(dd(4|@dHp4xpdhpt80dh0txpdhp48phdXxTxdhhDXHhtPH40dh0t8pd(pt80dd8T|pdlxdt@dhp48PdD0TLXdh0t8Pd|lldTdh|t8DhphHp8

ddTl||d4|L|4dhptX0d4dllLddxT|pdxXdH8dlhDtPhlpH|@dd|Lltdhptx0dhlTx4hp8HPhdhPt8pdt4lL|ddtl||dH0Tx0ddLLLDd8tdH|dhDD8LdtxtLpdhxD8Xhd8xtxdhPt8Pd(8DX8dhddxLd0xd08dd0Tlxdxdd(Lddh4|@dXpt(Pdh048pd0xd0xdhhDX(d8p4Hpdh0480d(8DX8dhL4x4d4PT|XddPTLXdPDd@Ldddl|ld(P4X0ddDL|lht88DXdhPtxpd((Dx(dh0tx0dxXd(8dhpT8Pd0xD0XdlhD4pdT0T|8dh04XPht0H40dlhDtpdpHDP(dhlTXtdPHdpHdhXDxXhpPH0pddDl|lhltp|Ldh04x0dtXTL0ddLLLDdLhdtpdhL4xtdHDdXLddxt|0d4X4l0dh(Dxhdx04h0ddllLDd0PD0@dhXDxxhdx848dhDDxldpXDpXdhPt8pdhltxTdd04lxhhH8Xxdh|48DdP8d0XddLLldd|@44hdhhd8hd4x4L0dhltXthh4H8Ddh4DX|dD@Tlhdh0tXpd8|T(ddhtDX|dlhdTPdhlTXtdTX4L0dd@Tlhhh8xXHdhPt80d|XdD@dhp4xphd4Ptldd|LL4dL|ltDdhPTx0d80T(pdhpt8pd|pTtXdhpTX0hhth8Ddhxd8xdphdP(dh8D88dp(DPhdhHD8(htxXdXdh8dXXdXpTH0ddx4|PdpXDPxdhXDXXdxxdhXdhlt8Td@xD@8dhP4XPdhltX4dd@tlHdhXDxxdhPtXPd(8Dxxdh0t8PhdpHd0dh(D8HdX(D(Hdd@tLhht|@4Tdd@4lHdttll|dd0tlXhh|xxldd@TLHdlHdTPdd|LL4dt@T|hddx4|PdlHdtPddTl||d88DH8dlhdTpd40t|xddht|@dpPDP@dhHDxHhxthHDdhddxldxtDH|dhltx4d8Dd(ldd|LLthp0H0Pdhl4x4d|0T4Xdd|ll4dt8tLPdd@4lhd|0TTXddPtLXd(8d8xdhPTxPdHxd8xdhHDX(ddLllddhp48Pd0@d0PdhptxpdX(DhHdd0TlXhtPHTPddh4|@dTDlLldhDDxLhp(hPxdhdD8ldXLTHTddPtLXdTh4L@dhLtxTdlpTd8dhPtXpdhLtX4ddPTlXdxxdhXdhhd8(d404|8dhTd8|dhL4Xtddp4l8d4X4LpdhL4Xtd@ldpDdddl|LdXP4h0dhpTX0htXxDxdhpt8pddLlLddhp4XPhp0H00dh4Dx|dlp4D8dhPtxpd((Dx(dh0tx0dxXd(8dhDDxlhlL0ltdhhDxHd@|d0TdhHdxhdL0tD8dhhD8hhl|pLdddxt|pd|hDd0ddPtLXhl@H|pdhxDXxd8DdhldlhdtphpphppdhpT8PdH8dxXdlhd40dtXtlPdhTd8|dXlthtdhTDX|dx|4HDddxT|pdHDd8ldhL4X4dhP4XpdhtDx|ddXt|Pdh|T8DdHhdxhddLLLDhlxHl8dh0tXPd|(ddPddDL|LdHhdxhdhp4x0dl8dT@ddXT|phdh8Thdh(DXhd0HDP(dddl|lhd(xT(dhXdXxdTxtl0dd|lLtd8|4hddd4l||dXLTh4dd04lxdP8DP8ddxT|0dXXdh8ddP4lxd0@DpPdh8dXxddp4lxdhLt8tdHTdx|dh4Dx|dxLTHtdhhd8hd@DDpldd04LXdXlT(tdhXdXxdhPT8pdh(DXHdP@dp0ddP4LXdXpThPdllL4td((D8(dh0tXpd|(ddpdh(DxhhdL@DDdhHDx(dxL4(tdhLtXtdl@4dHdhxd8xdTh4L@dhXDXXhhdH8Tdd8T|PdH04xPdlllT4hllpLtdhhDXHhxxXhhdhXDxXdPDd@Ldd0TlXdHLtX4ddDL|ldXLT(4dhPtXPdXXd(8dhpt8phdH8thddxT|pd(ptXpddP4LxdLXDT@dhpT80dLptDxddxt|pdP@Dp0dhptx0d|0T4XdlpTdxdxpt(PdhHD8(d4TlL|dhHDx(d@hD@(dd@tl(d88dHXdh(Dx(d4pT|xddPtl8dP@DPPdhhDxhd804(pdhHD8Hhdhx4hddP4lxhdhXt(dhxdX8dp@DppdlllT4dP0dp@dddl|ldH8DXXdllLT4dPXdp8dd@tLHdlPTd8ddtL||d8PtHpddHt|@hd|@d4dh(dX(hdhXT(dhpT80hdHX4(dlpTdxdtDlLlddxT|pd(ptXpddP4LxdLXDT@dhpT80dLptDxddxt|pdP@Dp0dhptx0d|0T4XdlpTdxdxpt(PdhHD8(d4TlL|dhHDx(d@hD@(dddL|lhtph40dhpTxPdlp4dXdhDDxldpxD08dh(dX(dHlTxTdd|ll4d40t|Xdh0480ht@hT@dhptXphdHxT(dh(D8Hd4PT|8dhpt8pd88dhXddDl|LhxdHHtddPtlXd|pt4Xdd0Tl8d0(D0hdhhd8hdppd0@ddPTlXd8P4hpdhlTx4d8dDhLdd@TLhhllplTddXT|0dH|4XDdh|4xDht8XD8ddptl8dH8d88dd|LLTdh(DXhddHt|@hpXhp(dhdDxLdDhT|@dhP4X0dXhDHhdh0T8Pd((dxhdhhDx(hdx8Txddp4LXd8xDH8dhPTXpdlPtD8dh(DxHd@8D@Xdhl48Td00Dp@dhLT8Tdp(d0(dhhd8(d404|8dhhdx(dx0T(pdd|lL4ddXt|Pdd0TlXhxdH(4ddllLDhhLXX|dhXDx8hl8hLxdhpT80dLPtDXdhptX0dPXd0XddP4lxd0@DpPdlptd8dl(dTPdhxDx8d(ptX0dhpT80htxxdXdhhDxhdXltHtddh4|@d@|dPTdhdDXLhpph0Pdhp48Pdt4lL|dh04xpdLpTD8dd@4lhdl8dt@ddhT|@dPxDp8dd04lXd40t|xdd0TLxdTdlLLddpTLXd|pTT8dd04lxhhH8XxdhddxlhddPT|dd04LXdlhd4pdh8d8xhh|8XLdhxd8xd(8d8xdhp48pd(8DX8dhhDXHd4dllLddx4|0d8PTH0ddPtlxd|P44XdlpTdxd(XDXXddpTlxdHltX4dhLTxtd|HDD0

हैश फ़ंक्शन इसलिए बनाया जाता है ताकि उच्च ऑर्डर बिट्स लोअर ऑर्डर बिट्स को कभी भी प्रभावित न करें, इसलिए मैं स्ट्रिंग्स का एक संग्रह उत्पन्न कर सकता हूं जहां सभी xनिचले ऑर्डर बिट्स शून्य हैं, फिर मैं इन स्ट्रिंग्स के संक्षिप्त संयोजन की कोशिश कर सकता हूं जहां कुछ और मिल जाए निचले बिट्स शून्य आदि हैं मुझे पूरा यकीन है कि इसे तोड़ने के और भी तरीके हैं, और ऐसे तरीके भी हैं जो काफी कम स्ट्रिंग्स का उत्पादन करते हैं, लेकिन इस तरह से मैंने बहुत सारे गणित करने से परहेज किया।

— aaaaaaaaaaaa
स्रोत

बहुत बढ़िया! वे दोनों 0x0000000a0000000a0000000a0000000aमेरे सिस्टम पर हैश करते हैं , लेकिन यह अभी भी बहुत आश्चर्यजनक है। ( echo -ne '\x0a' |./hashवही परिणाम भी देता है।)

— r3mainer

1

@squeamishossifrage आपके पास स्ट्रिंग्स में से प्रत्येक के बाद एक रूज न्यूलाइन है, इसके बिना यह सादे जीरो है।

— आआआआआआआआआआ आआआआ

अरे हाँ, मेरी गलती :-)

— r3mainer

4

पायथन 3, 118 बाइट्स

int(H("9"+"0"*400))

तथा

int(H("9"+"0"*4000))

(यह है: 9E400 और 9E4000)

दोनों का उत्पादन

83909358607540647658718900164058931893

कुछ गहराई से खोदने पर ऐसा लगता है कि किसी भी पूर्णांक के बाद के दोहराया गया अंक जैसे कि k> 128 और (k% 4 == 0) उसी हैश को लौटा देगा। उदाहरण के लिए, H("1"+"1"*32*4)और H("1"+"1"*33*4)दोनों हैं 13493430891393332689861502800964084413। हम्म, 128 ...

— tucuxi
स्रोत

4

पायथन द्वारा पाइथन 2, 161 बाइट्स

340282366920938463463374607431768211456 (decimal)
100000000000000000000000000000000 (hexadecimal)

तथा

340282366920938468780317283222139437056 (decimal)
100000000000001203B66F94300000000 (hexadecimal)

दोनों का आउटपुट है:

83F172CC3D050D131F64FD04B8181DC2

संख्याएं 2 ^ 128 और 2 ^ 128 + (3 * 5 * 7 * 11 * 13 * 17) ^ 2 * 19 * 2 ^ 32 हैं।

— jimmy23013
स्रोत

3

SuperJedi224 द्वारा जावा, 299 बाइट्स

Pastebin के लिए M। बाइनरी में, M65535 1एस है, इसके बाद 2 0एस है।

Pastebin के लिए N। बाइनरी में, N21845 1एस है, इसके बाद 174766 0एस है।

दोनों उपज 0।

ध्यान दें कि एल्गोरिथ्म का आधार है i.bitCount()*i.bitLength()+1और अंततः, हम परिणाम को शक्ति के रूप में iलेते हैं और इसे आधुनिक 2 ¹²⁸ लेते हैं । तो विचार सिर्फ दो को खोजने का था iजो चार से विभाज्य हैं, लेकिन जहां पहली अभिव्यक्ति 2 ^{32 देती है} । यह आसानी से 2 ³² -1 फैक्टरिंग और 1 एस की संख्या और संख्या की कुल बिट चौड़ाई के लिए दो कारकों को उठाकर किया गया था ।

संपादित करें: वास्तव में, Mशून्य की पैदावार करने के लिए थोड़ा और अधिक है, लेकिन हम आसानी से अधिक संख्या पा सकते हैं जो 2 ³² -1 के अन्य कारकों का उपयोग करके मेरे स्पष्टीकरण के कारण शून्य पैदा करते हैं जैसे कि अंत में कम से कम 64 शून्य हैं।

— मार्टिन एंडर
स्रोत

3

सी, 134 बाइट्स (बारटेक्स 2 एक्स द्वारा)

तथा

दोनों को हैश

0xa609779942cb9ef1

क्योंकि एल्गोरिथम में केवल अंतिम अंक होता है!

— r3mainer
स्रोत

यह एक मूर्खतापूर्ण गलती थी ...

— barteks2x

3

सी, 87 बाइट्स

$ echo B075343F9832CD60 | ./hash6_ ; echo
fc2e9f02bd284bd1
$ echo 5914BD1B71164C77 | ./hash6_ ; echo
fc2e9f02bd284bd1

मेरी टक्कर ब्रूटफ़ॉर्मर का उपयोग करते हुए मिली।

— Vi।
स्रोत

शायद यह केवल 64-बिट होने के कारण है।

— वि।

अच्छा किया :-) यह कितना समय लगा?

— r3mainer

कार्यक्रम चलाने के बारे में 7 मिनट। अब फिर से माप के साथ शुरू हुआ।

— वि।

1

एक और टक्कर मिली: 473E0B6ED5AF2B92 7EC2BC9B5E9F5645 -> 0000000000000000 0EAC34C8A9F943893525078917 हैश फ़ंक्शन कॉल और real 14m24.970s user 48m42.410sसमय के बाद।

— वि।

3

पाइथन 2, 115 बाइट्स, स्क्विश ओस्फीफ्रेज द्वारा

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

तथा

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

हैश मूल्य का ब्लॉक के आदेश से कोई लेना-देना नहीं था।

— jimmy23013
स्रोत

2

पायथन द्वारा पिथोन 2.x, 139 बाइट्स

H(2)

तथा

H(128)

दोनों लौट आए

16645614427504350476847004633262883518।

— mathmandan
स्रोत

2

सी ++, स्पेलिंगमिस्टेक द्वारा 239 बाइट्स

प्रदान किए गए "मुख्य" कार्यक्रम का उपयोग करते हुए, निम्नलिखित दो इनपुट एक ही हैश का उत्पादन करते हैं:

echo -n "dog" | ./h
481c27f26cba06cf

तथा

echo -n "fog" | ./h
481c27f26cba06cf

इनपुट के पहले 8 बाइट्स संसाधित कभी नहीं कर रहे हैं , कोड में इस बग के कारण:

 for(I i=n;--i;) // and then we use q[i] for this iteration

क्योंकि --iझूठ का मूल्यांकन करते समय i==1, q[0](पहले 8 बाइट्स: Iएक है int64)। लूप की स्थिति को बदलने के साथ for(I i=n;i--;)यह तय हो जाएगा।

— tucuxi
स्रोत

ऐसा लगता है कि इनपुट के पहले 8 बाइट्स को अनदेखा किया गया है।

— वि।

कोड में एक बग की तरह लगता है; फिक्स उपसर्ग के बजाय प्रत्यय चल रहा है।

— tucuxi

1

गैर-बग टकराव भी हैं (मूल प्रश्न पर टिप्पणी देखें)।

— वि।

2

रूबी, 90 बाइट्स, मेगाटॉम द्वारा

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

तथा

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

जो 2 और 11 के बाद 40 शून्य बाइट्स हैं। इसलिए इन दोनों में 41 बाइट्स हैं। प्रत्येक बाइट के लिए हैश मान इनपुट लंबाई से जोड़ा जाता है, और फिर इसे दशमलव में उलट दिया जाता है। के साथ समाप्त होने वाली एक इनपुट लंबाई 1सुनिश्चित कर सकती है कि हैश मूल्य 0बहुत जल्दी खत्म हो जाएगा । फिर इसे उलटने से हैश मान की लंबाई 1 से कम हो जाती है।

दोनों का हैश मान है 259।

— jimmy23013
स्रोत

2

सी # - 393 बाइट्स - द्वारा: लोगान बांध

70776e65642062792031333337206861786f72और 70776e65642062792031333337206861786f7200दोनों हैश करने के लिए 18E1C8E645F1BBD1।

— aaaaaaaaaaaa
स्रोत

ठंडा! क्या आप बता सकते हैं कि आपने इसे कैसे क्रैक किया? और शायद "दोषपूर्ण गद्दी"?

— ldam

@LoganDam यह वह सब कोड है जो इनपुट के चारों ओर स्विच करता है, आप कई 8 वर्णों को संसाधित करते हैं, और यदि इनपुट लंबाई 8 से अधिक नहीं है, तो आप शून्य को प्रतिस्थापित करते हैं। अगर मैं सही जगह पर कुछ शून्य में जोड़ देता हूं तो वे बस गद्दी की जगह लेते हैं, जो पहले स्थान पर शून्य था।

— आआआआआआआआआआ आआआआआ

क्रिप्टोग्राफिक हैश गोल्फ (लुटेरे)

क्रिप्टोग्राफिक हैश गोल्फ का साथी धागा

कार्य

स्कोरिंग

अतिरिक्त नियम

उदाहरण

Python 2.7, 22 बाइट्स user8675309 द्वारा

लीडरबोर्ड

कोड

व्याख्या

व्याख्या

PHP 4.1, इस्माइल मिगुएल द्वारा 66 बाइट्स