Цей конкурс закінчився.

У виклику поліцейських не залишилось жодної відповіді на хитрість.

Нитка супутника Криптографічного хеш-гольфу

Як нагадування, ось основні завдання для грабіжників:

Завдання

Тріщина будь-який з поліцейських Доводи, розмістивши такі дані в потоці грабіжників: два повідомлення M і N в I таким чином, що H (M) = H (N) і M ≠ N .

Оцінка балів

Якщо зламати кожне подання копа, ви отримаєте один бал. Перемагає грабіжник з найбільшою кількістю очок.

У разі краватки виграє прив'язаний розбійник, який тріснув найдовше.

Додаткові правила

• Кожне подання копа може бути зламано лише один раз.

• Якщо подання на поліцейських покладається на визначене впровадженням або не визначене поведінку, вам залишається лише знайти тріщину, яка працює (перевірено) на вашій машині.

• Кожна тріщина належить до окремої відповіді в нитці розбійників.

• Опублікування недійсної спроби злому забороняє вам зламати саме це подання протягом 30 хвилин.

• Ви не можете зламати власне подання.

Приклад

Python 2.7, 22 байти користувачем8675309

1

і

18

Таблиця лідерів

1. електронний бізнес: 3 тріщини, 393 байти
2. Мартін Бюттнер: 3 тріщини, 299 байт
3. jimmy23013: 3 тріщини, 161 байт
4. Sp3000: 3 тріщини, 44 байти
5. tucuxi: 2 тріщини, 239 байт
6. Vi .: 2 тріщини, 87 байт
7. feersum: 1 тріщина, 216 байт
8. mathmandan: 1 тріщина, 139 байт
9. кремезний костінь: 1 тріщина, 134 байти

C, 122 байти - автор: Містер Лама

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

Обидві струни хешують bb66000000000000d698000000000000

Так само, як "C, 128 байт - за: кричущі коси", біти вищого порядку ніколи не впливають на біти нижчого порядку, це можна використати.

Код

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

Зауважте, що Мартін першим тріснув, тому я не впевнений, чи заслуговує це балів. З іншого боку, я зробив попередню атаку, а не просте зіткнення - набагато сильніший результат. Це означає, що ви можете надати йому довільне хеш-значення, і воно сконструює вхід, який генерує це хеш-значення.

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 біт і багаторазово модифікує хеш (посіяний 42) на кожен фрагмент, перш ніж робити кілька додаткових хешування в кінці. Щоб знайти зіткнення, наша мета - знайти два числа, які дають однаковий результат після запуску наступного псевдо-коду на кожному фрагменті:

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

Оскільки хеш взято мод 2 ^128, ми хочемо шукати числа, які зміщують усі цікаві речі за межами цього бітового діапазону. Але хеш засівають 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

Ми можемо легко створити ще багато подібних зіткнень.

Mathematica, 89 байт від LegionMammal978

0

і

16

Обидва виходи 0.

Принцип роботи цього копа полягає в тому, щоб перетворити "випадковий" двійковий 1-D стільниковий автомат з "випадкової" початкової умови на "випадкове" число кроків, а потім інтерпретувати перші 128 комірок результату як ціле число.

Проблема полягає в тому, що правило визначається просто через Mod[#^2,256]таке, що будь-яке кратне 16 дає правило 0, що є тривіальним правилом, коли всі комірки завжди дорівнюють нулю. Якщо вхід не ділиться на 99, то ми розвинемось щонайменше на 1 крок, тому вихід завжди дорівнює нулю. Тож будь-які два кратні, які не кратні 99, безумовно, стикаються. Однак вхід 0 також дає 0 (незважаючи ніколи на використання цього правила), оскільки початковою умовою є лише двійкове представлення вводу (що в цьому випадку є всі нулі).

В сторону ми можемо знайти й інші зіткнення, які повністю не залежать від правила. Як зазначалося вище, будь-яке кратне число 99 означає, що стільниковий автомат взагалі не розвивається, тому результатом є просто перший (найзначніший) 128 біт початкової умови ... що саме по собі є лише вхідним числом. Отже, якщо ми візьмемо два кратні, які не відрізняються за першими 128 бітами (підкресленими праворуч нулями), ми також отримаємо зіткнення. Найпростішим прикладом цього є M = 99, N = 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є копріменом, і для цього 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, в цей момент в основному працюють будь-які два числа.

Ось код 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

Цифри занадто великі для публікації, тому ось вони на Пастебіні: число 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)

Тож якщо ми можемо знайти два вхідні числа, щоб суми S[i][j]*13^i*19^jбули однаковими за модулем16^20 як для початкового масиву в 600, так і для заархівованого масиву, ми закінчили.

Щоб зробити це трохи простішим, ми розглянемо лише 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.

Ось зворотний трекер на 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 байт на Ісмаель 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;

Знайдено за допомогою простого ітераційного хешування, починаючи з 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 . Я маю надію, що для нас буде неможливим розподілити коефіцієнт напівпрозорості, але я думаю, що 128 біт занадто мало, тому що якась веб-сторінка дала мені відповідь відразу.

Модуль мультиплікативної групи abматиме порядок (a - 1) (b - 1), це означає, що якщо ми піднімемо будь-яке число до цієї потужності, воно повинно призвести до 0 або (як правило) 1. Отже, я помістив 1 біт у місця, в результаті яких 2 ^{(a-1) (b-1)} , помножений на хеш. Тоді інше повідомлення в основному 0, але я встановлюю ще один біт у кожному номері, щоб довжини були однаковими.

Я думаю, що було б більше дратувати, якби хеш-квадрат був розміщений на кожному шматочку, а не тільки після використання всіх прайменів. Тоді було б не так просто побудувати для них довільні показники.

C, 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 біти нижчого порядку дорівнюють нулю, то я можу спробувати об'єднані комбінації цих рядків, щоб знайти деякі, де більше нижчі біти дорівнюють нулю і т. д. Я майже впевнений, що існує більше способів цього розбити, а також способи, що створюють значно коротші рядки, але таким чином я уникав багато математики.

Python 3, 118 байт

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

і

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

(тобто: 9E400 та 9E4000)

Обидва виробляють

83909358607540647658718900164058931893

Копаючи дещо глибше, здається, що будь-яке ціле число з наступними k повторними цифрами таким чином, що k> 128 і (k% 4 == 0) поверне той самий хеш. Наприклад, H("1"+"1"*32*4)і H("1"+"1"*33*4)обидва 13493430891393332689861502800964084413. Хм, 128 ...

Python 2, 161 bytes, Зрозуміло

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

Пастебін для M. У двійковій Mмається 65535 1с, далі 20 с.

Пастебін для N. У двійковій Nформі має 218451 формі с, а потім 174766 0с.

Обидва врожайні 0.

Зауважимо, що основою алгоритму є, i.bitCount()*i.bitLength()+1і, зрештою, ми приймаємо результат на силу iта приймаємо його mod 2 ¹²⁸ . Тож ідея полягала в тому, щоб знайти два, iякі поділяються на чотири, але там, де перший вираз дає 2 ³² . Це було легко зробити за допомогою коефіцієнта 2 ³² коефіцієнта -1 та вибору двох факторів для підрахунку 1s та загальної бітової ширини числа.

Редагувати: Насправді, є дещо більше, чому Mдається нуль, але ми можемо легко знайти більше чисел, які дають нуль через моє пояснення, використовуючи інші коефіцієнти 2 ³² -1, такі, що в кінці є принаймні 64 нулі.

C, 134 байти (від Barteks2x)

10

і

20

обидва хешу

0xa609779942cb9ef1

тому що алгоритм хеширує лише останню цифру!

C, 87 байт

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

Знайдено за допомогою мого грубого зіткнення.

Python 2, 115 bytes, від кричущої кості

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222

і

2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222211111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

Значення хеша не мало нічого спільного з порядком блоків.

Python 2.x, 139 байтів від Puzzled

H(2)

і

H(128)

обидва повертаються

16645614427504350476847004633262883518.

C ++, 239 байт від SpelingMistake

Використовуючи надану "основну" програму, наступні два входи створюють один і той же хеш:

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 байти - автор: Дамба Логан

70776e65642062792031333337206861786f72і 70776e65642062792031333337206861786f7200обидва хеши до 18E1C8E645F1BBD1.