15

इस कोड-गोल्फ का लक्ष्य एक प्रोग्राम बनाना है जो इनपुट के रूप में एक स्ट्रिंग लेता है, और आपको हेक्साडेसिमल संख्या के रूप में SHA-1 हैश मान का उत्पादन करना होगा । आप यहां SHA-1 के लिए छद्म कोड पा सकते हैं

अन्य नियम:

कोई नेटवर्क एक्सेस नहीं
आपको बाहरी कार्यक्रम चलाने की अनुमति नहीं है
आपको इनपुट को हैश करने के लिए अंतर्निहित विधियों का उपयोग करने की अनुमति नहीं है
सबसे छोटा कोड जीतता है
यह केवल ASCII इनपुट को संभालने के लिए आवश्यक है
आउटपुट या तो लोअरकेस या अपरकेस हो सकता है
इनपुट का उपयोग करके प्रदान किया जा सकता है:
1. इनपुट के लिए शीघ्र
2. कमांड-लाइन तर्कों का उपयोग करना
3. STDIN का उपयोग करना

परीक्षण के मामलों:

Input: The quick brown fox jumps over the lazy dog
Output: 2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
----------------------------------------------------------
Input: The quick brown fox jumps right over the lazy dog
Output: 1c3aff41d97ada6a25ae62f9522e4abd358d741f
------------------------------------------------------------
Input: This is a code golf challenge
Output: f52ff9edd95d98e707bd16a7dead459cb8db8693

code-golf hashing

— ProgramFOX
स्रोत

5

गोल्फस्क्रिप्ट, 374 322 वर्ण

[128]+.,.~55+64%1,*\(8*2
32?:?.*+256{base}:B~1>++"!Vi9y BRQ+@phoKD5Vj=]30z0"{96@32-*+}*?B\64/{4/{256B}%{0'=820'{64-
2$=^}/2*.?/+?%+}64*1$'&4$?(^3$&|1518500249{++[]@+@+@?*4/.?/+?%+2$+\@32*.?/++@(@+?%@-1%+}:Y~
^2$^1859775393Y
&4$3$&|3$3$&|2400959708Y
^2$^3395469782Y'n/{'~3$3$'\+20*~}/+]zip{~+?%}%}/{?+16B{.9>7*+48+}%1>}%''+

यह गोल्फस्क्रिप्ट में छद्म कोड के सटीक कार्यान्वयन पर आधारित है और कोड को छोटा करने के लिए कुछ मामूली एन्कोडिंग हैं ( ऑनलाइन प्रयास करें )। इनपुट STDIN से पढ़ा जाएगा।

— हावर्ड
स्रोत

पी: यह सबसे लंबे समय तक GolfScript मैंने आज तक देखा है

— दरवाज़े

5

पायथन 3 - 645 चार्ट

h=0x67452301,0xEFCDAB89,0x98BADCFE,0x10325476,0xC3D2E1F0
L=lambda v,s:(v<<s|v>>B-s)%2**B
B=32
R=range
m=input().encode()
l=len(m)
m+=b'\x80'+bytes((55-l)%64)+m.fromhex(hex(2**64+l*8)[3:])
for C in [m[i:i+64]for i in R(0,len(m),64)]:
 w=[sum(C[i+j]<<8*(3-j)for j in R(4))for i in R(0,64,4)];a,b,c,d,e=h
 for i in R(16,80):w+=[L(w[i-3]^w[i-8]^w[i-14]^w[i-16],1)]
 for i in R(80):f=[b&c|~b&d,b^c^d,b&c|b&d|c&d,b^c^d][i//20];k=[0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6][i//20];t=L(a,5)+f+e+k+w[i];e=d;d=c;c=L(b,30);b=a;a=t%2**32
 g=a,b,c,d,e;h=[(h[i]+g[i])%2**32for i in R(5)]
B=160
print('%x'%(L(h[0],128)|L(h[1],96)|L(h[2],64)|L(h[3],32)|h[4]))

बस छद्मकोड का एक गोल्फ संस्करण।

— gRC
स्रोत

python3 में utf = u8 क्या है?

— आप

1

@ यूओयू हां, वह भी काम करता है। मैंने अभी जाँच की है और यह पता चला है कि .encode()डिफ़ॉल्ट रूप से UTF-8 का उपयोग किया जाता है , जो और भी छोटा है।

— grc

2

डी (759 वर्ण)

ऑनलाइन निष्पादन योग्य संस्करण: http://dpaste.dzfl.pl/f0c8508f

import std.range,std.algorithm,std.bitmanip,std.stdio:g=writef;
void main(char[][]x){
    auto m=cast(ubyte[])x[1];
    uint a=0x67452301,b=0xEFCDAB89,i,t,f,k;
    uint[5]h=[a,b,~a,~b,0xC3D2E1F0],s;
    uint[80]w;
    auto r=(uint u,uint b)=>u<<b|u>>32-b;
    auto u=(uint i)=>[r(s[0],5)+f+s[4]+k+w[i],s[0],r(s[1],30),s[2],s[3]];
    ubyte[64]p;
    p[0]=128;
    m~=p[0..64-(m.length+8)%64]~nativeToBigEndian(8*m.length);
    foreach(ch;m.chunks(64)){
        16.iota.map!(i=>w[i]=ch[i*4..$][0..4].bigEndianToNative!uint).array;
        iota(16,80).map!(i=>w[i]=r(w[i-3]^w[i-8]^w[i-14]^w[i-16],1)).array;
        s=h;
        80.iota.map!(i=>(i<20?f=s[3]^s[1]&(s[2]^s[3]),k=0x5A827999:i<40?f=s[1]^s[2]^s[3],k=0x6ED9EBA1:i<60?f=s[1]&s[2]|s[3]&(s[1]|s[2]),k=0x8F1BBCDC:(f=s[1]^s[2]^s[3],k=0xCA62C1D6),s[]=u(i)[])).array;
        h[]+=s[];
    }
    g("%(%08x%)",h);
}

— mleise
स्रोत

2

C, 546 अक्षर

कार्यक्रम अपने मानक इनपुट की सामग्री के SHA-1 की गणना करता है।

unsigned b[16],k[]={1732584193,0xEFCDAB89,0,271733878,0xC3D2E1F0},i,j,n,p,t,u,v,w,x;
char*d=b;a(c){for(d[p++^3]=c,c=0,t=*k,u=k[1],v=k[2],w=k[3],x=k[4];
c>79?*k+=t,k[1]+=u,k[2]+=v,k[3]+=w,k[4]+=x,p=0:p>63;x=w,w=v,v=u<<30|u/4,u=t,t=i)
i=b[c-3&15]^b[c+8&15]^b[c+2&15]^b[j=c&15],c++>15?b[j]=i*2|i>>31:0,i=u^v^w,
i=(t<<5|t>>27)+x+b[j]+(c<21?(w^u&(v^w))+1518500249:c<41?i+1859775393:
c<61?(u&v|w&(u|v))-1894007588:i-899497514);}
main(){for(k[2]=~*k;i=~getchar();++n)a(~i);for(a(128);p-56;a(0));
for(;p<20?printf("%02x",(d=k)[p^3]&255):p>55;a(n*8L>>504-p*8));}

नोटों की एक जोड़ी:

यह प्रोग्राम मानता है कि intवास्तव में 32 बिट्स है। उन प्लेटफार्मों के लिए जहां यह मामला नहीं है, unsignedबहुत शुरुआत में घोषणा को प्लेटफॉर्म के अहस्ताक्षरित 32-बिट प्रकार से बदल दिया जाना चाहिए। ( uint32_tस्पष्ट विकल्प होगा, अगर इसकी आवश्यकता नहीं थी #include <stdint.h>।)
यह प्रोग्राम थोड़ा-सा एंडियन प्लेटफॉर्म मानता है। एक बड़े-एंडियन प्लेटफ़ॉर्म के लिए, बस प्रोग्राम की दो घटनाओं को हटा दें ^3, और k[]निम्न ब्लॉक के साथ आरंभीकरण को प्रतिस्थापित करें : {19088743,0x89ABCDEF,0,1985229328,0xF0E1D2C3}541 अक्षरों के आकार के लिए।
कार्यान्वयन के लिए, जहां charडिफ़ॉल्ट रूप से अहस्ताक्षरित है, कोई &255चार और वर्णों को सहेजने के लिए अंतिम पंक्ति पर दिखाई देने वाले को हटा सकता है ।

— रोटी का डिब्बा
स्रोत

यह वापसी करता है be417768b5c3c5c1d9bcb2e7c119196dd76b5570, The quick brown fox jumps over the lazy dogलेकिन इसे लौटना पड़ता है2fd4e1c67a2d28fced849ee1bb76e7391b93eb12

— प्रोग्रामफॉक्स

@ProgramFOX हैश मान स्ट्रिंग प्लस के लिए एक नई लाइन है। विवरण में उद्धृत परीक्षण SHA-1 मान नई कथनों को समाप्त किए बिना तार के लिए हैं, इसलिए यदि आप उन तारों का परीक्षण करना चाहते हैं, तो इनपुट के लिए एक नईरेखा को संलग्न न करें।

— ब्रेडबॉक्स

1

मेरा अजगर कोड थोड़ा लंबा है, लेकिन यह पूरी तरह से काम कर रहा है।

data="hello world"
bytes = ""
h0,h1,h2,h3,h4=0x67452301,0xEFCDAB89,0x98BADCFE,0x10325476,0xC3D2E1F0
for n in range(len(data)):bytes+='{0:08b}'.format(ord(data[n]))
bits=bytes+"1"
pBits=bits
while len(pBits)%512!=448:pBits+="0"
pBits+='{0:064b}'.format(len(bits)-1)
def chunks(l,n):return[l[i:i+n]for i in range(0,len(l),n)]
def rol(n,b):return((n<<b)|(n>>(32-b)))&0xffffffff 
for c in chunks(pBits,4512):
    words=chunks(c,32)
    w=[0]*80
    for n in range(0,16):w[n]=int(words[n],2)
    for i in range(16,80):w[i]=rol((w[i-3]^w[i-8]^w[i-14]^w[i-16]),1)
    a,b,c,d,e=h0,h1,h2,h3,h4
    for i in range(0,80):
        if 0<=i<=19:f=(b&c)|((~b)&d);k=0x5A827999
        elif 20<=i<=39:f=b^c^d;k=0x6ED9EBA1
        elif 40<=i<=59:f=(b&c)|(b&d)|(c&d);k=0x8F1BBCDC
        elif 60<=i<=79:f=b^c^d;k=0xCA62C1D6
        temp=rol(a,5)+f+e+k+w[i]&0xffffffff
        e,d,c,b,a=d,c,rol(b,30),a,temp 
    h0+=a
    h1+=b
    h2+=c
    h3+=d
    h4+=e 
print '%08x%08x%08x%08x%08x'%(h0,h1,h2,h3,h4)

— केली के
स्रोत

कृपया उत्तर में भाषा निर्दिष्ट करें। इसके अलावा, चूंकि यह कोड-गोल्फ है, इसलिए आपको कम से कम प्रयास करना चाहिए। एक-चर चर नाम, गैर-कानूनी व्हाट्सएप को हटाने, महंगे स्थिरांक ( 0xffffffff) को चर (भी -1पर्याप्त होगा?) में

— मारते हुए

मुझे phython लगता है :)

— Owais Qureshi

@JDDvorak मैंने अपना कोड संशोधित किया।

— काइल का

h0..h4अभी भी दो-अक्षर; ;-)

— जॉन ड्वोरक

मुझे लाइन 29 पर एक सिंटैक्स त्रुटि मिलती है।

— प्रोग्रामफ़ॉक्स

SHA-1 हैश एल्गोरिथम को लागू करना

गोल्फस्क्रिप्ट, 374 322 वर्ण

पायथन 3 - 645 चार्ट

डी (759 वर्ण)

C, 546 अक्षर