साबित कर दिया कि एक रूसी क्रिप्टोग्राफिक मानक भी संरचित है


92

इस चुनौती का उद्देश्य आपके चयन के नुकसान में, निम्नलिखित फ़ंक्शन का एक असंभव छोटा कार्यान्वयन खोजना है p। यहां C कोड इसे लागू कर रहा है ( यह TIO लिंक देखें जो इसके आउटपुट को प्रिंट भी करता है) और एक विकिपीडिया पृष्ठ जिसमें यह है।

unsigned char pi[] = {
    252,238,221,17,207,110,49,22,251,196,250,218,35,197,4,77,
    233,119,240,219,147,46,153,186,23,54,241,187,20,205,95,193,
    249,24,101,90,226,92,239,33,129,28,60,66,139,1,142,79,
    5,132,2,174,227,106,143,160,6,11,237,152,127,212,211,31,
    235,52,44,81,234,200,72,171,242,42,104,162,253,58,206,204,
    181,112,14,86,8,12,118,18,191,114,19,71,156,183,93,135,
    21,161,150,41,16,123,154,199,243,145,120,111,157,158,178,177,
    50,117,25,61,255,53,138,126,109,84,198,128,195,189,13,87,
    223,245,36,169,62,168,67,201,215,121,214,246,124,34,185,3,
    224,15,236,222,122,148,176,188,220,232,40,80,78,51,10,74,
    167,151,96,115,30,0,98,68,26,184,56,130,100,159,38,65,
    173,69,70,146,39,94,85,47,140,163,165,125,105,213,149,59,
    7,88,179,64,134,172,29,247,48,55,107,228,136,217,231,137,
    225,27,131,73,76,63,248,254,141,83,170,144,202,216,133,97,
    32,113,103,164,45,43,9,91,203,155,37,208,190,229,108,82,
    89,166,116,210,230,244,180,192,209,102,175,194,57,75,99,182,
};

unsigned char p(unsigned char x) {
     return pi[x];
}

क्या है p

pदो रूसी क्रिप्टोग्राफिक मानकों का एक घटक है, जिसका नाम हैश फ़ंक्शन स्ट्रीबॉग और ब्लॉक सिफर कुज़्नचिक है । में इस लेख (और आईएसओ बैठकों के दौरान), इन एल्गोरिदम के डिजाइनरों ने दावा किया कि वे सरणी उत्पन्न piयादृच्छिक 8 बिट क्रमपरिवर्तन उठा द्वारा।

"असंभव" कार्यान्वयन

कर रहे हैं 8 बिट्स पर क्रमपरिवर्तन। इसलिए, किसी दिए गए यादृच्छिक क्रमपरिवर्तन के लिए, एक कार्यक्रम जो इसे लागू करता है, उसे 1683 बिट्स से कम की आवश्यकता नहीं होगी।256!21684

हालाँकि, हमने कई असामान्य रूप से छोटे कार्यान्वयन पाए हैं (जो हम यहां सूचीबद्ध करते हैं ), उदाहरण के लिए निम्नलिखित सी कार्यक्रम:

p(x){unsigned char*k="@`rFTDVbpPBvdtfR@\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8",l=0,b=17;while(--l&&x^1)x=2*x^x/128*285;return l%b?k[l%b]^k[b+l/b]^b:k[l/b]^188;}

जिसमें केवल 158 अक्षर हैं और इस तरह 1264 बिट्स में फिट बैठता है। यह देखने के लिए यहां क्लिक करें कि यह काम करता है।

हम एक "असंभव" लघु कार्यान्वयन के बारे में बात करते हैं, क्योंकि यदि क्रमपरिवर्तन एक यादृच्छिक प्रक्रिया का उत्पादन था (जैसा कि इसके डिजाइनरों द्वारा दावा किया गया है), तो यह छोटा नहीं होगा एक कार्यक्रम ( अधिक विवरण के लिए इस पृष्ठ को देखें)।

संदर्भ कार्यान्वयन

पिछले C कोड का अधिक पठनीय संस्करण है:

unsigned char p(unsigned char x){
     unsigned char
         s[]={1,221,146,79,147,153,11,68,214,215,78,220,152,10,69},
         k[]={0,32,50,6,20,4,22,34,48,16,2,54,36,52,38,18,0};
     if(x != 0) {
         unsigned char l=1, a=2;
         while(a!=x) {
             a=(a<<1)^(a>>7)*29;
             l++;
         }
         unsigned char i = l % 17, j = l / 17;
         if (i != 0) return 252^k[i]^s[j];
         else return 252^k[j];
     }
     else return 252;
}

तालिका kऐसी है k[x] = L(16-x), जहां Lअर्थ में रैखिक है L(x^y)==L(x)^L(y), और जहां, सी की तरह, ^XOR को दर्शाता है। हालाँकि, हमने अपने कार्यान्वयन को छोटा करने के लिए इस संपत्ति का लाभ उठाने का प्रबंधन नहीं किया। हम किसी भी संरचना के बारे में नहीं जानते हैं sजो एक सरल कार्यान्वयन की अनुमति दे सकती है --- इसका उत्पादन हमेशा सबफील्ड में होता है, हालांकि, जहां परिमित क्षेत्र में किया जाता है। बेशक, आप एक को खोजने के लिए एक सरल अभिव्यक्ति का उपयोग करने के लिए बिल्कुल स्वतंत्र हैं !s[x]16=s[x]s

जबकि लूप 256 तत्वों के साथ परिमित क्षेत्र में एक असतत लघुगणक के मूल्यांकन से मेल खाता है। यह एक सरल जानवर-बल खोज के माध्यम से काम करता है: डमी चर aपरिमित क्षेत्र का एक जनरेटर होने के लिए सेट किया गया है, और जब तक परिणाम नहीं के बराबर होता है, तब तक इसे इस जनरेटर द्वारा गुणा किया जाता है x। जब यह मामला है, हमारे पास lअसतत लॉग है x। यह फ़ंक्शन 0 में परिभाषित नहीं है, इसलिए ifकथन के अनुरूप विशेष मामला ।

जनरेटर द्वारा गुणा करके एक गुणा के रूप में देखा जा सकता है में सापेक्ष बहुपद जो तब कम हो जाता है । यह सुनिश्चित करने के लिए कि चर 8 बिट पर रहता है की भूमिका है । वैकल्पिक रूप से, हम इस्तेमाल कर सकते हैं , जिसमें मामले एक हो सकता है (या किसी अन्य पूर्णांक प्रकार)। दूसरी तरफ, 1 के बराबर होने पर हमें शुरू करना आवश्यक है ।XF2[X]X8+X4+X3+X2+1unsigned charaa=(a<<1)^(a>>7)*(256^29)aintl=1,a=2l=255x

पिछले शार्ट इम्प्लीमेंटेशन प्राप्त करने के लिए हमारे अधिकांश अनुकूलन के राइटअप के साथ, हमारे पेपरp में प्रस्तुत किए गए गुणों के बारे में अधिक जानकारी दी गई है ।

नियम

p1683 बिट्स से कम में फ़ंक्शन को लागू करने वाले प्रोग्राम का प्रस्ताव करें । कार्यक्रम जितना छोटा होता है, दी गई भाषा के लिए यह उतना ही अधिक असामान्य होता है, लेकिन यह बेहतर होता है। यदि आपकी भाषा में कुज़नेचिक, स्ट्रीबोग या pएक बिलिन के रूप में होता है , तो आप उनका उपयोग नहीं कर सकते।

सबसे अच्छा कार्यान्वयन निर्धारित करने के लिए हम जिस मीट्रिक का उपयोग करते हैं, वह बाइट्स में प्रोग्राम की लंबाई है। हम अपने अकादमिक पेपर में बिट-लेंथ का उपयोग करते हैं लेकिन हम सादगी के लिए यहां बाइट्स करते हैं।

यदि आपकी भाषा में फ़ंक्शन, तर्क या आउटपुट की स्पष्ट धारणा नहीं है, तो एन्कोडिंग आपको परिभाषित करने के लिए है, लेकिन मूल्य एन्कोडिंग जैसी चालें स्पष्ट pi[x]रूप xसे निषिद्ध हैं।

हमने पहले ही इस विषय पर अपने निष्कर्षों के साथ एक शोध पत्र प्रस्तुत किया है। यह यहां उपलब्ध है । हालांकि, इसे एक वैज्ञानिक स्थल में प्रकाशित किया जाना चाहिए, हम सबसे अच्छे कार्यान्वयन के लेखकों को खुशी से स्वीकार करेंगे।

वैसे, इस सवाल का मसौदा तैयार करते समय उनकी मदद के लिए xnor को धन्यवाद!


12
मुझे आशा है कि कोई व्यक्ति बीज में एक उत्तर प्रस्तुत करता है।
रोबिन राइडर

6
इसी तरह, उदाहरण के लिए, ब्रेनफ़क कोड को प्रति वर्ण 3 बिट पर स्कोर किया जा सकता है अगर इसमें कोई नोड नहीं है? और 1683 bits at mostएक सख्त प्रतिबंध है [sic?] या लक्ष्य?
किसी ने

31
" यदि क्रमपरिवर्तन एक यादृच्छिक प्रक्रिया का उत्पादन था (जैसा कि इसके डिजाइनरों द्वारा दावा किया गया है), तो यह छोटा नहीं होगा एक कार्यक्रम " मैं असहमत हूं (हालांकि यह चुनौती के लिए कोई फर्क नहीं पड़ता)। यदि यह एक यादृच्छिक प्रक्रिया का उत्पादन था, तो यह संभावना नहीं होगी कि इस तरह के कार्यक्रम मौजूद थे; या इसे ढूंढना मुश्किल होगा
लुइस मेंडो

8
@Grimy यह कथन तब छोटा नहीं होगा एक कार्यक्रम एक वैचारिक एक (एक प्रोग्रामिंग नहीं है)। अपनी शर्तों का उपयोग करते हुए, यह शुद्ध-गणित की दुनिया से संबंधित है, प्रोग्रामिंग दुनिया के लिए नहीं
लुइस मेंडो

7
यह पहले से ही देखा जा सकता है, लेकिन सिर्फ मामले में: परिणाम केवल 8 अलग-अलग मूल्यों में होता है: ( शुरू होता है और मानकर ) । 1 , 10 , 68 , 79 , 146 , 153 , 220 , 221 i = 1 s 0 = 0si XOR si11,10,68,79,146,153,220,221i=1s0=0
अरनुलद

जवाबों:


35

AMD64 असेंबली (78 बाइट्स या मशीन कोड के 624 बिट्स)

uint8_t SubByte (uint8_t x) {
    uint8_t y, z;
    uint8_t s [] =
      {1,221,146,79,147,153,11,68,214,215,78,220,152,10,69};

    uint8_t k [] =
      {0,32,50,6,20,4,22,34,48,16,2,54,36,52,38,18,0};

    अगर (x) {
      for (y = z = 1;; (y = (y << 1) ^ ((y >> 7) * 29): = = x; z ++);
      x = (z% 17);
      z = (z / 17);
      x = (x)? k [x] ^ s [z]: k [z];
    }
    वापसी x ^ 252;
}

64-बिट x86 असेंबली

    ; AMD64 विधानसभा के 78 बाइट्स
    ; odzhan
    बिट्स 64

    % ifndef BIN
      वैश्विक सबबीटैक्स
    %अगर अंत

SubBytex:
    चल अल २५२
    jecxz L2; अगर (x) {
    L0 पर कॉल करें
क:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
रों:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    पॉप आरबीएक्स
    चल अल, 1; य = १
    cdq; z = 0
एल 1:
    inc dl; z ++
    अल, अल जोड़ें; y = y + y
    jnc $ + 4; यदि कोई कैरी नहीं है तो XOR को छोड़ दें
    xor अल, 29;
    सीपीएम अल, सीएल; if (y! x) goto L1
    जेएन एल 1    

    xchg eax, edx; eax = z
    cdq; edx = 0
    mov cl, 17; al = z / 17, dl = z% 17
    div ecx

    mov cl, [rbx + rax + 17]; cl = s [z]
    xlatb; अल = के [जेड]
    परीक्षण डीएल, डीएल; if (x == 0) goto L2
    जज एल 2
    xchg eax, edx; अल = एक्स
    xlatb; अल = के [एक्स]
    xor अल, सीएल; अल ^ = s [z]
एल 2:
    गीला करना

64-बिट कोड डिसाइड किया गया

00000000 B0FC mov al, 0xfc
00000002 67E348 jecxz 0x4d
00000005 E820000000 qword 0x2a कॉल करें
; k [] = 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde,
; 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
; s [] = 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44,
; 0xd6, 0xd7, 0x4, 0xdc, 0x98, 0x0a, 0x45
0000002A 5B पॉप आरबीएक्स
0000002B B001 mov al, 0x1
0000002D 99 cdq
0000002E FEC2 inc dl
00000030 00C0 अल, अल जोड़ें
00000032 7302 jnc 0x36
00000034 341D xor अल, 0x1d
00000036 38C8 cmp अल, सीएल
00000038 75F4 jnz 0x2e
0000003A 92 xchg eax, edx
0000003B 99 cdq
0000003C B111 मूव क्ल, 0x11
0000003E F7F1 div ecx
00000040 8A4C0311 mov cl, [rbx + rax + 0x11]
00000044 डी 7 एक्सलैटब
00000045 84D2 परीक्षण डीएल, डीएल
00000047 7404 jz 0x4d
00000049 92 xchg eax, edx
0000004A D7 xlatb
0000004B 30C8 xor अल, सीएल
0000004D C3 सेवानिवृत्त

32-बिट x86 असेंबली

    ; X86 असेंबली के 72 बाइट्स
    ; odzhan
    बिट्स 32

    % ifndef BIN
      वैश्विक सबबीटैक्स
      वैश्विक _SubBytex
    %अगर अंत

SubBytex:
_SubBytex:
    चल अल २५२
    jecxz L2; अगर (x) {
    L0 पर कॉल करें
क:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
रों:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    पॉप ईबेक्स
    चल अल, 1; य = १
    cdq; z = 0
एल 1:
    inc edx; z ++
    अल, अल जोड़ें; y = y + y
    jnc $ + 4; यदि कोई कैरी नहीं है तो XOR को छोड़ दें
    xor अल, 29;
    सीपीएम अल, सीएल; if (y! x) goto L1
    जेएन एल 1    
    xchg eax, edx; अल = जेड
    शाम 17; अल | x = z% 17, आह | z = z / 17
    जंग सीएल, आह; cl = z
    cmove eax, ecx; if (x == 0) al = z अन्यथा al = x
    xlatb; अल = के [जेड] या के [एक्स]
    jz L2; if (x == 0) goto L2
    xor al, [ebx + ecx + 17]; k [x] ^ = k [z]
एल 2:
    गीला करना

असंतुष्ट 32-बिट कोड

00000000 B0FC mov al, 0xfc
00000002 E345 jecxz 0x49
00000004 E820000000 कॉल डॉर्ड 0x29
; k [] = 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde,
; 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xfc
; s [] = 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44,
; 0xd6, 0xd7, 0x4, 0xdc, 0x98, 0x0a, 0x45
00000029 5B पॉप ईबेक्स
0000002A B001 mov al, 0x1
0000002C 99 cdq
0000002D 42 inc edx
0000002E 00C0 अल, अल जोड़ें
00000030 7302 jnc 0x34
00000032 341D xor अल, 0x1d
00000034 38C8 cmp अल, सीएल
00000036 75F5 jnz 0x2d
00000038 92 xchg eax, edx
00000039 D411 aam 0x11
0000003B 88E1 मूव, आह
0000003D 0F44C1 cmovz eax, ecx
00000040 D7 xlatb
00000041 7404 jz 0x47
00000043 32440B11 xor al, [ebx + ecx + 0x11]
00000047 सी 3 रिटायर

1
अच्छा जवाब! चूंकि ओपी बिट गणना की तलाश में था, यह (85 बाइट्स) 680 बिट्स के लिए निकलता है , प्रति बाइट 8 बिट्स का उपयोग करके, या 595 बिट्स 7 बाइट्स का उपयोग करके (संभव है क्योंकि सभी वर्ण ASCII हैं)। यदि आप और भी अधिक प्रतिबंधात्मक चरित्र सेट में संकुचित होते हैं, तो आप शायद कम जा सकते हैं।
कलुब

1
PPCG में आपका स्वागत है; अच्छा पहला उपाय है।
झबरा

9
@ क्यूबब मेरा बिंदु था, इस उत्तर में कोड सिर्फ C / असेंबलर है जो संकलित हो जाता है, इसलिए बाइट गिनती दिए गए कोड की नहीं है, बल्कि संकलित कोड की है। और वह ASCII नहीं है।
17

7
स्पष्टीकरण के लिए, 84 बाइट्स मशीन कोड का आकार है इसके बाद इसे इकट्ठा किया गया है? यदि ऐसा है तो शीर्षक को दर्शाने के लिए अद्यतन किया जाना चाहिए कि यह एक विधानसभा उत्तर के बजाय मशीन कोड उत्तर है।
आलू ४४

1
और BTW, आपको एक मानक कॉलिंग कन्वेंशन का उपयोग करने की आवश्यकता नहीं है; आप एक कस्टम कन्वेंशन का उपयोग कर सकते हैं जहाँ RBX कॉल-क्लोबर्ड है, जो पुश / पॉप के लिए 2 बाइट्स की बचत करता है। (और जहाँ uint8_tआरजीआर को JRCXZ के लिए 64-बिट तक बढ़ाया गया है)। इसके अलावा, यदि आप स्थिति-निर्भर कोड लिखते हैं, तो आप तालिका पते को mov ebx, imm326-बाइट call/ के बजाय 5-बाइट के साथ रजिस्टर में डाल सकते हैं pop। या यह एक के रूप में उपयोग disp32में mov al, [table + rax]है, लेकिन वह खो सकता है जब से तुम दो हैं xlatbऔर एक movपहले से ही। कॉल + पॉप शेलकोड ट्रिक retहालांकि, 7-बाइट RIP- सापेक्ष LEA के बाद डेटा के साथ जीतता है ।
पीटर कॉर्ड्स

23

CJam ,72 67 66 63 बाइट्स

ri{_2md142*^}es*]2#~Hmd{5\}e|Fm2b"Ý0$&Ü™ÖD�’
˜×EO“N".*Lts:^i

es* वर्तमान टाइमस्टैम्प द्वारा कुछ दोहराता है, जो एक बड़ी संख्या है, और इसे खत्म करने में बहुत लंबा समय लगेगा।

वास्तव में परीक्षण योग्य संस्करण, 64 बाइट्स:

ri{_2md142*^}256*]2#~Hmd{5\}e|Fm2b"Ý0$&Ü™ÖD�’
˜×EO“N".*Lts:^i
00000000: 7269 7b5f 326d 6431 3432 2a5e 7d32 3536  ri{_2md142*^}256
00000010: 2a5d 3223 7e48 6d64 7b35 5c7d 657c 466d  *]2#~Hmd{5\}e|Fm
00000020: 3262 22dd 3024 2612 dc99 d644 0092 0b0a  2b".0$&....D....
00000030: 98d7 454f 934e 0122 2e2a 4c74 733a 5e69  ..EO.N.".*Lts:^i

इसे ऑनलाइन आज़माएं!

सभी ऑनलाइन कोशिश करो!

इस कोड (एक Linux मशीन पर) चलाने के लिए आपको लाइन जोड़ने की जरूरत en_US.ISO-8859-1 ISO-8859-1में /etc/locale.genऔर चलाने के locale-gen। तब आप उपयोग कर सकते हैं:

LANG=en_US.ISO-8859-1 java -jar cjam.jar <source file>

या आप इस समकक्ष 72 बाइट UTF-8 संस्करण की कोशिश कर सकते हैं:

00000000: 7269 7b5f 326d 6431 3432 2a5e 7d32 3536  ri{_2md142*^}256
00000010: 2a5d 3223 7e48 6d64 7b35 5c7d 657c 466d  *]2#~Hmd{5\}e|Fm
00000020: 3262 22c3 9d30 2426 12c3 9cc2 99c3 9644  2b"..0$&.......D
00000030: 00c2 920b 0ac2 98c3 9745 4fc2 934e 0122  .........EO..N."
00000040: 2e2a 4c74 733a 5e69                      .*Lts:^i

व्याख्या

ri               e# Read input.
{_2md142*^}      e# Copy and divide by 2. If remainder is 1, xor 142.
es*]             e# Repeat a lot of times and wrap all results in an array.
2#               e# Find the first occurrence of 2, -1 if not found.
~                e# Increment and negate.
Hmd              e# Divmod 17. Both the quotient and remainder would be negated.
{5\}e|           e# If remainder = 0, return 5, quotient instead.
Fm2b             e# Subtract 15 from the remainder and expand in base 2.
                 e# In CJam, base conversion only applies to the absolute value.
"...".*          e# Filter 221, 48, 36, 38, 18 by the bits.
                 e# 221, the characters after 18
                 e#   and 18 itself in case quotient - 15 = -15 won't change.
Lt               e# Remove the item s[quotient] xor 220.
                 e# Quotient is 0, 5 or a negative integer from the end,
                 e#   which doesn't overlap with the previously filtered items.
s                e# Flatten, because some characters become strings after the process.
:^i              e# Reduce by xor and make sure the result is an integer.

स्ट्रिंग में वर्ण हैं:

  • 221. नीचे देखें।
  • 48, 36, 38, 18. यह प्रश्न में एल की विशेषताओं के आधार पर k का रैखिक अपघटन है।
  • 220, केवल सरणी k का उपयोग करने पर सरणी s का भराव मूल्य।
  • Array s xor 220 अंतिम तत्व को छोड़कर या उलट होने से पहले पहला तत्व है, जो कि स्ट्रिंग की शुरुआत में 221 है।

पावर सेट के साथ आप क्या करेंगे? पुनश्च मैं शायद रिवर्स फील्ड ऑपरेशन करने की उस चाल को चोरी करने जा रहा हूं। बहुत साफ़।
पीटर टेलर

@PeterTaylor आप सबसे सीधे क्रम के साथ [48 36 38 18] (या इसके विपरीत) के पावर सेट का उपयोग करके सरणी k प्राप्त कर सकते हैं, और प्रत्येक को xor द्वारा कम कर सकते हैं। लेकिन अब तक इस सवाल में इस्तेमाल की जाने वाली गोल्फ भाषाओं में, केवल 05AB1E का ही सही क्रम था। जेली और स्टैक्स का स्पष्ट रूप से एक अलग विचार था कि मुझे क्या लगता है कि यह सीधा होना चाहिए।
jimmy23013

मैं वर्तमान में 05AB1E को आपके उत्तर को गोल्फ देने की प्रक्रिया में हूं। आपके स्ट्रिंग के लिए पूर्णांक मान क्या हैं "Ý0$&Ü™ÖD�’\n˜×EO“N"?
केविन क्रूज़सेन

@KevinCruijssen क्या आप पूछ रहे हैं कि उनका क्या मतलब है, या उनके संख्यात्मक मूल्य (जो आप हेक्स डंप से देख सकते हैं)?
jimmy23013

@ jimmy23013 आह, बिल्कुल .. हेक्स-डंप के बारे में भूल गए ..
केविन क्रूज़सेन

19

जेली 71 59 बाइट्स

H^142ƊHḂ?Ƭi2d17U⁸⁴;$Ḣ?$CµṪạ⁴B¬T;;6ị“Œ0$&ØŀWð⁺Ṫ\ḢĠVı⁻¹]°Ẇ‘^/

इसे ऑनलाइन आज़माएं!

सभी संभावनाओं को सत्यापित करें

अब jimmy23013 के चतुर सीजेम उत्तर के एक पुनर्निर्मित संस्करण का उपयोग करके फिर से लिखा गया है, ताकि यह सुनिश्चित हो सके कि वह भी एक है! केवल 472 बिट्स (भोले दृष्टिकोण के 28.0%) का उपयोग करता है। @ jimmy23013 ने एक और बाइट भी बचाई है!

व्याख्या

चरण 1

         Ƭ        | Repeat the following until no new entries:
       Ḃ?         | - If odd:
     Ɗ            |   - Then following as a monad:
H                 |     - Halve
 ^142             |     - Xor 142
      H           |   - Else: Halve
          i2      | Index of 2 in this list

चरण 2

d17           | Divmod 17
          $   | Following as a monad:
   U          | - Reverse order
        Ḣ?    | - If head (remainder from divmod) non-zero:
    ⁸         |   - Then: left argument [quotient, remainder]
     ⁴;$      |   - Else: [16, quotient]
           C  | Complement (1 minus)
            µ | Start a new monadic chain

स्टेज 3

Ṫ                   | Tail (Complement of remainder or quotient from stage 2)
 ạ⁴                 | Absolute difference from 16
   B                | Convert to binary
    ¬               | Not
     T              | Indices of true values
      ;             | Concatenate (to the other value from stage 2)
       ;6           | Concatenate to 6
         ị“Œ...Ẇ‘   | Index into [19,48,36,38,18,238,87,24,138,206,92,197,196,86,25,139,129,93,128,207]
                 ^/ | Reduce using xor

मूल दृष्टिकोण

जेली , 71 66 बाइट्स

H^142ƊHḂ?Ƭi2d:j@“ÐḌ‘ɗ%?17ị"“p?Ä>4ɼḋ{zẉq5ʂċ¡Ḅ“`rFTDVbpPBvdtfR@‘^ƒ17

इसे ऑनलाइन आज़माएं!

सभी संभावनाओं को सत्यापित करें

एक विवादास्पद लिंक या पूर्ण कार्यक्रम जो एकल तर्क लेता है और का प्रासंगिक मूल्य लौटाता है pi[x]। यह 536 बिट्स है, इसलिए पी के भोले भंडारण के एक तिहाई के तहत।

Jimmy23013 के CJam उत्तरl से खोजने के लिए विधि का उपयोग करके 3 बाइट्स को बचाया ताकि एक को भी उखाड़ा जा सके!

व्याख्या

चरण 1

         Ƭ        | Repeat the following until no new entries:
       Ḃ?         | - If odd:
     Ɗ            |   - Then following as a monad:
H                 |     - Halve
 ^142             |     - Xor 142
      H           |   - Else: Halve
          i2      | Index of 2 in this list

चरण 2

         %?17  | If not divisible by 17
d              | - Then divmod 17
        ɗ      | - Else following as a dyad (using 17 as right argument)
 :             |   - Integer divide by 17
  j@“ÐḌ‘       |   - Join the list 15,173 by the quotient

स्टेज 3

ị"“p...Ḅ“`...@‘     | Index into two compressed lists of integers using the output from stage 2 (separate list for each output from stage 2). The third output from stage 2 will be left untouched
               ^ƒ17 | Finally reduce using Xor and 17 as the first argument


15

सी (gcc) , 157 148 140 139 बाइट्स

सी उदाहरण पर मामूली सुधार।

l,b=17,*k=L"@`rFTDVbpPBvdtfR@";p(x){for(l=256;--l*~-x;)x=2*x^x/128*285;return l%b?k[l%b]^"\xcer?\4@6\xc8\t{|\3q5\xc7\n"[l/b]-b:k[l/b]^188;}

इसे ऑनलाइन आज़माएं!

सी (जीसीसी) , 150 142 127 126 बाइट्स

यह एक gcc और x86 और UTF-8 quirks पर निर्भर करता है।

l,*k=L"@`rFTDVbpPBvdtfR@";p(x){for(l=256;--l*~-x;)x=2*x^x/128*285;x=l%17?k[l%17]^L"½a.ó/%·øjkò`$¶ù"[l/17]:k[l/17]^188;}

इसे ऑनलाइन आज़माएं!

-1 और कम अपरिभाषित व्यवहार के लिए @XavierBonnetain को धन्यवाद।


10

05AB1E , 101 100 98 97 95 94 बाइट्स

U•α">η≠ε∍$<Θγ\&@(Σα•₅вV₁[<ÐX*Q#X·₁%Xžy÷Ƶ¹*₁%^₁%U}D17©%DĀiYsès®÷•¾#kôlb¸ù,-ó"a·ú•₅вë\Ƶ∞s®÷Y}sè^

-3 बाइट्स @Grimy के लिए धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

पोर्ट ऑफ़ जेवियर बोनटैन के सी फंक्शन (1106 बिट्स वर्जन) यहाँ से , उसी सुधार के साथ @ सीलिंगकैट ने अपने सी उत्तर में 3 बाइट्स बचाने के लिए बनाया , इसलिए उसे उखाड़ना सुनिश्चित करें!

U                    # Store the (implicit) input in variable `X`
•α">η≠ε∍$<Θγ\&@(Σα• "# Push compressed integer 20576992798525946719126649319401629993024
 ₅в                  # Converted to base-255 as list:
                     #  [64,96,114,70,84,68,86,98,112,80,66,118,100,116,102,82,64]
   V                 # Pop and store this list in variable `Y`
                    # Push `i` = 256
 [                   # Start an infinite loop:
  <                  #  Decrease `i` by 1
   Ð                 #  Triplicate `i`
    X*Q              #  If `i` multiplied by `X` is equal to `i` (i==0 or X==1):
       #             #   Stop the infinite loop
  X·₁%               #  Calculate double(`X`) modulo-256
                     #  (NOTE: all the modulo-256 are to mimic an unsigned char in C)
  Xžy÷               #  Calculate `X` integer-divided by builtin integer 128,
      Ƶ¹*            #  multiplied by compressed integer 285,
         ₁%          #  modulo-256
  ^                  #  Bitwise-XOR those together
   ₁%                #  And take modulo-256 again
  U                  #  Then pop and store it as new `X`
 }D                  # After the loop: Duplicate the resulting `i`
   17©               # Push 17 (and store it in variable `®` without popping)
      %              # Calculate `i` modulo-17
       D             # Duplicate it
        Āi           # If it's NOT 0:
          Ysè        #  Index the duplicated `i` modulo-17 into list `Y`
          s®÷        #  Calculate `i` integer-divided by 17
          •¾#kôlb¸ù,-ó"a·ú•
                    "#  Push compressed integer 930891775969900394811589640717060184
           ₅в        #  Converted to base-255 as list:
                     #   [189,97,46,243,47,37,183,248,106,107,242,96,36,182,249]
         ë           # Else (`i` == 0):
          \          #  Discard the duplicated `i` modulo-17, since we don't need it
          Ƶ∞         #  Push compressed integer 188
          s®÷        #  Calculate `i` integer-divided by 17
          Y          #  Push list `Y`
         }s          # After the if-else: swap the integer and list on the stack
           è         # And index the `i` modulo/integer-divided by 17 into the list
            ^        # Then Bitwise-XOR the top two together
                     # (after which the top of the stack is output implicitly as result)

इस 05AB1E टिप को देखें (यह समझने के लिए कि बड़े पूर्णांकों को कैसे संपीड़ित करें ? और पूर्णांक सूचियों को कैसे संपीड़ित करें? ) यह समझने के लिए कि क्यों •α">η≠ε∍$<Θγ\&@(Σα•है 20576992798525946719126649319401629993024? •α">η≠ε∍$<Θγ\&@(Σα•₅вहै [64,96,114,70,84,68,86,98,112,80,66,118,100,116,102,82,64]; Ƶ¹है 285; •¾#kôlb¸ù,-ó"a·ú•है 930891775969900394811589640717060184; •¾#kôlb¸ù,-ó"a·ú•₅вहै [189,97,46,243,47,37,183,248,106,107,242,96,36,182,249]; और Ƶ∞है 188


@Grimy धन्यवाद, मैं हमेशा इस तरह के गोल्फ को संकुचित पूर्णांक सूचियों के साथ भूल गया था .. (PS: आप कोड को घेर सकते हैं जिसमें दोनों पक्षों में दो के साथ टिप्पणी हो सकती है। I 'के बजाय': '' code'code '। ''।)
केविन क्रूज़सेन

व्हाट्स, मेस अप्ड फॉर्मेटिंग के बारे में खेद है। मैं बैकटिक्स को दोगुना करने के बारे में जानता हूं, लेकिन मुझे महसूस नहीं हुआ कि कंप्रेस्ड लिस्ट में बैकटिक था। इसके अलावा: s^=> ^(XOR सराहनीय है)। वास्तव में, s^_बस के रूप में ही नहीं है Q?
ग्रिमि

@ ग्रैमी थैंक्स! तुम वास्तव में सही हो। हम मूल रूप से जाँचते हैं कि लूप से बाहर निकलने के लिए निम्नलिखित तीन चीजों में से एक सत्य है या नहीं i==0 || X==0 || X==1
केविन क्रूज़सेन

10

स्टैक्स , 65 64 62 59 58 बाइट्स

ç∙¼≥2▼Uó╤áπ╙º┐╩♫∟öv◘≥δ♦Θ╫»─kRWÑâBG")≥ö0╥kƒg┬^S ΔrΩ►╣Wü Ü╕║

इसे चलाएं और डीबग करें

दुर्भाग्य से, यह कार्यक्रम कुछ निर्देशों का उपयोग करता है जो आंतरिक रूप से कुछ पदावनत स्टैक्स निर्देशों का उपयोग करते हैं। मैं सिर्फ उनके कार्यान्वयन को अद्यतन करना भूल गया। यह प्रकट करने के लिए कुछ गंभीर चेतावनी का कारण बनता है, लेकिन परिणाम अभी भी सही हैं।

यह jimmy23013 के शानदार जवाब से प्रेरित है । कुछ हिस्सों को बेहतर ढंग से स्टैक्स के अनुरूप बदला गया है।

मुद्रण योग्य ASCII में लिखे गए स्टैक्स कार्यक्रमों में एक वैकल्पिक प्रतिनिधित्व है जो प्रति बाइट से थोड़ा अधिक 1 बिट बचाता है, क्योंकि केवल 95 प्रिंट करने योग्य ASCII वर्ण हैं।

यहां टिप्पणियों के साथ "पठनीयता" के लिए स्वरूपित इस कार्यक्रम का एससीआई प्रतिनिधित्व है।

{                       begin block
  2|%142*S              given n, calculate (n/2)^(n%2*142)
                         - this seems to be the inverse of the operation in the while loop
gu                      use block to generate distinct values until duplicate is found
                         - starting from the input; result will be an array of generated values
2I^                     1-based index of 2 in the generated values
17|%                    divmod 17
c{Us}?                  if the remainder is zero, then use (-1, quotient) instead
~                       push the top of the main stack to the input stack for later use
"i1{%oBTq\z^7pSt+cS4"   ascii string literal; will be transformed into a variant of `s`
./o{H|EF                interpret ascii codes as base-94 integer
                         - this is tolerant of digits that exceed the base
                        then encode big constant as into base 222 digits
                         - this produces an array similar to s
                         - 0 has been appended, and all elements xor 220
@                       use the quotient to index into this array
"jr+R"!                 packed integer array literal [18, 38, 36, 48]
F                       for each, execute the rest of the program
  ;                     peek from the input array, stored earlier
  v                     decrement
  i:@                   get the i-th bit where i is the iteration index 0..3
  *                     multiply the bit by value from the array literal
  S                     xor with result so far
                        after the loop, the top of the stack is printed implicitly

इसको चलाओ

सभी इनपुट के लिए चलाने के लिए संशोधित संस्करण 0..255


स्टेक्स में Sपावर सेट है। आप [18 38 36 48] का पावर सेट प्राप्त कर सकते हैं, इंडेक्स और एक्सोर द्वारा कम कर सकते हैं। (मैं स्टैक्स नहीं जानता और मुझे यकीन नहीं है कि यह हालांकि छोटा होगा।)
jimmy23013

मुझे लगता है कि Sऑपरेटर द्वारा उत्पादित सबसेट के लिए स्टैक्स का ऑर्डर सही क्रम में काम करने के लिए नहीं है। उदाहरण के लिए "abc"SJ("एबीसी" की शक्तियां रिक्त स्थान के साथ जुड़ गई) "एब एबीसी एसी बीसी सी सी" का उत्पादन करती है।
पुनरावर्ती

8

पायथन 3 , 151 बाइट्स

f=lambda x,l=255,k=b'@`rFTDVbpPBvdtfR@':f(x*2^x//128*285,l-1)if~-x*l else[k[l%17]^(0x450a98dc4ed7d6440b99934f92dd01>>l//17*8&255),k[l//17]][l%17<1]^188

इसे ऑनलाइन आज़माएं!

एक फ़ंक्शन जो क्रमपरिवर्तन को लागू करता है। कोड केवल 7-बिट ASCII वर्णों का उपयोग करता है।

लैंडिंग पृष्ठ URL के kएक अजगर 3 bytestring के रूप में, स्थानांतरित कर दिया ^64प्रिंट करने योग्य श्रेणी में। इसके विपरीत, sएक संख्यात्मक स्थिरांक के आधार -256 अंकों के रूप में एन्कोड किया गया है, और अंकों को इस रूप में निकाला जाता है [number]>>[shift]*8&255। यह sएक स्ट्रिंग में एन्कोडिंग की तुलना में कम था, क्योंकि इस आवश्यक भागने की संख्या के कारण, यहां तक ​​कि ^160उन को कम करने के लिए एक इष्टतम बदलाव के साथ ।

असतत-लॉग संगणना पीछे की ओर की जाती है। x=x*2^x//128*285जब तक यह पहचान तक नहीं पहुंच जाता, तब तक अद्यतन चक्रीय समूह में आगे बढ़ते हुए अनुकरण द्वारा उत्पन्न होता है x=1। हम l=255(चक्र की लंबाई) पर असतत लॉग शुरू करते हैं , और प्रत्येक पुनरावृत्ति को घटाते हैं। x=0मामले को संभालने के लिए और इसे हमेशा के लिए लूप नहीं बनाने के लिए, हम यह भी समाप्त करते हैं l=0कि कब , कौन सा x=0नक्शा l=0निर्दिष्ट करता है।


पायथन 2 अच्छे बाइटस्ट्रेट्स नहीं होने पर हार जाता है, इसलिए हमें करने की जरूरत है map(ord,...)(ArBo ने यहां एक बाइट को बचाया)। यह पूर्णांक विभाजन के /बजाय हमें उपयोग करने देता है //

पायथन 2 , 156 बाइट्स

f=lambda x,l=255,k=map(ord,'@`rFTDVbpPBvdtfR@'):f(x*2^x/128*285,l-1)if~-x*l else[k[l%17]^(0x450a98dc4ed7d6440b99934f92dd01>>l/17*8&255),k[l/17]][l%17<1]^188

इसे ऑनलाइन आज़माएं!


7

जावास्क्रिप्ट (ईएस 6), 139 बाइट्स

Node.js संस्करण के समान, लेकिन ASCII श्रेणी से परे वर्णों का उपयोग करना।

f=(x,l=256,b=17,k=i=>"@`rFTDVbpPBvdtfR@¬p?â>4¦é{zãq5§è".charCodeAt(i))=>--l*x^l?f(x+x^(x>>7)*285,l):l%b?k(l%b)^k(b+l/b)^b:k(l/b)^188

इसे ऑनलाइन आज़माएं!


जावास्क्रिप्ट (Node.js) ,  149  148 बाइट्स

जेवियर बोनटैन के सी कार्यान्वयन (जो यहां प्रस्तुत किया गया है ) के आधार पर ।

f=(x,l=256,b=17,k=i=>Buffer("@`rFTDVbpPBvdtfR@,p?b>4&i{zcq5'h")[~~i]|3302528>>i-b&128)=>--l*x^l?f(x+x^(x>>7)*285,l):l%b?k(l%b)^k(b+l/b)^b:k(l/b)^188

इसे ऑनलाइन आज़माएं!

एन्कोडिंग

जेवियर्स मूल जवाब में, टेबल s[]और k[]निम्नलिखित स्ट्रिंग में जमा हो जाती है:

"@`rFTDVbpPBvdtfR@\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8"
 \_______________/\__________________________________/
         k                         s

पहले 17 अक्षर ASCII के प्रतिनिधित्व हैं k[i] XOR 64और अगले 15 अक्षर ASCII के प्रतिनिधित्व हैं s[i-17] XOR 173, या s[i-17] XOR 64 XOR 17 XOR 252

k[i] XOR 64s[i-17] XOR 173126128

यहाँ हम क्या है:

original value : 172 112  63 226  62  52 166 233 123 122 227 113  53 167 232
subtract 128?  :   1   0   0   1   0   0   1   1   0   0   1   0   0   1   1
result         :  44 112  63  98  62  52  38 105 123 122  99 113  53  39 104
as ASCII       : "," "p" "?" "b" ">" "4" "&" "i" "{" "z" "c" "q" "5" "'" "h"

11001001100100125801

128

| 3302528 >> i - b & 128

s

NB: यह सिर्फ एक साइड नोट है, जो उपरोक्त उत्तरों से संबंधित है।

s

{1,11,79,146}

console.log(
  [ 0b0001, 0b1100, 0b1000, 0b0100, 0b1001, 0b1010, 0b0010, 0b0110,
    0b1110, 0b1111, 0b0101, 0b1101, 0b1011, 0b0011, 0b0111
  ].map(x =>
    [ 1, 11, 79, 146 ].reduce((p, c, i) =>
      p ^= x >> i & 1 && c,
      0
    )
  )
)

इसे ऑनलाइन आज़माएं!


4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 141 बाइट्स

x=>{var k="@`rFTDVbpPBvdtfR@¬p?â>4¦é{zãq5§è";int l=256,b=17;for(;--l*x!=l;)x=2*x^x/128*285;return l%b>0?k[l%b]^k[b+l/b]^b:k[l/b]^188;}

उदाहरण समाधान का केवल एक पोर्ट, C # पर पोर्ट किया गया।

इसे ऑनलाइन आज़माएं!


3

पायथन 3 , 182 बाइट्स

def p(x,t=b'@`rFTDVbpPBvdtfR@\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8',l=255,d=17):
 if x<2:return 252-14*x
 while~-x:x=x*2^(x>>7)*285;l-=1
 return(188^t[l//d],d^t[l%d]^t[d+l//d])[l%d>0]

इसे ऑनलाइन आज़माएं!

अजगर यहां पहला पुरस्कार जीतने नहीं जा रहा है, लेकिन यह अभी भी यहां के सबसे अच्छे पायथन कार्यक्रम का 10-बाइट वाला गोल्फ है

पायथन 3 , 176 बाइट्स

p=lambda x,l=255,t=b'@`rFTDVbpPBvdtfR@\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8',d=17:2>x<l>254and-14*x+252or(p(x*2^(x>>7)*285,l-1)if~-x else(188^t[l//d],d^t[l%d]^t[d+l//d])[l%d>0])

इसे ऑनलाइन आज़माएं!

एक लंबोदर के रूप में, यह अभी भी छह बाइट्स छोटा है। यह मुझे उपयोग करने के लिए दर्द होता है if... else, लेकिन मुझे शॉर्ट-सर्कुलेटिंग के लिए एक और विकल्प नहीं दिखता है, यह देखते हुए कि 0 एक संभावित उत्तर कैसे है।

पायथन 3 , 173 बाइट्स

p=lambda x,l=255,t=bytes('@`rFTDVbpPBvdtfR@¬p?â>4¦é{zãq5§è','l1'),d=17:2>x<l>254and-14*x+252or(p(x*2^(x>>7)*285,l-1)if~-x else(188^t[l//d],d^t[l%d]^t[d+l//d])[l%d>0])

इसे ऑनलाइन आज़माएं!

यहां तक ​​कि बाइट्स में भी कम (हालांकि मैं बिट्स के बारे में निश्चित नहीं हूं, क्योंकि यह शुद्ध ASCII नहीं है), अंडा के सौजन्य से।


3 बाइट्स\x.. भागने के बजाय शाब्दिक वर्णों का उपयोग करके कम
ovs


@ नो थैंक्स! शायद कुछ हद तक गिनती बढ़ जाती है (यकीन नहीं कि जो ओपी के लिए सबसे महत्वपूर्ण है), इसलिए मैं अपना पुराना जवाब भी रखूंगा।
अरेबो

2

जंग , 170 163 बाइट्स

|mut x|{let(k,mut l)=(b"QqcWEUGsaASguewCQ\xacp?\xe2>4\xa6\xe9{z\xe3q5\xa7\xe8",255);while l*x!=l{x=2*x^x/128*285;l-=1}(if l%17>0{l+=289;k[l%17]}else{173})^k[l/17]}

इसे ऑनलाइन आज़माएं!

यह सी में मेरे समाधान का एक बंदरगाह है, थोड़ा अलग स्ट्रिंग के साथ, जिसे xor 17 की आवश्यकता नहीं है। मुझे उम्मीद है कि अधिकांश समाधान स्ट्रिंग पर आधारित हैं @ @ rFTDVbpPBvdtfR @ \ xacp? \ Xe2> 4 \ xa6 \ xe9? {z \ xe3q5 \ xa7 \ "

मैं सशर्त जोड़कर लुकअप में से एक को हटा दिया 17*17करने के लिए l, जैसा कि हम (कम या ज्यादा) एआरएम मशीन कोड समाधान में किया था।

जंग में टाइप इंफ़ेक्शन और क्लोजर होते हैं, लेकिन इसकी कास्ट (बूलियन के लिए या पूर्णांक के बीच भी) हमेशा स्पष्ट होती है, परिवर्तनशीलता को चिह्नित करना पड़ता है, इसमें एक टर्नरी ऑपरेटर, पूर्णांक संचालन नहीं होता है, डिफ़ॉल्ट रूप से, अतिप्रवाह पर घबराहट और संचालन संचालन ( l+=1) रिटर्न यूनिट। मैंने पुनरावृत्तियों के साथ एक छोटा समाधान प्राप्त करने का प्रबंधन नहीं किया, क्योंकि क्लोजर + मैपिंग अभी भी काफी क्रियात्मक है।

यह रस्ट को गोल्फ के लिए एक बहुत बुरा विकल्प बनाता है। फिर भी, ऐसी भाषा में भी जो संक्षिप्तता पर पठनीयता और सुरक्षा पर बल देती है, हम बहुत कम हैं।

अपडेट: मैनेटवर्क के सुझाव से एक अनाम फ़ंक्शन का उपयोग किया।


1
को छोड़कर जब पुनरावर्ती रूप से कहा जाता है, तो अनाम फ़ंक्शन / लंबो स्वीकार्य हैं, इसलिए आप let p=हैडर पर जा सकते हैं और इसे गिन नहीं सकते। ;अनाम कॉल के लिए के रूप में के बारे में अनिश्चित जरूरत नहीं है: यह ऑनलाइन कोशिश करो!
मैनाटवर्क

1

05AB1E , 74 बाइट्स

₄FÐ;sÉiƵf^])2k>17‰Dθ_i¦16š}<(Rć16α2в≠ƶ0Kì6ª•5›@¾ÂÌLìÁŒ©.ðǝš«YWǝŠ•ƵŠвs<è.«^

पोर्ट ऑफ़ @NickKennedy का पहला जेली उत्तर । मैं सीधे @ jimmy23013 के CJam उत्तर के पोर्ट पर काम कर रहा था , लेकिन मैं पहले से ही 78 बाइट्स पर था और अभी भी एक बग को ठीक करना था, इसलिए यह बड़ा होता। यह निश्चित रूप से अभी भी काफी थोड़ा गोल्फ हो सकता है, हालांकि।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

F              # Loop 1000 times:
  Ð             #  Triplicate the current value
                #  (which is the implicit input in the first iteration)
   ;            #  Halve it
    s           #  Swap to take the integer again
     Éi         #  If it's odd:
       Ƶf^      #   Bitwise-XOR it with compressed integer 142
]               # Close the if-statement and loop
 )              # Wrap all values on the stack into a list
  2k            # Get the 0-based index of 2 (or -1 if not found)
    >           # Increase it by 1 to make it 1-based (or 0 if not found)
     17        # Take the divmod-17 of this
Dθ_i    }       # If the remainder of the divmod is 0:
    ¦16š        #  Replace the quotient with 16
         <      # Decrease both values by 1
          (     # And then negate it
R               # Reverse the pair
 ć              # Extract head; push head and remainder-list
  16α           # Get the absolute difference between the head and 16
     2в         # Convert it to binary (as digit-list)
               # Invert booleans (0 becomes 1; 1 becomes 0)
        ƶ       # Multiply all by their 1-based indices
         0K     # And remove all 0s
           ì    # And prepend this in front of the remainder-list
            6ª  # And also append a trailing 6
5›@¾ÂÌLìÁŒ©.ðǝš«YWǝŠ•
                # Push compressed integer 29709448685778434533295690952203992295278432248
  ƵŠв           # Converted to base-239 as list:
                #  [19,48,36,38,18,238,87,24,138,206,92,197,196,86,25,139,129,93,128,207]
     s          # Swap to take the earlier created list again
      <         # Subtract each by 1 to make them 0-based
       è        # And index them into this list
.«^             # And finally reduce all values by bitwise XOR-ing them
                # (after which the result is output implicitly)

इस 05AB1E टिप को देखें (यह समझने के लिए कि बड़े पूर्णांकों को कैसे संपीड़ित करें ? और पूर्णांक सूचियों को कैसे संपीड़ित करें? ) यह समझने के लिए कि क्यों Ƶfहै 142? •5›@¾ÂÌLìÁŒ©.ðǝš«YWǝŠ•है 29709448685778434533295690952203992295278432248, ƵŠहै 239; और •5›@¾ÂÌLìÁŒ©.ðǝš«YWǝŠ•ƵŠвहै [19,48,36,38,18,238,87,24,138,206,92,197,196,86,25,139,129,93,128,207]

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.