การประกวดนี้จบแล้ว

ไม่มีคำตอบที่สามารถถอดรหัสได้ในการท้าทายของตำรวจ

ด้ายคู่หูของCryptographic hash golf

เพื่อเป็นการเตือนความจำนี่คือกฎสำหรับโจรจากการท้าทายหลัก:

งาน

แตกใด ๆ ของตำรวจส่งโดยโพสต์ต่อไปนี้ในโจรหัวข้อ: สองข้อความMและNในฉันเช่นว่า H (M) = H (N)และM ≠ N

เกณฑ์การให้คะแนน

การแคร็กการส่งตำรวจแต่ละครั้งทำให้คุณได้หนึ่งจุด โจรที่มีคะแนนมากที่สุดเป็นผู้ชนะ

ในกรณีของการผูกเน็คไทโจรที่ถูกผูกไว้จะทำให้การยอมแพ้ที่ยาวนานที่สุดชนะ

กฎเพิ่มเติม

• การส่งตำรวจทุกครั้งสามารถถอดรหัสได้หนึ่งครั้งเท่านั้น

• หากการส่งตำรวจขึ้นอยู่กับพฤติกรรมที่กำหนดหรือไม่ได้กำหนดไว้คุณจะต้องพบกับรอยแตกที่ทำงานได้บนเครื่องของคุณ

• การแตกร้าวแต่ละครั้งเป็นของคำตอบแยกกันในเธรดของโจร

• การโพสต์ความพยายามในการแคร็กที่ไม่ถูกต้องห้ามคุณจากการแคร็กการส่งนั้นเป็นเวลา 30 นาที

• คุณไม่สามารถทำการส่งของคุณเองได้

ตัวอย่าง

Python 2.7, 22 ไบต์โดย user8675309

1

และ

18

ลีดเดอร์บอร์ด

1. eBusiness: 3 รอยแตก 393 ไบต์
2. Martin Büttner: 3 รอยร้าว 299 ไบต์
3. jimmy23013: 3 รอยแตก, 161 ไบต์
4. Sp3000: 3 รอยแตก 44 ไบต์
5. tucuxi: 2 รอยแตก 239 ไบต์
6. Vi .: 2 รอยแตก 87 ไบต์
7. feersum: 1 crack, 216 ไบต์
8. mathmandan: 1 รอยแตก 139 ไบต์
9. sossamish ossifrage: 1 รอยแตก, 134 ไบต์

C, 122 ไบต์ - โดย: นายลามะ

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

แฮชทั้งสองสตริงเป็น bb66000000000000d698000000000000

เช่นเดียวกับ "C, 128 ไบต์ - โดย: squeamish ossifrage" บิตคำสั่งที่สูงกว่าไม่เคยส่งผลกระทบต่อบิตคำสั่งที่ต่ำกว่านี้สามารถใช้ประโยชน์ได้

รหัส

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

Python 109 ไบต์โดย Sp3000

ทราบว่ามาร์ตินแตกก่อนดังนั้นฉันไม่แน่ใจว่านี่ควรได้รับคะแนนหรือไม่ ในทางกลับกันฉันทำการโจมตีแบบ preimage แทนการชนแบบง่าย ๆ ซึ่งเป็นผลลัพธ์ที่ดีกว่ามาก ซึ่งหมายความว่าคุณสามารถให้ค่าแฮชตามอำเภอใจและมันจะสร้างอินพุตที่สร้างค่าแฮชนั้น

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

Python 109 ไบต์โดย Sp3000

340282366920938463463374607431768211414

และ

113982837842983129870077688367927159293402923522160868689804433865221255200726

ผลผลิตทั้งสอง

132946164914354994014709093261515948032

อัลกอริธึมจะแยกอินพุตออกเป็นชิ้นจำนวน 128 บิตและทำการดัดแปลงแฮช (seeded เป็น42) กับแต่ละก้อนซ้ำ ๆก่อนที่จะทำการแฮ็ชพิเศษเพิ่มเติมในตอนท้าย ในการค้นหาการชนกันเป้าหมายของเราคือการหาตัวเลขสองตัวที่ให้ผลลัพธ์เดียวกันหลังจากรันโค้ดหลอกต่อไปนี้ในแต่ละอัน:

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

เนื่องจากแฮชนำมา mod 2 ¹²⁸เราต้องการค้นหาตัวเลขที่เปลี่ยนทุกสิ่งที่น่าสนใจนอกช่วงบิตนี้ แต่แฮชจะถูก seeded 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 122 จากนั้นผลลัพธ์ระดับกลางหลังจากนั้นhash += chunkจะเหมือนกันและเราจะได้ผลลัพธ์ที่เหมือนกันในตอนท้าย

ดังนั้นเราสามารถคำนวณตัวเลขสองตัวของการชนกัน:

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

เราสามารถสร้างการชนกันมากมายเช่นนี้ได้อย่างง่ายดาย

Mathematica, 89 bytes โดย LegionMammal978

0

และ

16

0อัตราผลตอบแทนที่ทั้งสอง

หลักการของตำรวจนี้คือการพัฒนาหุ่นยนต์เคลื่อนที่ 1-D ไบนารี "สุ่ม" จากสภาวะเริ่มต้น "สุ่ม" สำหรับจำนวนขั้นตอน "สุ่ม" แล้วตีความผล 128 เซลล์แรกของผลลัพธ์เป็นจำนวนเต็ม

ปัญหาคือกฎถูกกำหนดโดยง่ายๆMod[#^2,256]เช่นว่าค่าใด ๆ ของ 16 จะให้กฎ0ซึ่งเป็นกฎที่ไม่สำคัญที่เซลล์ทั้งหมดจะเป็นศูนย์เสมอ หากอินพุตไม่หารด้วย 99 เราจะพัฒนาอย่างน้อย 1 ขั้นดังนั้นเอาต์พุตจะเป็นศูนย์เสมอ ดังนั้นสองทวีคูณใด ๆ ที่ไม่ได้ทวีคูณของ 99 ชนกันอย่างแน่นอน อย่างไรก็ตามอินพุต0 ยังให้ 0 (แม้จะไม่เคยใช้กฎ) เนื่องจากเงื่อนไขเริ่มต้นเป็นเพียงการแทนเลขฐานสองของอินพุต (ซึ่งเป็นศูนย์ทั้งหมดในกรณีนี้)

นอกจากนี้เราสามารถพบการชนอื่น ๆ ที่ไม่ขึ้นอยู่กับกฎ ตามที่ระบุไว้ข้างต้นตัวคูณใด ๆ ของ 99 หมายความว่าหุ่นยนต์เซลลูลาร์ไม่ได้ถูกพัฒนาเลยดังนั้นผลลัพธ์จึงเป็นเงื่อนไขเริ่มต้นแรก (สำคัญที่สุด) 128 บิต ... ซึ่งเป็นเพียงหมายเลขอินพุต ดังนั้นถ้าเราเอาสองทวีคูณที่ไม่แตกต่างกันใน 128 บิตแรก (เบาะไปทางขวาด้วยเลขศูนย์) เราก็จะได้ชนกัน ตัวอย่างที่ง่ายที่สุดของที่นี่คือ,M = 99N = 99*2 = 198

J, 39 ไบต์

หมายเลขแรกคือ:

10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000

นั่นคือ10000000ซ้ำ 64 ครั้ง ตัวเลขที่สองคือบวกหนึ่งเช่น

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มี coprime และการที่เราจะต้องมีk a == b mod kดังนั้นเราสามารถหาลอการิทึมแบบไม่ต่อเนื่องของ 1 mod 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ที่จุดใดตัวเลขหนึ่งจะทำงาน

นี่คือรหัส Mathematica เพื่อสร้างสายบันทึกแยก:

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

นี้จะช่วยให้การส่งออกต่อไป

Pyth, 8 ไบต์โดย FryAmTheEggman

99999999999999999999999999

และ

99999999999999999999999998

ความแม่นยำจุดลอยตัวไม่ใหญ่พอสำหรับเรื่องนี้

CJam, 44 ไบต์, ผู้ใช้ jimmy23013

ตัวเลขที่มีขนาดใหญ่เกินไปที่จะโพสต์เพื่อให้ที่นี่พวกเขาอยู่บน Pastebin: NUM 1 , NUM 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)

ดังนั้นถ้าเราสามารถหาตัวเลขสองตัวเพื่อให้ผลรวมของS[i][j]*13^i*19^jเป็นโมดูโลเดียวกัน16^20สำหรับทั้งอาร์เรย์ 600 กว้างเริ่มต้นและอาร์เรย์ซิปแล้วเราก็เสร็จแล้ว

ในการทำให้สิ่งต่าง ๆ ง่ายขึ้นเราจะพิจารณาเฉพาะ600^2 = 360000-digit input number ดังนั้นอาร์เรย์ 600-wide เป็นเพียง 600 x 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เพื่อ

นี่คือผู้ย้อนรอยใน Python 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

สำหรับโบนัสนี่คือพอร์ตแฮชที่ไม่มีประสิทธิภาพใน Python 3 มันไร้ประโยชน์

PHP 4.1, 66 bytesโดยIsmael Miguel

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

พบว่าใช้ hashing ซ้ำง่ายเริ่มต้นจาก 1:

$ 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

Python 3 (216) โดย Sp3000

ข้อความของฉันคือ

5012053369354645637214643587103597313576086380250249302980438772005248488380915054746146050001036696049972235875591571028140916001206596142280971107479334216535925703480968283657357930602076844092875640359192729378384507238123245417656548512647301639542279794868512420586823155070914644206130805893968511673770843170450832829657206145931885656157628306896903719624729809643572222159364893644113710867223921580178741177106141068298067479650611992859787419779579962211254029169589775046869542029842374359998053713002047081002506346875804341770199884355810931652447801492691887376948615365487982834690942054717077615539311699691010938426302886867891090301248321702485904291177813145565144089044261424329155436660979948932491709511914065619715728353376578192548334780893602675684085757434059540582004872746967999949306946618036846307799677491651967418565531672392468089533111553281620101129322575737949904022139471688252420467041529301533363008476437812216585923822571793353317799365005036029476865
5012053369354645637214643587103103086948976188724715498910865650846170784131001427390927276355140411160919276493388206817700368694224128444524223814513348177926532982330730066315320819293979046126543806115318009892783577432467861426768883700930779409885418980853424256180864755881414774514084197887594253752179391098292488771920695965135791582218083012144604515253506370334133858904659263953147111654656123599460222236152128559750436960308887683690915261431659087040402402092795259541564130228515353133867041828417398395559815392177084002004583988047406317670433664624642858480970640416500369367395538257341309676777745698712896295462462064271676447460293684100001583256400774270688958051470568447233589146620275159126426142305307007744396679875427883384557759778766330566230012377845843842097372663092379922300568052486301863154557664156185573021849420011058607321977550938866119133331529852821217331665195832442542012455132139770813510559894254061471149750738447764616026512400623344132554752

ฉันใช้รหัส Python 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ฉันเดาว่าความหวังคือมันเป็นไปไม่ได้ที่ NP จะเป็นไปไม่ได้ที่เราจะแยกเซมิโคลอนออกมา แต่ฉันเดาว่า 128 บิตมีขนาดเล็กเกินไปเนื่องจากหน้าเว็บบางหน้าให้คำตอบกับฉันทันที

กลุ่มโมดูโลแบบหลายกลุ่มabจะมีคำสั่ง(a - 1) (b - 1)ซึ่งหมายความว่าถ้าเราเพิ่มจำนวนใด ๆ ไปยังพลังนั้นมันจะต้องมีผลลัพธ์เป็น 0 หรือ (ปกติ) 1 ดังนั้นฉันจึงใส่ 1 บิตในสถานที่ที่ทำให้เกิด2 ^{(a-1) (b-1)}ถูกคูณเข้าไปในแฮช จากนั้นข้อความอื่น ๆ นั้นเป็น 0 แต่ฉันตั้งบิตอื่น ๆ ในแต่ละหมายเลขเพื่อทำให้ความยาวเท่ากัน

ฉันคิดว่ามันน่ารำคาญกว่านี้คือความยุ่งเหยิงยกกำลังสองทุก ๆ ครั้งแทนที่จะใช้เฉพาะช่วงเวลาทั้งหมด จากนั้นมันคงไม่ง่ายนักที่จะสร้างเลขชี้กำลังโดยพลการสำหรับพวกเขา

C, 128 bytes - by: squeamish ossifrage

สองสตริงต่อไปนี้ทั้งแฮชกับศูนย์ทั้งหมด:

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บิตลำดับล่างทั้งหมดเป็นศูนย์จากนั้นฉันสามารถลองชุดค่าผสมเหล่านี้ของสตริงเหล่านี้ บิตที่ต่ำกว่าเป็นศูนย์ ฯลฯ ฉันค่อนข้างแน่ใจว่ามีวิธีการทำลายมากกว่านี้และวิธีที่สร้างสตริงที่สั้นลงอย่างมีนัยสำคัญ แต่วิธีนี้ฉันหลีกเลี่ยงการทำคณิตศาสตร์จำนวนมาก

Python 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 ...

Python 2, 161 ไบต์โดย Puzzled

340282366920938463463374607431768211456 (decimal)
100000000000000000000000000000000 (hexadecimal)

และ

340282366920938468780317283222139437056 (decimal)
100000000000001203B66F94300000000 (hexadecimal)

ทั้งคู่มีเอาต์พุต:

83F172CC3D050D131F64FD04B8181DC2

ตัวเลขคือ 2 ^ 128 และ 2 ^ 128 + (3 * 5 * 7 * 11 * 13 * 17) ^ 2 * 19 * 2 ^ 32

Java, 299 ไบต์โดย SuperJedi224

Pastebin Mสำหรับ ในไบนารีMมี 65535 1s ตามด้วย 2 0s

Pastebin Nสำหรับ ในไบนารีNมี 21845 1s ตามด้วย 174766 0s

0อัตราผลตอบแทนที่ทั้งสอง

หมายเหตุว่าพื้นฐานของอัลกอริทึมที่เป็นi.bitCount()*i.bitLength()+1และในที่สุดเราใช้ผลให้อำนาจของiและนำ mod 2 128 ดังนั้นความคิดเป็นเพียงที่จะได้พบกับสองiที่หารด้วยสี่ แต่ที่แสดงออกแรกให้ 2 32 ซึ่งทำได้ง่ายโดยการแยก 2 ³² -1 และเลือกสองปัจจัยสำหรับการนับ 1 และความกว้างบิตรวมของตัวเลข

แก้ไข: ที่จริงแล้วมีอะไรเพิ่มเติมว่าทำไมMอัตราผลตอบแทนเป็นศูนย์ แต่เราสามารถหาตัวเลขที่ให้ผลเป็นศูนย์ได้ง่ายขึ้นเนื่องจากคำอธิบายของฉันโดยใช้ปัจจัยอื่น ๆ ของ 2 ³² -1 เช่นที่ปลาย 64 มีอย่างน้อย

C, 134 ไบต์ (โดย Barteks2x)

10

และ

20

แฮชทั้งสองไป

0xa609779942cb9ef1

เพราะอัลกอริทึมแฮชตัวสุดท้ายเท่านั้น!

C, 87 ไบต์

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

พบโดยใช้ bruteforcer ชนของฉัน

Python 2, 115 ไบต์, โดย squeamish ossifrage

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

และ

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

ค่าแฮชไม่มีส่วนเกี่ยวข้องกับลำดับของบล็อก

Python 2.x, 139 ไบต์โดย Puzzled

H(2)

และ

H(128)

ทั้งสองกลับมา

16645614427504350476847004633262883518.

C ++, 239 ไบต์โดย SpelingMistake

การใช้โปรแกรม "main" ที่ให้มาอินพุตสองตัวต่อไปนี้สร้างแฮชเดียวกัน:

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--;)จะแก้ไขสิ่งนี้

ทับทิม 90 ไบต์โดย MegaTom

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

และ

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

ซึ่งคือ 2 และ 11 ตามด้วย 40 ศูนย์ไบต์ ดังนั้นพวกเขาจึงมี 41 ไบต์ ค่าแฮชจะถูกเพิ่มโดยความยาวอินพุตสำหรับแต่ละไบต์จากนั้นจะถูกย้อนกลับเป็นทศนิยม ความยาวของอินพุตที่ลงท้ายด้วย1สามารถทำให้แน่ใจได้ว่าค่าแฮชจะลงท้ายด้วยค่าที่0ค่อนข้างเร็ว จากนั้นการย้อนกลับจะลดความยาวของค่าแฮชลง 1

259ทั้งสองมีมูลค่ากัญชา

C # - 393 ไบต์ - โดย: Logan Dam

70776e65642062792031333337206861786f72และทั้งกัญชาไป70776e65642062792031333337206861786f720018E1C8E645F1BBD1