พิสูจน์ว่ามาตรฐานการเข้ารหัสลับของรัสเซียมีโครงสร้างที่มากเกินไป


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เป็นส่วนประกอบของสองมาตรฐานการเข้ารหัสลับของรัสเซียคือฟังก์ชันแฮชStreebogและตัวเลขบล็อกKuznyechik ในบทความนี้ (และระหว่างการประชุม ISO) นักออกแบบของอัลกอริทึมเหล่านี้อ้างว่าพวกเขาสร้างอาร์เรย์piโดยเลือกวิธีเรียงสับเปลี่ยน 8 บิตแบบสุ่ม

การใช้งาน "เป็นไปไม่ได้"

มี256!21684พีชคณิตบน 8 บิต ดังนั้นสำหรับการเปลี่ยนแปลงแบบสุ่มที่กำหนดโปรแกรมที่ใช้มันจะไม่ถูกคาดหวังว่าจะต้องน้อยกว่า 1683 บิต

อย่างไรก็ตามเราพบการใช้งานขนาดเล็กผิดปกติหลายอย่าง (ซึ่งเราอยู่ที่นี่ ) ตัวอย่างเช่นโปรแกรม C ต่อไปนี้:

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)และใน C ^หมายถึง XOR อย่างไรก็ตามเราไม่ได้จัดการเพื่อใช้ประโยชน์จากคุณสมบัตินี้เพื่อทำให้การติดตั้งของเราสั้นลง เราไม่ได้ตระหนักถึงโครงสร้างใด ๆsที่สามารถทำให้การนำไปใช้งานง่ายขึ้น --- เอาต์พุตนั้นอยู่ในฟิลด์ย่อยเสมอนั่นคือs[x]16=s[x]ซึ่งการยกกำลังจะกระทำในฟิลด์ จำกัด แน่นอนคุณมีอิสระอย่างยิ่งที่จะใช้สำนวนที่เรียบง่ายกว่าsถ้าคุณจะหามัน!

The while loop corresponds to the evaluation of a discrete logarithm in the finite field with 256 elements. It works via a simple brute-force search: the dummy variable a is set to be a generator of the finite field, and it is multiplied by this generator until the result is equal to x. When it is the case, we have that l is the discrete log of x. This function is not defined in 0, hence the special case corresponding to the if statement.

XF2[X]X8+X4+X3+X2+1unsigned charaa=(a<<1)^(a>>7)*(256^29)aintl=1,a=2l=255x

รายละเอียดเพิ่มเติมเกี่ยวกับคุณสมบัติของpจะถูกนำเสนอในบทความของเราด้วยการเขียนของการเพิ่มประสิทธิภาพส่วนใหญ่ของเราเพื่อให้ได้การใช้งานสั้นก่อนหน้านี้

กฎระเบียบ

เสนอโปรแกรมที่ใช้ฟังก์ชันpน้อยกว่า 1683 บิต เมื่อโปรแกรมสั้นลงความผิดปกติที่เกิดขึ้นก็จะยิ่งสั้นลงเท่านั้น หากภาษาของคุณมี Kuznyechik, Streebog หรือpเป็น builtin คุณจะไม่สามารถใช้มันได้

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

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

เราได้ส่งรายงานการวิจัยพร้อมกับข้อค้นพบของเราในหัวข้อนี้แล้ว มันมีอยู่ที่นี่ อย่างไรก็ตามหากมันถูกตีพิมพ์ในสถานที่ทางวิทยาศาสตร์เรายินดีที่จะรับทราบผู้เขียนของการใช้งานที่ดีที่สุด

ขอบคุณ xnor สำหรับความช่วยเหลือของเขาเมื่อร่างคำถามนี้!


12
ฉันหวังว่าจะมีคนส่งคำตอบใน Seed
Robin Ryder

6
ในทำนองเดียวกันสามารถยกตัวอย่างเช่น brainfuck code ที่ 3 บิตต่อตัวอักษรหากไม่มี nops? และเป็น1683 bits at mostข้อ จำกัด ที่เข้มงวด [sic?] หรือเป้าหมายหรือไม่
บางคน

31
" หากการเรียงสับเปลี่ยนเป็นผลลัพธ์ของกระบวนการสุ่ม (ตามที่อ้างสิทธิ์โดยผู้ออกแบบ) จากนั้นโปรแกรมสั้นนี้จะไม่มีตัวตน " ฉันไม่เห็นด้วย (แม้ว่ามันจะไม่สำคัญสำหรับความท้าทาย) ถ้ามันเป็นผลลัพธ์ของกระบวนการสุ่มมันจะไม่น่าเป็นไปได้ที่โปรแกรมนั้นจะมีอยู่; หรือว่ามันจะเป็นเรื่องยากที่จะหา
หลุยส์ Mendo

8
@Grimy คำสั่งจากนั้นโปรแกรมสั้นนี้จะไม่มีอยู่เป็นแนวคิดหนึ่ง (ไม่ใช่โปรแกรมหนึ่ง) การใช้คำศัพท์ของคุณมันเป็นของโลกคณิตศาสตร์ที่บริสุทธิ์ไม่ใช่ในโลกแห่งการเขียนโปรแกรม
Luis Mendo

7
si XOR si11,10,68,79,146,153,220,221i=1s0=0

คำตอบ:


35

AMD64 Assembly (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) {
      สำหรับ (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;
}

ชุดประกอบ x86 64 บิต

    ; การประกอบ AMD64 78 ไบต์
    ; odzhan
    บิต 64

    ถังขยะ ifndef
      SubBytex ทั่วโลก
    endif%

SubBytex:
    mov al, 252
    jecxz L2; ถ้า (x) {
    โทร L0
k:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xee, 0xfc
s:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    ป๊อป rbx
    mov al, 1; y = 1
    cdq; z = 0
L1:
    inc dl; Z ++
    เพิ่ม al, al; y = y + y
    jnc $ + 4; ข้าม XOR หากไม่มีการพกพา
    xor al, 29;
    cmp al, cl; ถ้า (y! = x) goto L1
    jne L1    

    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; อัล = k [z]
    ทดสอบ dl, dl; ถ้า (x == 0) goto L2
    jz L2
    xchg eax, edx; อัล = x
    xlatb; อัล = k [x]
    xor al, cl; al ^ = s [z]
L2:
    เกษียณ

ถอดชิ้นส่วนรหัส 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, 0x4e, 0xdc, 0x98, 0x0a, 0x45
0000002A 5B ป๊อป rbx
0000002B B001 mov al, 0x1
0000002D 99 cdq
0000002E FEC2 inc dl
00000030 00C0 เพิ่มอัล
00000032 7302 jnc 0x36
00000034 341D xor al, 0x1d
00000036 38C8 cmp al, cl
00000038 75F4 jnz 0x2e
0000003A 92 xchg eax, edx
0000003B 99 cdq
0000003C B111 mov cl, 0x11
0000003E F7F1 div ecx
00000040 8A4C0311 mov cl, [rbx + rax + 0x11]
00000044 D7 xlatb
00000045 84D2 ทดสอบ dl, dl
00000047 7404 jz 0x4d
00000049 92 xchg eax, edx
0000004A D7 xlatb
0000004B 30C8 xor al, cl
0000004D C3 Ret

ชุดประกอบ x86 แบบ 32 บิต

    ; 72 ไบต์ของชุดประกอบ x86
    ; odzhan
    บิต 32

    ถังขยะ ifndef
      SubBytex ทั่วโลก
      global _SubBytex
    endif%

SubBytex:
_SubBytex:
    mov al, 252
    jecxz L2; ถ้า (x) {
    โทร L0
k:
    db 0xfc, 0xdc, 0xce, 0xfa, 0xe8, 0xf8, 0xea, 0xde, 
    db 0xcc, 0xec, 0xfe, 0xca, 0xd8, 0xc8, 0xda, 0xee, 0xee, 0xfc
s:
    db 0x01, 0xdd, 0x92, 0x4f, 0x93, 0x99, 0x0b, 0x44, 
    db 0xd6, 0xd7, 0x4e, 0xdc, 0x98, 0x0a, 0x45
L0:
    ป๊อป ebx
    mov al, 1; y = 1
    cdq; z = 0
L1:
    inc edx; Z ++
    เพิ่ม al, al; y = y + y
    jnc $ + 4; ข้าม XOR หากไม่มีการพกพา
    xor al, 29;
    cmp al, cl; ถ้า (y! = x) goto L1
    jne L1    
    xchg eax, edx; อัล = z
    aam 17; al | x = z% 17, ah | z = z / 17
    mov cl, ah; cl = z
    cmove eax, ecx; ถ้า (x == 0) al = z else al = x
    xlatb; al = k [z] หรือ k [x]
    jz L2; ถ้า (x == 0) goto L2
    xor al, [ebx + ecx + 17]; k [x] ^ = k [z]
L2:
    เกษียณ

ถอดชิ้นส่วนรหัส 32 บิต

00000000 B0FC mov al, 0xfc
00000002 E345 jecxz 0x49
00000004 E820000000 เรียก dword 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, 0x4e, 0xdc, 0x98, 0x0a, 0x45
00000029 5B ป๊อป ebx
0000002A B001 mov al, 0x1
0000002C 99 cdq
0000002D 42 incx
0000002E 00C0 เพิ่มอัล
00000030 7302 jnc 0x34
00000032 341D xor al, 0x1d
00000034 38C8 cmp al, cl
00000036 75F5 jnz 0x2d
00000038 92 xchg eax, edx
00000039 D411 aam 0x11
0000003B 88E1 mov cl, ah
0000003D 0F44C1 cmovz eax, ecx
00000040 D7 xlatb
00000041 7404 jz 0x47
00000043 32440B11 xor al, [ebx + ecx + 0x11]
00000047 C3 เรต

1
คำตอบที่ดี! เนื่องจาก OP กำลังมองหาการนับบิตสิ่งนี้ (85 ไบต์) ออกมาถึง680 บิตโดยใช้ 8 บิตต่อไบต์หรือ595 บิตโดยใช้ 7 บิตต่อไบต์ (เป็นไปได้เนื่องจากอักขระทั้งหมดเป็น ASCII) คุณอาจสั้นลงได้ถ้าคุณบีบอัดชุดอักขระที่ จำกัด ยิ่ง
Cullub

1
ยินดีต้อนรับสู่ PPCG; ทางออกแรกที่ดี
Shaggy

9
@Cullub จุดของฉันคือรหัสในคำตอบนี้เป็นเพียง C / Assembler ที่ได้รับการรวบรวมดังนั้นการนับไบต์ไม่ได้เป็นของรหัสที่กำหนด แต่ของรหัสที่รวบรวม และนั่นไม่ใช่ ASCII
ArBo

7
เพื่อความชัดเจน 84 ไบต์คือขนาดของรหัสเครื่องหลังจากประกอบแล้ว? หากเป็นเช่นนั้นควรอัปเดตชื่อเพื่อแสดงว่านี่เป็นคำตอบของรหัสเครื่องแทนที่จะเป็นคำตอบของชุดประกอบ
Potato44

1
และ BTW คุณไม่จำเป็นต้องใช้แบบแผนการโทรมาตรฐาน คุณสามารถใช้การประชุมที่กำหนดเองโดยที่ RBX จะถูกโทรออกโดยมีการบันทึก 2 ไบต์สำหรับการพุช / ป๊อป (และที่ซึ่งuint8_targs นั้นขยายเป็นศูนย์ถึง 64 บิตสำหรับ JRCXZ) นอกจากนี้ถ้าคุณเขียนตำแหน่งขึ้นอยู่กับรหัสที่คุณสามารถวางอยู่ที่โต๊ะลงทะเบียนที่มี 5 ไบต์mov ebx, imm32แทนที่จะเป็น 6 ไบต์/call popหรือใช้มันเป็นแบบdisp32in mov al, [table + rax], แต่มันอาจเสียตั้งแต่คุณมีสองxlatbตัวmovแล้ว เคล็ดลับโทร + ป๊อป shellcode ไม่ชนะเทียบกับ 7 ไบต์หน่วยงาน LEA RIP ญาติกับข้อมูลหลังจากที่retแม้ว่า
Peter Cordes

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>

หรือคุณอาจลองรุ่น UTF-8 ขนาด 72 ไบต์ที่เทียบเท่านี้:

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 ตามลักษณะของ L ในคำถาม
  • 220, ค่าตัวเติมของอาร์เรย์ s เมื่อใช้เฉพาะอาร์เรย์ k
  • Array s xor 220 ที่ตรงกันข้ามยกเว้นองค์ประกอบสุดท้ายหรือองค์ประกอบแรกก่อนที่จะกลับซึ่งเป็น 221 ที่จุดเริ่มต้นของสตริง

คุณจะทำอะไรกับชุดไฟ ป.ล. ฉันอาจจะขโมยกลอุบายของการดำเนินการในขอบเขตที่ตรงกันข้าม เรียบร้อยมาก
Peter Taylor

@PeterTaylor คุณสามารถรับอาร์เรย์ k โดยใช้ชุดพลังงานของ [48 36 38 18] (หรือกลับด้าน) ด้วยการเรียงลำดับที่ตรงไปตรงมาที่สุดและลดแต่ละ xor แต่ในภาษากอล์ฟที่ใช้ในคำถามนี้จนถึงตอนนี้มีเพียง 05AB1E เท่านั้นที่มีการสั่งซื้อที่ถูกต้อง เห็นได้ชัดว่าเจลลี่และสแตกซ์มีความคิดที่แตกต่างเกี่ยวกับสิ่งที่ฉันคิดว่าควรจะตรงไปตรงมา
jimmy23013

ขณะนี้ฉันกำลังตีกอล์ฟกับคำตอบของคุณที่ 05AB1E ค่าจำนวนเต็มสำหรับสตริงของคุณ"Ý0$&Ü™ÖD�’\n˜×EO“N"คืออะไร?
Kevin Cruijssen

@KevinCruijssen คุณกำลังถามเกี่ยวกับสิ่งที่พวกเขาหมายถึงหรือค่าตัวเลข (ซึ่งคุณสามารถเห็นได้จากการถ่ายโอนข้อมูลฐานสิบหก)?
jimmy23013

@ jimmy23013 อ่าแน่นอน .. ลืมเรื่อง hex-dump ..
Kevin Cruijssen

19

เยลลี่ 71 59 ไบต์

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

ลองออนไลน์!

ตรวจสอบความเป็นไปได้ทั้งหมด

ตอนนี้เขียนใหม่โดยใช้คำตอบ CJam อันชาญฉลาดของ 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 บิตดังนั้นภายใต้หนึ่งในสามของหน่วยเก็บข้อมูลไร้เดียงสาของ pi

บันทึก 3 ไบต์โดยใช้วิธีการค้นหาlจากคำตอบ CJam ของ jimmy23013ดังนั้นอย่าลืม upvote อันนั้นด้วย!

คำอธิบาย

ด่าน 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

1
59 ไบต์ , รุ่นอื่น
jimmy23013

15

C (gcc) , 157 148 140 139 ไบต์

การปรับปรุงเล็กน้อยในตัวอย่าง C

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;}

ลองออนไลน์!

C (gcc) , 150 142 127 126 ไบต์

อันนี้ขึ้นอยู่กับนิสัยใจคอ gcc และ x86 และ UTF-8

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;}

ลองออนไลน์!

ขอบคุณ @XavierBonnetain สำหรับพฤติกรรมที่ไม่ได้กำหนดไว้ -1 และน้อยกว่า


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

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ฟังก์ชั่น C ของ Port of Xavier Bonnetain (รุ่น 1106 บิต) จากที่นี่ด้วยการปรับปรุง@ceilingcat ที่เหมือนกันในคำตอบ C ของเขาเพื่อประหยัด 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: คุณสามารถล้อมรอบรหัสที่มี `ในความคิดเห็นที่มีสองของพวกเขาทั้งสองด้าน Ie ด้วย 'แทน`:' 'code'code ''.)
Kevin Cruijssen

อ๊ะขอโทษด้วยที่การจัดรูปแบบสับสน ฉันรู้เกี่ยวกับการ backticks เป็นสองเท่า แต่ฉันไม่ทราบว่ารายการที่บีบอัดมี backtick อยู่ในนั้น นอกจากนี้: s^=> ^(XOR เป็นสับเปลี่ยน) ที่จริงแล้วไม่s^_เหมือนกันQใช่ไหม
Grimy

@Grimy ขอบคุณ! คุณพูดถูก โดยทั่วไปเราตรวจสอบว่าหนึ่งในสามสิ่งต่อไปนี้คือ truthy i==0 || X==0 || X==1เพื่อออกจากวง:
Kevin Cruijssen

10

Stax , 65 64 62 59 58 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

น่าเสียดายที่โปรแกรมนี้ใช้คำสั่งบางอย่างที่ใช้คำสั่ง stax ที่คัดค้านภายใน ฉันลืมปรับปรุงการใช้งาน นี่ทำให้บางคำเตือนปลอมปรากฏขึ้น แต่ผลลัพธ์ยังคงถูกต้อง

นี้เป็นแรงบันดาลใจ jimmy23013 ของคำตอบที่ดี บางส่วนมีการเปลี่ยนแปลงเพื่อให้เหมาะกับ stax ที่ดีขึ้น

โปรแกรม Stax ที่เขียนด้วย ASCII ที่พิมพ์ได้มีตัวเลือกอื่นที่ช่วยประหยัดมากกว่า 1 บิตต่อไบต์เล็กน้อยเนื่องจากมีเพียง ASCII ที่พิมพ์ได้ 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


Stax มีSไว้สำหรับชุดพาวเวอร์ คุณสามารถรับชุดกำลังของ [18 38 36 48], ดัชนีและลดลงด้วย xor (ฉันไม่รู้ Stax และฉันไม่แน่ใจว่ามันจะสั้นกว่านี้)
jimmy23013

ฉันคิดว่าการสั่งซื้อชุดย่อยที่สแต็กซ์ผลิตโดยSผู้ดำเนินการไม่ได้อยู่ในลำดับที่ถูกต้องสำหรับการทำงาน เช่น"abc"SJ(powerset ของ "abc" เข้าร่วมกับช่องว่าง) สร้าง "ab abc ac bc c"
เรียกซ้ำ

8

Python 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

ลองออนไลน์!

ฟังก์ชั่นที่ใช้การเปลี่ยนแปลง รหัสใช้ตัวอักษร ASCII 7 บิตเท่านั้น

เข้ารหัสkเป็น Python 3 โดยการทดสอบเลื่อน^64ลงในช่วงที่พิมพ์ได้ ในทางตรงกันข้ามsจะถูกเข้ารหัสเป็นฐาน-256 [number]>>[shift]*8&255ตัวเลขของค่าคงที่ตัวเลขและตัวเลขที่มีการสกัดเป็น นี่สั้นกว่าการเข้ารหัสsในสตริงเนื่องจากจำนวนของอักขระเลี่ยงที่จำเป็นนี้แม้จะมีการเลื่อนที่เหมาะสมที่สุด^160เพื่อย่อให้เล็กที่สุด

การคำนวณแบบไม่ต่อเนื่องบันทึกจะทำย้อนหลัง การปรับปรุงx=x*2^x//128*285loops x=1ไปข้างหน้าในวงจรกลุ่มโดยการจำลองการคูณโดยสร้างจนกว่าจะถึงตัวตน เราเริ่มต้นบันทึกที่ไม่ต่อเนื่องที่l=255(ความยาวรอบ) และลดลงในแต่ละการวนซ้ำ เพื่อจัดการกับx=0เคสและทำให้ไม่วนซ้ำตลอดไปเรายังยุติเมื่อl=0ซึ่งทำให้x=0map l=0เป็นไปตามที่ระบุ


Python 2 ไม่มีการทดสอบที่ดีดังนั้นเราต้องทำmap(ord,...)(ArBo บันทึกไบต์ที่นี่) มันช่วยให้เราใช้/แทน//การหารจำนวนเต็ม

Python 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

JavaScript (ES6), 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

ลองออนไลน์!


JavaScript (Node.js) ,  149  148 ไบต์

ขึ้นอยู่กับการใช้งาน C ของ Xavier Bonnetain (ซึ่งนำเสนอที่นี่ )

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 173s[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

หมายเหตุ: นี่เป็นเพียงบันทึกด้านข้างที่ไม่เกี่ยวข้องกับคำตอบข้างต้น

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
    )
  )
)

ลองออนไลน์!



3

Python 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 ไบต์ของโปรแกรมหลามที่ดีที่สุดที่นี่

Python 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 คือคำตอบที่เป็นไปได้

Python 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 บริสุทธิ์อีกต่อไป), ความเอื้อเฟื้อของ ovs


3 ไบต์สั้นโดยใช้ตัวอักษรตัวอักษรแทนการ\x..หนี
OVS


@ovs ขอบคุณ! อาจเพิ่มจำนวนบิตบ้าง (ไม่แน่ใจว่าสิ่งใดสำคัญที่สุดสำหรับ OP) ดังนั้นฉันจะเก็บคำตอบเก่าไว้ด้วย
ArBo

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]}

ลองออนไลน์!

นี่คือพอร์ตของโซลูชันของฉันใน C ซึ่งมีสตริงแตกต่างกันเล็กน้อยซึ่งไม่จำเป็นต้องมี xor 17 ฉันคาดหวังว่าโซลูชันส่วนใหญ่จะใช้สตริง "@` rFTDVbpPBvdtfR @ \ xacp? \ xe2> 4 \ xa6 \ xe9 {z \ xe3q5 \ xa7 \ xe8 "สามารถปรับปรุงได้เช่นกัน (เพียงเปลี่ยนสตริงลบ xor 17 และ xor 173 แทน 188)

ฉันออกหนึ่งของการค้นหาโดยมีเงื่อนไขเพิ่ม17*17เพื่อlที่เรา (มากหรือน้อย) ได้ในการแก้ปัญหา ARM รหัสเครื่อง

สนิมมีการอนุมานและการปิดพิมพ์ แต่มันได้ปลดเปลื้อง (แม้สำหรับ booleans หรือระหว่างจำนวนเต็ม) จะชัดเจนเสมอความไม่แน่นอนจะต้องมีการทำเครื่องหมายมันไม่ได้มีผู้ประกอบการประกอบที่สามการดำเนินการจำนวนเต็มโดยค่าเริ่มต้นl+=1) ส่งคืนหน่วย ฉันไม่ได้จัดการเพื่อให้ได้วิธีแก้ปัญหาที่สั้นกว่าด้วยตัววนซ้ำเนื่องจากการปิด + การแมปยังคงเป็นความจริง

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

อัพเดท: ใช้ฟังก์ชั่นนิรนามจากคำแนะนำของ manatwork


1
ยกเว้นเมื่อเรียกซ้ำแบบไม่ระบุชื่อฟังก์ชั่น / lambdas เป็นที่ยอมรับดังนั้นคุณสามารถย้ายlet p=ไปที่ส่วนหัวและไม่นับ ไม่แน่ใจเกี่ยวกับการ;โทรที่ไม่ระบุชื่อ: ลองออนไลน์! .
จัดการ

1

05AB1E , 74 ไบต์

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

ท่าเรือ@NickKennedyแรกคำตอบ Jelly 's ฉันกำลังทำงานกับพอร์ตของคำตอบ CJamของ@ jimmy23013โดยตรงแต่ฉันอยู่ที่ 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]

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.