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

เนื่องจากลักษณะของความท้าทายตำรวจและโจรความท้าทายตำรวจกลายเป็นเรื่องง่ายขึ้นมากเมื่อความสนใจในความท้าทายโจรที่เกี่ยวข้องได้ลดลง ดังนั้นในขณะที่คุณยังสามารถโพสต์ฟังก์ชันแฮชคำตอบของคุณจะไม่ได้รับการยอมรับหรือเป็นส่วนหนึ่งของกระดานแต้มนำ

ความท้าทายนี้คือการค้นหาการใช้งานฟังก์ชันแฮชที่สั้นที่สุดที่ทนทานต่อการชนกล่าวคือควรหาข้อความที่แตกต่างกันสองข้อความที่มีแฮชเดียวกัน

ในฐานะตำรวจคุณพยายามคิดค้นและใช้ฟังก์ชันแฮชเพื่อหาการประนีประนอมที่ดีที่สุดระหว่างขนาดรหัสและการต่อต้านการชน ใช้จำนวนไบต์มากเกินไปและตำรวจอีกคนจะเร็วกว่าคุณ!

ในฐานะโจรคุณพยายามสกัดกั้นความพยายามของตำรวจโดยการทำหน้าที่ของพวกเขาให้แตกเพื่อพิสูจน์ว่าพวกเขาไม่เหมาะสม สิ่งนี้จะบังคับให้พวกเขาใช้จำนวนไบต์มากขึ้นเพื่อเสริมอัลกอริทึมของพวกเขา!

ตำรวจท้าทาย

งาน

ใช้การเข้ารหัสลับฟังก์ชันแฮชH: ฉัน -> Oที่คุณเลือกที่ฉันเป็นชุดของทั้งหมดไม่ integers เชิงลบด้านล่าง 2 ^{2 30}และOเป็นชุดของทั้งหมดไม่ integers เชิงลบด้านล่าง 2 128

คุณสามารถใช้Hเป็นฟังก์ชันจริงที่ยอมรับและส่งคืนจำนวนเต็มเดียวการแทนค่าสตริงของจำนวนเต็มหรืออาร์เรย์ของจำนวนเต็มหรือโปรแกรมเต็มรูปแบบที่อ่านจาก STDIN และพิมพ์ไปยัง STDOUT ในฐาน 10 หรือ 16

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

• Hว่ามันต้องต่อต้านความท้าทายโจรที่กำหนดไว้ด้านล่าง

  ถ้าโจรเอาชนะส่งของคุณใน 168 ชั่วโมงแรกหลังการโพสต์มันก็ถือว่าแตก

• การดำเนินการของHควรสั้นที่สุด การส่งที่ไม่ได้ติดตามที่สั้นที่สุดจะเป็นผู้ชนะของความท้าทายของตำรวจ

กฎเพิ่มเติม

• หากคุณใช้งานHเป็นฟังก์ชั่นโปรดใส่กระดาษห่อเพื่อใช้งานฟังก์ชั่นจากภายในโปรแกรมที่ทำงานตามที่อธิบายไว้ข้างต้น

• โปรดระบุเวกเตอร์ทดสอบอย่างน้อยสามรายการสำหรับโปรแกรมหรือ wrapper ของคุณ (ตัวอย่างอินพุตและเอาต์พุตที่สอดคล้องกัน)

• Hสามารถออกแบบนวนิยายของคุณ (ที่ต้องการ) หรืออัลกอริทึมที่รู้จักกันดีตราบใดที่คุณใช้มันด้วยตัวคุณเอง ห้ามมิให้ใช้ฟังก์ชั่นแฮชในตัว, ฟังก์ชั่นการบีบอัด, ตัวเลข, PRNG และอื่น ๆ

  ในตัวที่ใช้ทั่วไปในการใช้ฟังก์ชั่นแฮช (เช่นการแปลงฐาน) เป็นเกมที่ยุติธรรม

• ผลลัพธ์ของโปรแกรมหรือฟังก์ชั่นของคุณจะต้องกำหนดไว้ล่วงหน้า

• ควรมีคอมไพเลอร์ / ล่ามฟรี (เช่นเบียร์) ที่สามารถเรียกใช้บนแพลตฟอร์ม x86 หรือ x64 หรือจากภายในเว็บเบราว์เซอร์

• โปรแกรมหรือฟังก์ชั่นของคุณควรมีประสิทธิภาพพอสมควรและต้องแฮชข้อความใด ๆ ในIด้านล่าง 2 ^{2 19}ในเวลาน้อยกว่าหนึ่งวินาที

  สำหรับกรณีขอบเวลา (ผนัง) ที่ใช้ในเครื่องของฉัน (Intel Core i7-3770, RAM 16 GiB) จะแตกหัก

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

  หากการส่งของคุณแตก (หรือแม้ว่าจะยังไม่มี) คุณสามารถโพสต์คำตอบเพิ่มเติมได้

  หากคำตอบของคุณไม่ถูกต้อง (เช่นคำตอบนั้นไม่เป็นไปตามข้อกำหนด I / O) โปรดลบออก

ตัวอย่าง

Python 2.7, 22 ไบต์

def H(M):
 return M%17

เสื้อคลุม

print H(int(input()))

ความท้าทายของโจร

งาน

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

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

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

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

กฎเพิ่มเติม

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

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

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

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

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

ตัวอย่าง

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

1

และ

18

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

ส่งที่ปลอดภัย

1. CJam, 21 ไบต์โดย eBusiness
2. C ++, 148 ไบต์โดย tucuxi
3. C ++, 233 (?) ไบต์โดย Vi

ส่งที่ไม่ได้ติดตาม

คุณสามารถใช้ Stack Snippet นี้เพื่อรับรายการคำตอบที่ยังไม่ถอดรหัส

function g(p){$.getJSON('//api.stackexchange.com/2.2/questions/51068/answers?page='+p+'&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e',function(s){s.items.map(function(a){var h=$('<div/>').html(a.body).children().first().text();if(!/cracked/i.test(h)&&(typeof a.comments=='undefined'||a.comments.filter(function(b){var c=$('<div/>').html(b.body);return /^cracked/i.test(c.text())||c.find('a').filter(function(){return /cracked/i.test($(this).text())}).length>0}).length==0)){var m=/^\s*((?:[^,(\s]|\s+[^-,(\s])+)\s*(?:[,(]|\s-).*?([0-9]+)/.exec(h);$('<tr/>').append($('<td/>').append($('<a/>').text(m?m[1]:h).attr('href',a.link)),$('<td class="score"/>').text(m?m[2]:'?'),$('<td/>').append($('<a/>').text(a.owner.display_name).attr('href',a.owner.link))).appendTo('#listcontent');}});if(s.length==100)g(p+1);});}g(1);

table th, table td {padding: 5px} th {text-align: left} .score {text-align: right} table a {display:block}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><table><tr><th>Language</th><th class="score">Length</th><th>User</th></tr><tbody id="listcontent"></tbody></table>

CJam, 21 ไบต์

1q3*{i+_E_#*^26_#)%}/

รับค่าสตริงของไบต์เป็นอินพุต

ใน pseudocode:

hash = 1
3 times:
    for i in input:
        hash = hash + i
        hash = hash xor hash * 14^14
        hash = hash mod (26^26 + 1)
output hash

ตัวอย่างแฮช:

"" (สตริงว่าง) -> 1
"ทดสอบ" -> 2607833638733409808360080023081587841
"ทดสอบ" -> 3636404674245868955047381313373747474713 "

มันอาจจะเป็นบิตที่เรียบง่ายช่วงเอาท์พุทเป็นเพียงมากกว่า 122 บิตเล็กน้อยการทำซ้ำที่เพิ่มขึ้นสามเท่านั้นแตกหักเล็กน้อยเพราะมันทำสิ่งเดียวกันทุกครั้งดังนั้นอินพุตที่แฮ็กถึง 1 ในครั้งแรก การวนซ้ำจะเป็นการพักเต็ม แต่มันสั้นและไม่มีความสนุกที่จะปลอดภัยเกินไป

งูหลาม 109 ไบต์ [ แตก , และอีกครั้ง ]

def f(n,h=42,m=2**128):
 while n:h+=n&~-m;n>>=128;h+=h<<10;h^=h>>6;h%=m
 h+=h<<3;h^=h>>11;h+=h<<15;return h%m

ฉันลองใช้ฟังก์ชั่นครั้งละครั้งของเจนกินส์ตามที่เป็นจริงโดยมีความแตกต่างเพียงอย่างเดียวคือเมล็ดและจำนวนบิต

สนุกจริง: เห็นได้ชัดPerl ใช้กัญชาเจนกินส์ในบางจุด

เสื้อคลุม

print(f(int(input())))

ตัวอย่าง

>>> f(0)
12386682
>>> f(1)
13184902071
>>> f(2**128-1)
132946164914354994014709093274101144634
>>> f(2**128)
13002544814292
>>> f(2**128+1)
13337372262951
>>> f(2**(2**20))
290510273231835581372700072767153076167

C ++, 148 ไบต์

typedef __uint128_t U;U h(char*b,U n,U&o){U a=0x243f6a8885a308d,p=0x100000001b3;for(o=a;n--;)for(U i=27;--i;){o=(o<<i)|(o>>(128-i));o*=p;o^=b[n];}}

__uint128_tเป็นส่วนขยาย GCC และทำงานได้ตามที่คาดไว้ แฮชจะขึ้นอยู่กับการทำซ้ำแฮช FNV (ฉันยืมนายกของพวกเขาแม้ว่าจะaเป็นตัวเลขแรกของ Pi ในฐานสิบหก) ด้วยการหมุนsha1 เหมือนตอนเริ่มต้นของการทำซ้ำแต่ละครั้ง การคอมไพล์ด้วย-O3ไฟล์ hashing ขนาด 10MB ใช้เวลาไม่เกิน 2 วินาทีดังนั้นยังมีระยะขอบสำหรับการทำซ้ำวนซ้ำในวงใน - แต่วันนี้ฉันรู้สึกใจกว้าง

De-uglified (เปลี่ยนชื่อตัวแปรเพิ่มคอมเม้นท์ช่องว่างและวงเล็บปีกกา) เพื่อความพึงพอใจของคุณ:

typedef __uint128_t U;
U h(char* input, U inputLength, U &output){
    U a=0x243f6a8885a308d,p=0x100000001b3;    
    for(output=a;inputLength--;) {   // initialize output, consume input
        for(U i=27;--i;) {                          // evil inner loop
            output = (output<<i)|(output>>(128-i)); // variable roll 
            output *= p;                            // FNV hash steps
            output ^= input[inputLength];        
        }
    }
    // computed hash now available in output
}

ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ (แม้ว่าฉันจะไม่ได้รับการปรับปรุงรหัสตามพวกเขา)

แก้ไข: ความผิดพลาดคงที่ในรหัส de-uglified (รุ่น golfed ยังคงไม่เปลี่ยนแปลง)

CJam, 44 ไบต์ [ แตก ]

lW%600/_z]{JfbDbGK#%GC#[md\]}%z~Bb4G#%\+GC#b

อินพุตอยู่ในฐาน 10

CJam ช้า ฉันหวังว่ามันจะทำงานใน 1 วินาทีในคอมพิวเตอร์บางเครื่อง ...

คำอธิบาย

lW%600/            e# Reverse, and split into chunks with size 600.
_z                 e# Duplicate and swap the two dimensions.
]{                 e# For both versions or the array:
    JfbDb          e# Sum of S[i][j]*13^i*19^j, where S is the character values,
                   e# and the indices are from right to left, starting at 0.
    GK#%GC#[md\]   e# Get the last 32+48 bits.
}%
z~                 e# Say the results are A, B, C, D, where A and C are 32 bits.
Bb4G#%             e# E = the last 32 bits of A * 11 + C.
\+GC#b             e# Output E, B, D concatenated in binary.

ดูเหมือนว่าสิ่งสองมิตินั้นจะเป็นจุดอ่อน ... มันมีจุดประสงค์เพื่อให้การคำนวณช้ากว่าเดิมในตอนแรก แต่มันไม่สามารถทำงานได้ในไม่ช้าไม่ว่าฉันจะทำอะไรฉันก็เลยลบรหัสช้าออกในที่สุด

มันควรจะดีกว่านี้ถ้าฉันใช้เลขฐานสองและฐานที่สูงกว่า

รุ่น C

__uint128_t hash(unsigned char* s){
    __uint128_t a=0,b=0;
    __uint128_t ar=0;
    __uint128_t v[600];
    int l=0,j=strlen(s);
    memset(v,0,sizeof v);
    for(int i=0;i<j;i++){
        if(i%600)
            ar*=19;
        else{
            a=(a+ar)*13;
            ar=0;
        }
        if(i%600>l)
            l=i%600;
        v[i%600]=v[i%600]*19+s[j-i-1];
        ar+=s[j-i-1];
    }
    for(int i=0;i<=l;i++)
        b=b*13+v[i];
    a+=ar;
    return (((a>>48)*11+(b>>48))<<96)
        +((a&0xffffffffffffull)<<48)
        +(b&0xffffffffffffull);
}

C ++, 182 ตัวอักษร (+ สำเร็จรูปประมาณ 51 ตัว)

h=0xC0CC3051F486B191;j=0x9A318B5A176B8125;char q=0;for(int i=0;i<l;++i){char w=buf[i];h+=((w<<27)*257);j^=(h+0x5233);h+=0xAA02129953CC12C3*(j>>32);j^=(w+0x134)*(q-0x16C552F34);q=w;}

ต้นแบบ:

void hash(const unsigned char* buf, size_t len, unsigned long long *hash1, unsigned long long *hash2)
{
    unsigned long long &h=*hash1;
    unsigned long long &j=*hash2;
    size_t l = len;
    const unsigned char* b = buf;

    // code here
}

โปรแกรมที่รันได้พร้อมฟังก์ชั่น golfed

#include <stdio.h>

// The next line is 227 characters long
int hash(char*b,int l,long long&h,long long&j){h=0xC0CC3051F486B191;j=0x9A318B5A176B8125;char q=0;for(int i=0;i<l;++i){char w=b[i];h+=((w<<27)*257);j^=(h+0x5233);h+=0xAA02129953CC12C3*(j>>32);j^=(w+0x134)*(q-0x16C552F34);q=w;}}

int main() {
    char buf[1024];
    int l  = fread(buf, 1, 1024, stdin);
    long long q, w;
    hash(buf, l, q, w);
    printf("%016llX%016llX\n", q, w);
}

Pyth, 8 แคร็ก

sv_`.lhQ

ลองออนไลน์

ฉันจะอธิบายวิธีการทำงานเพราะคนส่วนใหญ่ไม่สามารถอ่าน Pyth นี่จะใช้บันทึกตามธรรมชาติของหนึ่งบวกกับอินพุตจากนั้นแปลงเป็นสตริง สตริงนั้นจะถูกย้อนกลับจากนั้นประเมินค่าแล้วแปลงเป็นจำนวนเต็ม

การแปลภาษาไพ ธ อนมีลักษณะดังนี้:

import math
n = eval(input()) + 1
rev = str(math.log(n))[::-1]
print(int(eval(rev)))

Python 3, 216 ไบต์ [ แตก ]

def f(m):
 h=1;p=[2]+[n for n in range(2,102)if 2**n%n==2];l=len(bin(m))-2;*b,=map(int,bin((l<<(l+25)//26*26)+m)[2:])
 while b:
  h*=h
  for P in p:
   if b:h=h*P**b.pop()%0xb6ee45a9012d1718f626305a971e6a21
 return h

เนื่องจากความไม่ลงรอยกันกับสเป็คฉันสามารถคิดได้ว่ามีช่องโหว่เล็กน้อยอย่างน้อยหนึ่งช่องทาง แต่นอกเหนือจากนั้นฉันคิดว่านี่เป็นข้อพิสูจน์ที่โหดร้ายอย่างน้อยที่สุด ฉันได้ตรวจสอบแฮช 10 ล้านครั้งแรกเหนือสิ่งอื่นใด

ในแง่ของการเล่นกอล์ฟสิ่งนี้จะสั้นลงใน Python 2 แต่ฉันได้เสียสละบางอย่างเพื่อประสิทธิภาพ (เนื่องจากอาจไม่ชนะเลย)

แก้ไข: นี่คือความพยายามของฉันในการใช้แฮชที่ราบรื่นมากแต่น่าเสียดายที่ 128 บิตนั้นเล็กเกินไป

เสื้อคลุม

print(f(int(input())))

ตัวอย่าง

>>> f(0)
2
>>> f(123456789)
228513724611896947508835241717884330242
>>> f(2**(2**19)-1)
186113086034861070379984115740337348649
>>> f(2**(2**19))
1336078

คำอธิบายรหัส

def f(m):
 h=1                                             # Start hash at 1
 p=[2]+[n for n in range(2,102)if 2**n%n==2]     # p = primes from 2 to 101
 l=len(bin(m))-2                                 # l = bit-length of m (input)
 *b,=map(int,bin((l<<(l+25)//26*26)+m)[2:])      # Convert bits to list, padding to
                                                 # a multiple of 26 then adding the
                                                 # bit-length at the front

 while b:                                        # For each round
  h*=h                                           # Square the hash
  for P in p:                                    # For each prime in 2 ... 101
   if b:h=(h*P**b.pop()                          # Multiply by prime^bit, popping
                                                 # the bit from the back of the list
           %0xb6ee45a9012d1718f626305a971e6a21)  # Take mod large number

 return h                                        # Return hash

ตัวอย่างของ padding สำหรับf(6):

[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0]

(len 3)(------------------ 23 zeroes for padding -------------------------)(input 6)
       (---------------------------- length 26 total ------------------------------)

C, 87 ไบต์ [ แตก ]

นี่เป็นโปรแกรมที่สมบูรณ์ ไม่จำเป็นต้องห่อหุ้ม ยอมรับอินพุตไบนารีผ่าน stdin และเอาต์พุตแฮชเลขฐานสิบหกเป็น stdout

c;p;q;main(){while((c=getchar())+1)p=p*'foo+'+q+c,q=q*'bar/'+p;printf("%08x%08x",p,q);}

สิ่งนี้คำนวณเฉพาะแฮชแบบ 64 บิตดังนั้นฉันจึงเสี่ยงโชคเล็กน้อย

ในกรณีที่ทุกคนสงสัยทั้งสองค่าคงที่'foo+'และ'bar/'เป็นหมายเลขเฉพาะ 1718578987 และ 1650553391

ตัวอย่าง:

ละเว้นเลขศูนย์นำหน้า:

echo -ne '\x00\x00\x00\x00' |./hash
0000000000000000

อินพุตไบต์เดียว:

echo -ne '\x01' |./hash
0000000100000001
echo -ne '\xff' |./hash
000000ff000000ff

อินพุตแบบหลายไบต์:

echo -ne '\x01\x01' |./hash
666f6f2dc8d0e15c
echo -ne 'Hello, World' |./hash
04f1a7412b17b86c

J - 39 ไบต์ - แตก

ฟังก์ชั่นการสตริงเป็น input และกลับมาเป็นจำนวนเต็ม <2 128 ฉันสมมติว่าเราต้องตั้งชื่อฟังก์ชั่นของเราให้ถูกต้องดังนั้นให้ปล่อยอีก 3 ตัวอักษรจากการนับถ้าเราสามารถส่งฟังก์ชั่นที่ไม่ระบุชื่อได้

H=:_8(".p:@+5,9:)a\(a=.(2^128x)&|@^/@)]

สำหรับบรรดาของคุณที่ไม่ได้อ่านอักษรอียิปต์โบราณนี่เป็นบทสรุปของสิ่งที่ฉันทำ

• a=.(2^128x)&|@^/@นี่คือ * ย่อยซึ่งจะมีอาร์เรย์ของตัวเลขและจากนั้นจะถือว่าเป็นหอคอยพลังงานที่จะได้รับการยกกำลัง 2 mod 128 โดย "หออำนาจ" ผมหมายถึงถ้าคุณให้มันป้อนข้อมูลก็จะคำนวณ3 4 5 63 ^ (4 ^ (5 ^ 6))
• (".p:@+5,9:)aฟังก์ชันนี้ใช้สตริงแปลงเป็นตัวเลขNจากนั้นคำนวณจำนวนเฉพาะ ( n +5) -th และ ( n +9) -th จากนั้นจึงส่งค่าaจากก่อนหน้าลงไป นั่นคือเราพบp(n+5) ^ p(n+9)mod 2 ¹²⁸ซึ่งp(k)เป็นkอันดับที่
• H=:_8...\(a...)]ดำเนินการฟังก์ชันข้างต้นใน subblocks 8 ตัวอักษรของการป้อนข้อมูลและจากนั้นทุกผลเข้าด้วยกันและเรียกใช้ฟังก์ชันแฮชที่เกิดa Hผมใช้ 8 ตัวอักษรเพราะเจ " k-th สำคัญ" ฟังก์ชั่นล้มเหลวเมื่อp(k)> 2 ^{วันที่ 31}คือเป็นความปลอดภัยที่ใหญ่ที่สุดk=105097564k

มีเอาต์พุตตัวอย่างบางส่วน คุณสามารถลองด้วยตัวเองแบบออนไลน์ที่tryj.tkแต่ผมแนะนำให้ทำเช่นนี้ที่บ้านโดยการดาวน์โหลดล่ามจากJsoftware

   H=:_8(".p:@+5,9:)a\(a=.(2^128x)&|@^/@)]
   H '88'
278718804776827770823441490977679256075
   H '0'
201538126434611150798503956371773
   H '1'
139288917338851014461418017489467720433
   H '2'
286827977638262502014244740270529967555
   H '3'
295470173585320512295453937212042446551
   30$'0123456789'  NB. a 30 character string
012345678901234567890123456789
   H 30$'0123456789'
75387099856019963684383893584499026337
   H 80$'0123456789'
268423413606061336240992836334135810465

* ในทางเทคนิคมันไม่ใช่ฟังก์ชั่นในและของมันมันแนบกับฟังก์ชั่นอื่น ๆ และทำหน้าที่ในการส่งออกของพวกเขา แต่นี่เป็นประเด็นทางความหมายของ J ไม่ใช่ความแตกต่างทางแนวคิด: โฟลว์โปรแกรมเป็นอย่างที่ฉันอธิบายไว้ข้างต้น

Python 3, 118 ไบต์ [ แตก ]

def H(I):
    o=0;n=3;M=1<<128
    for c in I:i=ord(c);o=(o<<i^o^i^n^0x9bb90058bcf52d3276a7bf07bcb279b7)%M;n=n*n%M
    return o

การเยื้องเป็นแท็บเดียว แฮชแบบง่ายยังไม่ได้ทดสอบอย่างละเอียด

โทรไปที่:

print(H("123456789"))

ผล: 73117705077050518159191803746489514685

C ++, 239 ไบต์

กอล์ฟรหัสแรกของฉัน! [ กรุณาอ่อนโยน ]

#define r(a,b) ((a<<b)|(a>>(64-b)))
typedef uint64_t I;I f(I*q, I n, I&h){h=0;for(I i=n;--i;)h=r(h^(r(q[i]*0x87c37b91114253d5,31)*0x4cf5ad432745937f),31)*5+0x52dce729;h^=(h>>33)*0xff51afd7ed558ccd;h^=(h>>33)*0xc4ceb9fe1a85ec53;h^=(h>>33);}

เวอร์ชันที่ไม่ถูกปรับแต่ง:

I f(I* q, I n, I& h) // input, length and output
{
    h = 0; // initialize hashes
    for (I i=n;--i;)
    {
        q[i] *= 0x87c37b91114253d5;
        q[i]  = rotl(q[i], 31);
        q[i] *= 0x4cf5ad432745937f;

        h ^= q[i]; // merge the block with hash

        h *= rotl(h, 31);
        h = h * 5 + 0x52dce729;
    }
    h ^= h>>33;
    h *= 0xff51afd7ed558ccd;
    h ^= h>>33;
    h *= 0xc4ceb9fe1a85ec53; // avalanche!
    h ^= h>>33;
}

ไม่ใช่แฮชที่ดีที่สุดและไม่ใช่รหัสสั้นที่สุดที่มีอยู่ ยอมรับเคล็ดลับการเล่นกอล์ฟและหวังว่าจะปรับปรุง!

เสื้อคลุม

อาจไม่ใช่สิ่งที่ดีที่สุดในโลก แต่เป็นเสื้อคลุม

I input[500];

int main()
{
    string s;
    getline(cin, s);
    memcpy(input, s.c_str(), s.length());
    I output;
    f(input, 500, output);
    cout << hex << output << endl;
}

Java, 299 291 282 ไบต์แตก

import java.math.*;class H{public static void main(String[]a){BigInteger i=new java.util.Scanner(System.in).nextBigInteger();System.out.print(BigInteger.valueOf(i.bitCount()*i.bitLength()+1).add(i.mod(BigInteger.valueOf(Long.MAX_VALUE))).modPow(i,BigInteger.valueOf(2).pow(128)));}}

ไม่ดำเนินการบางอย่างใน BigIntegers แล้วจะเกิดผลแบบโมดูโล 2 128

C, 128 ไบต์ [ แตก ]

p;q;r;s;main(c){while((c=getchar())+1)p=p*'foo+'+s^c,q=q*'bar/'+p,r=r*'qux3'^q,s=s*'zipO'+p;printf("%08x%08x%08x%08x",p,q,r,s);}

นี่เป็นอัลกอริทึมเดียวกับความพยายามครั้งล่าสุดของฉัน (แตกโดย Vi)แต่ตอนนี้มีล้อแฮมสเตอร์เพียงพอที่จะสร้างแฮชที่เหมาะสม 128 บิต

ค่าคงที่สี่หลักในรหัสมีดังนี้:

'foo+' = 1718578987
'bar/' = 1650553391
'qux3' = 1903523891
'zipO' = 2053730383

ก่อนหน้านี้เป็นโปรแกรมที่สมบูรณ์แบบโดยไม่จำเป็นต้องใช้กระดาษห่อหุ้ม จำนวนเต็มฉันป้อนผ่าน stdin เป็นข้อมูลไบนารีดิบ (ใหญ่สุด) และ hash Oถูกพิมพ์ในฐานสิบหกเป็น stdout เลขศูนย์นำหน้าในฉันจะถูกละเว้น

ตัวอย่าง:

echo -ne '\x00' |./hash
00000000000000000000000000000000
echo -ne '\x00\x00' |./hash
00000000000000000000000000000000
echo -ne '\x01' |./hash
00000001000000010000000100000001
echo -ne 'A' |./hash
00000041000000410000004100000041
echo -ne '\x01\x01' |./hash
666f6f2dc8d0e15cb9a5996fe0d8df7c
echo -ne 'Hello, World' |./hash
da0ba2857116440a9bee5bb70d58cd6a

C, 122 ไบต์ [ แตก ]

long long x,y,p;main(c){for(c=9;c|p%97;c=getchar()+1)for(++p;c--;)x=x*'[3QQ'+p,y^=x^=y^=c*x;printf("%016llx%016llx",x,y);}

ลูปซ้อนซ้อน LCG แบบครึ่งทางและการสลับตัวแปร จะไม่รักอะไร

นี่คือรุ่นที่ไม่ได้นำมาเล่นกับ:

long long x,y,p;

int main(int c){
    // Start with a small number of iterations to
    //   get the state hashes good and mixed because initializing takes space
    // Then, until we reach the end of input (EOF+1 == 0)
    //   and a position that's a multiple of 97
    for (c=9;c|p%97;c=getchar()+1) {

        // For each input c(haracter) ASCII value, iterate down to zero
        for (++p;c--;) {

            // x will act like a LCG with a prime multiple
            //   partially affected by the current input position
            // The string '[3QQ' is the prime number 0x5B335151
            x=x*'[3QQ'+p;

            // Mix the result of x with the decrementing character
            y^=c*x;

            // Swap the x and y buffers
            y^=x^=y;
        }
    }

    // Full 128-bit output
    printf("%016llx%016llx",x,y);
    return 0;
}

นี่เป็นโปรแกรมที่บรรจุในตัวเองอย่างสมบูรณ์ที่อ่านจาก STDIN และพิมพ์ไปยัง STDOUT

ตัวอย่าง:

> echo -n "Hello world" | ./golfhash
b3faef341f70c5ad6eed4c33e1b55ca7

> echo -n "" | ./golfhash
69c761806803f70154a7f816eb3835fb

> echo -n "a" | ./golfhash
5f0e7e5303cfcc5ecb644cddc90547ed

> echo -n "c" | ./golfhash
e64e173ed4415f7dae81aae0137c47e5

ในการวัดประสิทธิภาพอย่างง่ายมันจะทำการแฮชข้อมูลข้อความประมาณ 3MB / s ความเร็วการแฮชขึ้นอยู่กับข้อมูลอินพุตเองดังนั้นจึงควรนำมาพิจารณาด้วย

PHP 4.1, 66 ไบต์ [ แตก ]

ฉันแค่อุ่นขึ้น

ฉันหวังว่าคุณจะพบการทำลายนี้

<?for($l=strlen($b.=$a*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

ฉันได้พยายามตัวเลขมันมีขนาดใหญ่เป็น 999999999999999999999999999.
เอาท์พุทดูเหมือนจะเป็นภายใน 2 ¹²⁸ช่วง

ต้องใช้ PHP 4.1 เนื่องจากregister_globalsคำสั่ง

มันทำงานโดยการสร้างตัวแปรท้องถิ่นจากเซสชั่น, POST, GET, คำขอและคุกกี้โดยอัตโนมัติ

aจะใช้กุญแจ (EG: การเข้าถึงhttp://localhost/file.php?a=<number>)

ถ้าคุณต้องการทดสอบด้วย PHP 4.2 และใหม่กว่าลองสิ่งนี้:

<?for($l=strlen($b.=$a=$_REQUEST['a']*1);$i<40;$o.=+$b[+$i]^"$a"/$a,$i++);echo$o;

รุ่นนี้ใช้ได้กับ POST และ GET เท่านั้น

ตัวอย่างผลลัพธ์:

0 -> 0000000000000000000000000000000000000000
9 -> 8111111111111111111111111111111111111111
9999 -> 8888111111111111111111111111111111111111
1234567890 -> 0325476981111111111111111111111111111111
99999999999999999999999999999999999999999999999999999999999999999999999999999999 -> 0111191111111111111111111111111111111111

(ฉันรับรองกับคุณว่ามีตัวเลขที่สร้างแฮชเดียวกัน)

C, 134 ไบต์, แคร็ก

นี่คือโปรแกรม C ที่สมบูรณ์

long long i=0,a=0,e=1,v,r;main(){for(;i++<323228500;r=(e?(scanf("%c",&v),e=v>'/'&&v<':',v):(a=(a+1)*7)*(7+r)));printf("0x%llx\n", r);}

มันทำอะไร: ความคิดคือการป้อนข้อมูลเป็นอาร์เรย์ไบต์และผนวกแบบสุ่มหลอก (แต่กำหนดขึ้นได้) ไบต์ในตอนท้ายเพื่อให้ความยาวเท่ากับ 2 ^{2 30} (อีกเล็กน้อย) การใช้งานจะอ่านอินพุตไบต์ต่อไบต์และเริ่มใช้ข้อมูลสุ่มหลอกเมื่อพบอักขระตัวแรกที่ไม่ใช่ตัวเลข

เนื่องจาก builtin PRNG ไม่ได้รับอนุญาต

มีพฤติกรรมที่ไม่ได้กำหนด / การใช้งานที่กำหนดไว้ซึ่งทำให้รหัสสั้นลง (ค่าสุดท้ายควรไม่ได้ลงนามและฉันควรใช้ประเภทที่แตกต่างกันสำหรับค่าที่แตกต่างกัน) และฉันไม่สามารถใช้ค่า 128 บิตใน C เวอร์ชันที่สับสนน้อยลง:

long long i = 0, prand = 0, notEndOfInput = 1, in, hash;

main() {
    for (; i++ < 323228500;) {
        if (notEndOfInput) {
            scanf("%c", &in);
            notEndOfInput = in >= '0' && in <= '9';
            hash = in;
        } else {
            prand = (prand + 1)*7;
            hash = prand*(7 + hash);
        }
    }
    printf("0x%llx\n", hash);
}

Python 2.X - 139 bytes [[ Cracked ]]

นี่ค่อนข้างคล้ายกับอื่น ๆ ทั้งหมด (LOOP, XOR, SHIFT, ADD) แฮชที่นี่ มารับคะแนนโจรของคุณ;) ฉันจะทำให้ยากขึ้นหลังจากนี้ได้รับการแก้ไข

M=2**128
def H(I):
 A=[1337,8917,14491,71917];O=M-I%M
 for z in range(73):
  O^=A[z%4]**(9+I%9);O>>=3;O+=9+I**(A[z%4]%A[O%4]);O%=M
 return O

Wrapper (คาดว่าจะมีอาร์กิวเมนต์หนึ่งตัวในฐาน -16 หรือที่เรียกว่าเลขฐานสิบหก):

import sys
if __name__ == '__main__':
 print hex(H(long(sys.argv[1], 16)))[2:][:-1].upper()

Python 2.7 - 161 bytes [[ แคร็ก ]]

เนื่องจากฉันจัดการเปลี่ยนฟังก์ชันแฮชแรกของฉันเป็นเวอร์ชันที่ไม่มีประโยชน์ก่อนที่จะโพสต์ฉันคิดว่าฉันจะโพสต์โครงสร้างที่คล้ายกันอีกเวอร์ชัน เวลานี้ฉันทดสอบกับการชนกันเล็กน้อยและฉันทดสอบขนาดอินพุตที่เป็นไปได้สำหรับความเร็ว

A=2**128;B=[3,5,7,11,13,17,19]
def H(i):
 o=i/A
 for r in range(9+B[i%7]):
  v=B[i%7];i=(i+o)/2;o=o>>v|o<<128-v;o+=(9+o%6)**B[r%6];o^=i%(B[r%6]*v);o%=A
 return o

แรปเปอร์ (ไม่นับใน bytecount)

import sys
if __name__ == '__main__':
 arg = long(sys.argv[1].strip(), 16)
 print hex(H(arg))[2:][:-1].upper()

เรียกใช้ตัวอย่าง (อินพุตเป็นเลขฐานสิบหกเสมอ):

$ python crypt2.py 1
3984F42BC8371703DB8614A78581A167
$ python crypt2.py 10
589F1156882C1EA197597C9BF95B9D78
$ python crypt2.py 100
335920C70837FAF2905657F85CBC6FEA
$ python crypt2.py 1000
B2686CA7CAD9FC323ABF9BD695E8B013
$ python crypt2.py 1000AAAA
8B8959B3DB0906CE440CD44CC62B52DB

Ruby, 90 ไบต์

def H(s);i=823542;s.each_byte{|x|i=(i*(x+1)+s.length).to_s.reverse.to_i%(2**128)};i;end

อัลกอริทึมแฮชแบบสุ่มสูงที่ฉันสร้างขึ้นโดยไม่ดูแฮชจริง ๆ ... ไม่รู้เลยว่ามันดี มันต้องใช้สตริงเป็นอินพุต

wrapper:

def buildString(i)
  if(i>255)
    buildString(i/256)+(i%256).chr
  else
    i.chr
  end
end 
puts H buildString gets

Mathematica 89 ไบต์แตก

Last@CellularAutomaton[(a=Mod)[#^2,256],{#~IntegerDigits~2,0},{#~a~99,128}]~FromDigits~2&

ไม่สั้นที่สุด

PHP, 79 ไบต์ (แตกด้วยความคิดเห็น):

echo (('.'.str_replace('.',M_E*$i,$i/pi()))*substr(pi(),2,$i%20))+deg2rad($i);

สิ่งนี้ทำสิ่งที่น่ากลัวมากมายผ่านการแปลงประเภทใน php ซึ่งทำให้ยากต่อการคาดเดา;) (หรืออย่างน้อยฉันก็หวังเช่นนั้น) ไม่ใช่คำตอบที่สั้นที่สุดหรืออ่านไม่ได้มากที่สุด

ในการรันคุณสามารถใช้PHP4 และลงทะเบียน globals (ด้วย? i = 123) หรือใช้ commandline:

php -r "$i = 123.45; echo (('.'.str_replace('.',M_E*$i,$i/pi()))*substr(pi(),2,$i%20))+deg2rad($i);"

C # - 393 ไบต์แตก

using System;class P{static void Main(string[]a){int l=a[0].Length;l=l%8==0?l/8:l/8+1;var b=new byte[l][];for(int i=0;i<l;i++){b[i]=new byte[8];};int j=l-1,k=7;for(int i=0;i<a[0].Length;i++){b[j][k]=Convert.ToByte(""+a[0][i],16);k--;if((i+1)%8==0){j--;k=7;}}var c=0xcbf29ce484222325;for(int i=0;i<l;i++){for(int o=0;o<8;o++){c^=b[i][o];c*=0x100000001b3;}}Console.WriteLine(c.ToString("X"));}}

Ungolfed:

using System;
class P
{
    static void Main(string[]a)
    {
      int l = a[0].Length;
      l = l % 8 == 0 ? l / 8 : l / 8 + 1;
      var b = new byte[l][];
      for (int i = 0; i < l; i++) { b[i] = new byte[8]; };
      int j = l-1, k = 7;
      for (int i = 0; i < a[0].Length; i++)
      {
        b[j][k] = Convert.ToByte(""+a[0][i], 16);
        k--;
        if((i+1) % 8 == 0)
        {
          j--;
          k = 7;
        }
      }
      var c = 0xcbf29ce484222325;
      for (int i = 0; i < l; i++)
      {
        for (int o = 0; o < 8; o++)
        {
          c ^= b[i][o];
          c *= 0x100000001b3;
        }
      }
      Console.WriteLine(c.ToString("X"));
    }
}

ฉันไม่เคยสัมผัสวิทยาการเข้ารหัสลับหรือ hashing ในชีวิตของฉันดังนั้นอ่อนโยน :)

มันใช้งานง่ายของแฮชFNV-1a ที่มีการหมุนแถวเรียงบนอินพุต ฉันแน่ใจว่ามีวิธีที่ดีกว่าในการทำเช่นนี้ แต่นี่คือสิ่งที่ดีที่สุดที่ฉันสามารถทำได้

อาจใช้หน่วยความจำเล็กน้อยในอินพุตที่ยาว

Python 2, 115 ไบต์ [ แคร็กเรียบร้อยแล้ว! ]

ตกลงนี่เป็นความพยายามครั้งสุดท้ายของฉัน เพียง 115 ไบต์เพราะไม่จำเป็นต้องขึ้นบรรทัดใหม่

h,m,s=1,0,raw_input()
for c in[9+int(s[x:x+197])for x in range(0,len(s),197)]:h+=pow(c,257,99**99+52)
print h%4**64

นี่เป็นโปรแกรมที่สมบูรณ์ที่ป้อนเลขจำนวนเต็มฐานสิบบน stdin และพิมพ์ค่าแฮชทศนิยมบน stdout เลขศูนย์นำหน้าพิเศษจะส่งผลให้มีค่าแฮชที่แตกต่างกันดังนั้นฉันจะสมมติว่าอินพุตไม่มี

สิ่งนี้ทำงานโดยการบรรจุชิ้นส่วนจำนวน 197 หลักของหมายเลขอินพุตผ่านการยกกำลังแบบแยกส่วน int()ฟังก์ชันนี้มีค่าเริ่มต้นเป็นฐาน 10 เสมอซึ่งแตกต่างจากบางภาษาบางฟังก์ชันเช่นint('077')77 ไม่ใช่ 63

ตัวอย่างผลลัพธ์:

$ python hash.py <<<"0"
340076608891873865874583117084537586383

$ python hash.py <<<"1"
113151740989667135385395820806955292270

$ python hash.py <<<"2"
306634563913148482696255393435459032089

$ python hash.py <<<"42"
321865481646913829448911631298776772679

$ time python hash.py <<<`python <<<"print 2**(2**19)"`
233526113491758434358093601138224122227

real    0m0.890s   <-- (Close, but fast enough)
user    0m0.860s
sys     0m0.027s