এই প্রতিযোগিতা শেষ।

পুলিশ চ্যালেঞ্জের আর কোন ক্র্যাকযোগ্য উত্তর নেই।

ক্রিপ্টোগ্রাফিক হ্যাশ গল্ফের সঙ্গী থ্রেড

অনুস্মারক হিসাবে, এখানে মূল চ্যালেঞ্জ থেকে ডাকাতদের জন্য নিয়ম রয়েছে:

কার্য

দুই বার্তা: থ্রেড 'ডাকাত নিম্নোক্ত পোস্ট করে জমা' পুলিশ কোনো ফাটল এম এবং এন মধ্যে আমি যেমন যে এইচ (এম) = এইচ (এন) এবং এম ≠ এন ।

স্কোরিং

প্রতিটি কপ সাবমিশন ক্র্যাক করা আপনার এক পয়েন্ট লাভ করে। সবচেয়ে পয়েন্ট সহ ডাকাত জিতেছে।

টাইয়ের ক্ষেত্রে, বাঁধা ডাকাত যা দীর্ঘতম জমা দেওয়ার পক্ষে জয়লাভ করে।

অতিরিক্ত বিধি

প্রতিটি পুলিশ জমা দেওয়ার সময় কেবল একবার ফাটানো যায়।

যদি কোনও পুলিশ জমা দেওয়ার বাস্তবায়ন-সংজ্ঞায়িত বা অপরিজ্ঞাত আচরণের উপর নির্ভর করে তবে আপনাকে কেবল আপনার মেশিনে একটি ক্র্যাক (যাচাইযোগ্য) কাজ করতে হবে তা খুঁজে পেতে হবে।

প্রতিটি ক্র্যাক ডাকাতদের থ্রেডে পৃথক উত্তরের অন্তর্ভুক্ত।

একটি অবৈধ ক্র্যাকিংয়ের প্রচেষ্টা পোস্ট করা আপনাকে 30 মিনিটের জন্য নির্দিষ্ট জমাটি ক্র্যাক করা থেকে নিষিদ্ধ করে।

আপনি নিজের জমা জমা দিতে পারেন না।

উদাহরণ
পাইথন 2.7, 22 বাইট দ্বারা ব্যবহারকারী 8675309
1
এবং
18

লিডারবোর্ড

eBusiness: 3 ফাটল, 393 বাইট
মার্টিন বাটনার: 3 ফাটল, 299 বাইট
জিমি 23013: 3 ফাটল, 161 বাইট
Sp3000: 3 ফাটল, 44 বাইট
টুকুসি: 2 ফাটল, 239 বাইট
ভি .: 2 ফাটল, 87 বাইট
মল: 1 ক্র্যাক, 216 বাইট
mathmandan: 1 ক্র্যাক, 139 বাইট
স্কাইমিশ ওসিফ্রেজ: 1 ক্র্যাক, 134 বাইট

— ডেনিস
সূত্র

5

সি, 122 বাইট - লিখেছেন: মিঃ লামা

bmaj8PCosFLAJjeHaevvvchnJedmg2iujpePOPivI2x2asw0yKa2eA15xvFJMFe82RGIcdlvxyaAPRuDuJhFjbh78BFsnCufJkarwEyKa0azHxccw5qegpcP9yaO0FKoohanxgiAfK1Lqwba51bKtjacbvdjMmcBkiv8kd62sBd98c4twa98sgj3iPh7nkP4
rlaejTPrua1DhBdg0jrIoDBi8fc1GIJAigivIGaxs1OmfPcctNadK3HErvzPLCeDPD8fkMNPCBcIwuoGfEHegOfk9k9pwktslqaBenaati1uNthMiyk9ndpy7gdIz88iot6A09cbNeIMheyjBvbeegL7aGp7mCb91hCxnvgV5abfImrPfLbrbraAsN6loJgh

উভয় স্ট্রিং হ্যাশ bb66000000000000d698000000000000

ঠিক "সি, 128 বাইট - যেমন: স্কোয়ামিশ ওসিফ্রেজ" এর মতো উচ্চতর অর্ডার বিটগুলি কখনই নিম্ন আদেশের বিটগুলিকে প্রভাবিত করে না, এটি শোষণ করা যেতে পারে।

কোড

ভিজ্যুয়াল সি ++, " অনিরাপদ " স্ট্রিং ক্রিয়াকলাপগুলি ব্যবহার করে

#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
সূত্র

অসাধারণ! আমি আসলে এক বিচিত্র ধরণের চাটুকার! : ডি

— মিঃ লালমা

এছাড়াও, আমার নিজের ব্যক্তিগত শিক্ষার জন্য, আপনি যখন বলেন উচ্চতর অর্ডার বিটগুলি কখনই নিম্নের উপর প্রভাব ফেলে না, আপনি কী বোঝাতে চাইছেন? ইনপুট স্ট্রিং এর উচ্চতর অর্ডার বিট, বা হ্যাশ রাজ্যের?

— মিঃ লালমা

@ মিঃল্লামা হ্যাশ অবস্থায়, x এবং y এর উপরের বিটগুলি কখনই নীচের বিটগুলিকে প্রভাবিত করবে না, উদাহরণস্বরূপ আপনি যদি গণনার সময় মিডল বিটগুলি ফ্লিট করেন তবে হ্যাশের নীচের অংশটি ঠিক তখনই বেরিয়ে আসবে। এটি আমাকে হ্যাশ রাষ্ট্রের সর্বনিম্ন বিট ব্যতীত সমস্ত কিছু উপেক্ষা করে শুরু করতে দেয়, তারপরে যখন আমার সম্পূর্ণ নিয়ন্ত্রণে থাকে তখন আমি বিটগুলির পরবর্তী স্তরটিতে চলে যাই এবং আরও এগিয়ে।

— aaaaaaaaaaaa

শান্ত! বর্নানার জন্য ধন্যবাদ!

— মিঃ লালমা

ডাকাতদের চ্যালেঞ্জ জিতে অভিনন্দন!

— ডেনিস

12

পাইথন, এসপি 3000 দ্বারা 109 বাইট

নোট করুন যে মার্টিন প্রথমে ফাটল, তাই আমি নিশ্চিত নই যে এটি পয়েন্টগুলির প্রাপ্য। অন্যদিকে, আমি একটি সাধারণ সংঘর্ষের চেয়ে প্রাক-আক্রমণ আক্রমণ করেছি - এটি আরও দৃ stronger় ফলাফল। এর অর্থ হল যে আপনি এটিকে একটি স্বেচ্ছাচারী হ্যাশ মান দিতে পারেন এবং এটি একটি ইনপুট তৈরি করবে যা সেই হ্যাশ মান উত্পন্ন করে।

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

স্যান্ডবক্সে আমার প্রাথমিক প্রস্তাবটি সংঘর্ষ, প্রাকমাইজ এবং (সামান্য ওভারসিম্প্লিফিং জিনিস) দৈর্ঘ্যের বর্ধনের আক্রমণগুলির জন্য পয়েন্ট প্রদান করেছে, তবে আমি স্কোরিংটি সহজ রাখার সিদ্ধান্ত নিয়েছি। আমি যখন parts অংশগুলি সম্পাদনা করেছি, তখন প্রতিটি জমা কেবল একবারই ফাটানো যায় (এটি হ'ল পুলিশ-ডাকাতরা সাধারণত কীভাবে কাজ করে) কোনওরকমে হারিয়ে যায়। আপনার উত্তরটি দেখে আমার মনে হয় আমি প্রিমাইজ আক্রমণ চালিয়েছি ...

— ডেনিস

9

পাইথন, এসপি 3000 দ্বারা 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

এটি মোটামুটি সহজ তাই এর দুটি সংখ্যার একটি হিসাবে এটি ব্যবহার করার চেষ্টা করি। (আসলে, আমি যে সংঘর্ষটি ব্যবহার করেছি তার প্রথম সংখ্যাটি ¹²⁸ -42 ডলার 42

এখন আমরা একই ফলাফল সহ অন্য নম্বরটি কীভাবে খুঁজে পাব? ঠিক আছে এক পুনরাবৃত্তির পরে হ্যাশ আর নেই 42, তবে 2**122যেমনটি আমরা স্রেফ দেখিয়েছি। এখন আমাদের ইনপুট সংখ্যায় দ্বিতীয় অংশ যোগ করে, আমরা আরেকটি পুনরাবৃত্তি চালাতে পারি। আমরা এটির মতো একই যুক্তি দ্বারা দ্বিতীয় অংশটি চয়ন করতে পারি, অর্থাৎ আমরা 2 ¹²⁸ -2 ^{122 চাই} । তারপরে মধ্যবর্তী ফলাফলটি hash += chunkঅভিন্ন হবে এবং আমরা শেষে একই ফলাফলটি দিয়ে শেষ করব।

সুতরাং আমরা সংঘর্ষের দুটি সংখ্যা গণনা করতে পারি:

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

আমরা সহজেই এরকম আরও অনেক সংঘর্ষ তৈরি করতে পারি।

— মার্টিন ইন্ডার
সূত্র

আমি এটি ক্র্যাকিং ছিল - প্রায় সম্পন্ন। এটি কি পশ্চিমের প্রতিযোগিতার দ্রুততম বন্দুক বা আমি এখনও এটি পোস্ট করার জন্য পয়েন্ট পেতে পারি?

— orlp

@orlp সাধারণত প্রথম ডাকাত একটি পয়েন্ট পায়। অন্যথায়, প্রথম ক্র্যাক পোস্ট হওয়ার পরে লোকেরা কেবল কয়েক মিলিয়ন অতিরিক্ত ক্র্যাক তৈরি করতে পারে।

— মার্টিন ইন্ডার

1

খোঁড়া = / ভাবেন আমি তখন এই চ্যালেঞ্জটি করা বন্ধ করব। আমি অন্যের বিরুদ্ধে রেসিং উপভোগ করি না - আমি কেবল ধাঁধা দিতে চাই। প্রথমটির পরে ক্র্যাকের জন্য কিছু সময় উইন্ডো থাকতে পারে না, কেবল ব্যক্তি প্রতি 1 ক্র্যাক দিয়ে?

— orlp

@orlp স্যান্ডবক্সের মূল সংস্করণটিতে একটি পুলিশকে ক্র্যাক করার তিনটি ভিন্ন পদ্ধতি ছিল এবং তিনটিই স্বাধীনভাবে পোস্ট করা যেতে পারে। আমার ধারণা এটি কোনও সময়ে তদন্ত করার জন্য একটি আকর্ষণীয় মডেল। তবে এখন পর্যন্ত আগের সিএনআরগুলিতে একাধিক ফাটলকে অনুমতি দেওয়া চ্যালেঞ্জটিকে আরও উন্নত করার চেয়ে সবসময় ভেঙে ফেলত।

— মার্টিন ইন্ডার

1

কোনও সংঘর্ষের চেয়ে

— প্রিমাইজ

8

ম্যাথমেটিকা, 89 বাইট লেজিওনম্যামাল 978 দ্বারা

এবং

উভয় ফলন 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, ycoprime হয়, এবং যে জন্য 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
সূত্র

সামান্য সংক্ষিপ্ত সংস্করণটি হ'ল যদি প্রথম কয়েক শত অঙ্ক একই হয় তবে বাকী ইনপুটটি যে কোনওভাবেই গুরুত্বপূর্ণ impro আসলে এটি ভাঙ্গার জন্য গণিত করা ওভারকিল।

— aaaaaaaaaaaa

@eBusiness এটি সত্য। দেখা গেল যে এখানে খুব বেশি কিছু আসে যায় না, তবে প্রাথমিকভাবে আমি 2^(2^30)সীমা ছাড়িয়ে যাওয়ার বিষয়ে চিন্তিত ছিলাম , তাই চেক।

— Sp3000

প্রকৃতপক্ষে, আমি সন্দেহ করি যে 512 তম সংখ্যার বাইরে যে কোনও বিষয়ই এমন স্ট্রিং বানানো অসম্ভব। আপনি সবচেয়ে খারাপ পরিস্থিতি তৈরি করতে পরিচালিত হয়েছেন। অভ্যন্তরীণ নেতৃস্থানীয় শূন্যগুলির সুবিধার্থে সবচেয়ে সহজ ক্র্যাকটি অবশ্যই হতে হবে: "100000001" "1000000001"।

— aaaaaaaaaaaa

7

পাইথ, ফ্রিআমডেইজিম্যান দ্বারা 8 বাইট

99999999999999999999999999

এবং

99999999999999999999999998

ভাসমান পয়েন্ট যথার্থতা এর পক্ষে যথেষ্ট বড় নয়।

— Sp3000
সূত্র

আমি আসলে এর জন্য বিভিন্ন ফলাফল পাচ্ছি, তবে আমি বিশ্বাস করি যে এই কৌশলটি যেভাবেই চলবে তাই আমি এটিকে ফাটল হিসাবে চিহ্নিত করব। দ্রুত কাজ: পি

— FryAmTheEggman

হুম অদ্ভুত। আমি 437409784163148উভয়ের জন্য পেতে । আমি ভাবছি কেন পার্থক্য আছে ...

— Sp3000

আপনি সম্ভবত অজগর 3.5 ব্যবহার করছেন? আমি এখনও আপডেট হয়নি, এখনও 3.4 এ সম্ভবত এটিই কি?

— FryAmTheEggman

@ ফ্রাইআমএইজিগম্যান আমি অনলাইন দোভাষী ব্যবহার করছি, আসলে ...

— Sp3000

আসলে হ্যাঁ আমি পেয়েছি 437409784163148এবং 37409784163148সুতরাং অনুমান করি যে এটি কোনও কারণে শেষ সংখ্যাটি সবেমাত্র হারিয়েছে, তবে 99 ... 997 999 ... 98 হিসাবে একই উত্তর দেয়।

— FryAmTheEggman

6

সিজেম, 44 বাইট, ব্যবহারকারী জিমি 23013

সংখ্যাগুলি পোস্ট করার জন্য খুব বড়, সুতরাং এখানে তারা পাস্তবিনে রয়েছে: নাম্বার 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)Triplets আমরা এখান থেকে ডিজিটের পরিবর্তন (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

ইসমাইল মিগুয়েল দ্বারা পিএইচপি 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: থেকে শুরু করে সাধারণ পুনরাবৃত্ত হ্যাশিং ব্যবহার করে পাওয়া গেছে

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

অনুবাদ: বেশ দুর্বল হ্যাশ?

— ইসমাইল মিগুয়েল

হ্যাঁ.󠀠󠀠󠀠󠀠󠀠󠀠

— 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। আমি অনুমান করি যে আশাটি ছিল আমাদের পক্ষে সেমিপ্রাইম ফ্যাক্টর করা NP- অসম্ভব, তবে আমার ধারণা 128 বিট খুব ছোট কারণ কিছু ওয়েবপৃষ্ঠা আমাকে এখনই উত্তর দিয়েছে the

গুণক গোষ্ঠীটির মডুলোর abঅর্ডার থাকবে (a - 1) (খ - 1) যার অর্থ আমরা যদি সেই শক্তিটিতে কোনও সংখ্যা বাড়িয়ে তুলি তবে এটির ফলাফল 0 বা (সাধারণত) হতে হবে। সুতরাং আমি 1 বিটগুলি স্থানে ফেলেছি যার ফলস্বরূপ 2 ^{(a-1) (খ -1)} হ্যাশে গুণিত হচ্ছে। তারপরে অন্যান্য বার্তাটি মূলত 0, তবে দৈর্ঘ্যকে একই করার জন্য আমি প্রতিটি সংখ্যায় অন্য একটি বিট সেট করে রেখেছি।

আমি মনে করি যে সমস্ত প্রাইম ব্যবহারের পরে না হয়ে বরং প্রতিটি বিটের উপর হ্যাশ স্কোয়ার করা বেশি বিরক্তিকর হত। তাহলে তাদের পক্ষে স্বেচ্ছাচারী অভিব্যক্তি তৈরি করা এত সহজ হত না।

— feersum
সূত্র

দুর্দান্ত কাজ :) হ্যাঁ আমার দুর্বলতার কথা মনে ছিল মূলত কোডটিতে সেমিপ্রাইম দৃশ্যমান এবং আমি বুঝতে পেরেছিলাম ম্যাথমেটিকাকে তাত্ক্ষণিকভাবে ফ্যাক্টর করতে পারে।

— Sp3000

+1 আপনার কোডটি পড়া শক্ত, তবে অন্যথায় একটি দুর্দান্ত এবং শিক্ষণীয় ক্র্যাক।

— aaaaaaaaaaaa

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নীচের ক্রমের সমস্ত বিট শূন্য থাকে, তারপরে আমি আরও কিছু যেখানে খুঁজে পেতে এই স্ট্রিংগুলির সংমিশ্রণ সংমিশ্রণগুলি চেষ্টা করতে পারি নিম্ন বিটগুলি শূন্য ইত্যাদি I'm আমি নিশ্চিত যে এটি ভাঙ্গার আরও অনেকগুলি উপায় রয়েছে এবং এটিও যেগুলি উল্লেখযোগ্যভাবে ছোট স্ট্রিং উত্পাদন করে, তবে এইভাবে আমি প্রচুর গণিত করা এড়িয়ে চলেছি।

— aaaaaaaaaaaa
সূত্র

অসাধারণ! তারা উভয়ই 0x0000000a0000000a0000000a0000000aআমার সিস্টেমে হ্যাশ করেছে তবে এটি এখনও বেশ আশ্চর্যজনক। ( echo -ne '\x0a' |./hashএছাড়াও একই ফলাফল দেয়))

— r3mainer

1

@ স্ক্যোয়ামিশোসিফ্রেজে আপনার কাছে প্রতিটি স্ট্রিংয়ের পরে একটি নতুন নতুন লাইন রয়েছে, এটি সরল শূন্য নয়।

— aaaaaaaaaaaa

ওহ হ্যাঁ, আমার ভুল :-)

— r3mainer

4

পাইথন 3, 118 বাইট

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

এবং

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

(এটি: 9E400 এবং 9E4000)

উভয় উত্পাদন

83909358607540647658718900164058931893

কিছুটা গভীর খনন করা গেলে, মনে হয় যে কোনও সংখ্যার পি কে পুনরাবৃত্ত সংখ্যা যেমন কে> 128 এবং (কে% 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

জাভা, সুপারজেডি ২২৪ বাই ২৯৯ বাইট

পেস্টবিনের জন্য M। বাইনারিতে M65535 1গুলি, এর পরে 2 0এস রয়েছে।

পেস্টবিনের জন্য N। বাইনারি মধ্যে N21845 1গুলি, এর পরে 174766 0s রয়েছে।

উভয় ফলন 0।

নোট করুন যে অ্যালগরিদমের ভিত্তি i.bitCount()*i.bitLength()+1এবং শেষ পর্যন্ত, আমরা iফলাফলটিকে পাওয়ারের দিকে নিয়ে যাই এবং এটি 2 ^{128 এর} মোডে নিয়ে যাই । সুতরাং ধারণাটি কেবলমাত্র দুটি iদ্বারা বিভক্ত যা চারটি দ্বারা বিভক্ত, তবে যেখানে প্রথম প্রকাশটি 2 ³² দেয় । এটি সহজেই 2 ³² -1 ফ্যাক্টর করে এবং 1 ^টি গণনা এবং সংখ্যার মোট বিট প্রস্থের জন্য দুটি কারণ বাছাই করে করা হয়েছিল।

সম্পাদনা: প্রকৃতপক্ষে Mশূন্যের ফলন পাওয়ার জন্য আরও কিছু রয়েছে তবে শেষ পর্যন্ত কমপক্ষে 64৪ টি শূন্য রয়েছে এমন 2 ³² -1 এর অন্যান্য কারণগুলি ব্যবহার করে আমার স্পষ্টতার কারণে আমরা আরও সহজেই শূন্যের ফলক খুঁজে পেতে পারি ।

— মার্টিন ইন্ডার
সূত্র

3

সি, 134 বাইট (বারটেক্স 2 এক্স দ্বারা)

এবং

উভয় হ্যাশ

0xa609779942cb9ef1

কারণ অ্যালগরিদম শুধুমাত্র শেষ সংখ্যা হ্যাশ!

— r3mainer
সূত্র

এটি একটি মূর্খ ভুল ছিল ...

— বারটেক্স 2 এক্স 31'15

3

সি, 87 বাইট

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

আমার সংঘর্ষের ব্রুটোফোসার ব্যবহার করে পাওয়া গেছে।

— Vi।
সূত্র

এটি কেবলমাত্র 64৪-বিট হওয়ার কারণে।

— vi।

ভাল হয়েছে :-) এটি কত সময় নিল?

— r3mainer

প্রোগ্রামটি চালানোর প্রায় 7 মিনিট। এখন আবার পরিমাপ দিয়ে শুরু।

— vi।

1

আর একটি সংঘর্ষ পাওয়া গেছে: 473E0B6ED5AF2B92 7EC2BC9B5E9F5645 -> 0000000000000000 0EAC34C8A9F943893525078917 এর পরে হ্যাশ ফাংশন কল এবং real 14m24.970s user 48m42.410sসময়।

— vi।

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 বাইট ইনপুট কেবল উপেক্ষা করা হয়েছে।

— vi।

কোডটিতে বাগের মতো মনে হচ্ছে; সমাধান উপসর্গের পরিবর্তে প্রত্যয় যাচ্ছে।

— টুকুসি

1

নন-বাগ সংঘর্ষও রয়েছে (মূল প্রশ্নের মন্তব্য দেখুন)।

— vi।

2

রুবি, 90 বাইট, মেগা টম দ্বারা

4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873152

এবং

23495857395130010906345238767865073260629749745923180469417457686044416983587046050252582956302336

যা 2 এবং 11 এর পরে 40 জিরো বাইট রয়েছে। সুতরাং তাদের উভয় 41 বাইট আছে। প্রতিটি বাইট জন্য ইনপুট দৈর্ঘ্য দ্বারা হ্যাশ মান যোগ করা হয়, এবং তারপরে এটি দশমিক মধ্যে বিপরীত হয়। শেষ হওয়া একটি ইনপুট দৈর্ঘ্য 1হ্যাশ মানটি 0খুব দ্রুত শেষ হবে তা নিশ্চিত করতে পারে । তারপরে এটির বিপরীতকরণ হ্যাশ মানটির দৈর্ঘ্য 1 দ্বারা হ্রাস করে।

উভয়েরই হ্যাশ মান রয়েছে 259।

— jimmy23013
সূত্র

2

সি # - 393 বাইট - লিখেছেন: লোগান বাঁধ

70776e65642062792031333337206861786f72এবং 70776e65642062792031333337206861786f7200উভয় হ্যাশ 18E1C8E645F1BBD1।

— aaaaaaaaaaaa
সূত্র

শান্ত! আপনি কীভাবে এটি ফাটিয়েছিলেন তা আপনি ব্যাখ্যা করতে পারেন? এবং সম্ভবত "ত্রুটিপূর্ণ প্যাডিং"?

— ld

@ লোগানড্যাম এটি সমস্ত কোড যা ইনপুটটির চারপাশে স্যুইচ করে, আপনি 8 টি অক্ষরের একাধিক প্রসেসিং শেষ করেন এবং যদি ইনপুট দৈর্ঘ্য 8 এর একাধিক না হয় তবে আপনি শূন্যের বিকল্প রাখবেন। আমি যদি সঠিক জায়গায় কিছু শেরো যুক্ত করি তবে তারা কেবল প্যাডিংয়ের জায়গাটি নেয় যা প্রথম স্থানে শূন্য ছিল।

— aaaaaaaaaaaa

ক্রিপ্টোগ্রাফিক হ্যাশ গল্ফ (ডাকাত)

ক্রিপ্টোগ্রাফিক হ্যাশ গল্ফের সঙ্গী থ্রেড

কার্য

স্কোরিং

অতিরিক্ত বিধি

উদাহরণ

পাইথন 2.7, 22 বাইট দ্বারা ব্যবহারকারী 8675309

লিডারবোর্ড

কোড

ব্যাখ্যা

ব্যাখ্যা

ইসমাইল মিগুয়েল দ্বারা পিএইচপি 4.1, 66 বাইট