มีอัลกอริทึมหากินที่มีชื่อเสียงสำหรับการนับจำนวนบิตที่ตั้งค่าในจำนวนเต็มแบบ 32 บิตที่ไม่ได้ลงนาม:

int popcount(unsigned x) {
   x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
   x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
   x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
   return x;
}

ฉันจะไม่อธิบายที่นี่ แต่ลองนึกภาพโค้ดที่คล้ายกันสำหรับจำนวนเต็ม 512 บิต! ค่าคงที่เลขฐานสิบหกจะมีขนาดใหญ่และสร้างรูปแบบที่สวยงาม งานของคุณเป็นเพียงการพิมพ์ผลลัพธ์ที่แน่นอนนี้ :

0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

ไม่มีช่องว่างต่อท้ายโปรด - แม้ว่าการขึ้นบรรทัดใหม่จะเป็นตัวเลือกก็ตาม

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

05AB1E , 26 22 21 ไบต์

05AB1E ใช้การเข้ารหัสCP-1252

9F„0x0NÍo×9ooNoo>÷hJ,

ลองออนไลน์!

คำอธิบาย

9F                      # for N in [0 ... 8]
  „0x                   # push the string "0x"
     0NÍo×              # push 2**(N-2) zeroes
          9oo           # 2**2**9
                 ÷      # //
             Noo>       # (2**2**N+1)
                  h     # converted to base-16
                   J    # join everything to string
                    ,   # print with a newline

รุ่นอื่น ๆ ที่อาจได้รับการปรับปรุง

9F9ooNoo>÷h¾6o×J7o£R…0xÿ,
9F9ooNoo>÷h0žy×ìR7o£R…0xÿ,
9FX0No×1No×JCh7o×1K7o£…0xÿ,
8ÝovX0y×1y×JCh7o×1K7o£…0xÿ,
9F1NoÅ0D>)˜JCh1K7o×7o£…0xÿ,

Python 2, 52 49 46 ไบต์

หมายเลข kth ถูกกำหนดโดย 2**512/(2**2**k + 1)จะได้รับจาก นี่คือหมายเลข 512 บิตดังนั้นจึงเป็นเรื่องสำคัญที่จะขยายรูปแบบให้มีความกว้างต่างกัน

l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

บันทึก 3 ไบต์ด้วย Dennis
บันทึกได้ 3 ไบต์ด้วย xnor

PHP, 111 110 108 ไบต์

บันทึกหนึ่งไบต์ด้วย @ user59178

<?=($p=str_pad)("0x",130,5).$p($s="\n0x",131,3);for($x=1;$x<65;$x*=2)echo($p($s,131,$p(0,$x,0).$p(f,$x,f)));

รูปแบบของ 1024 บิตคืออะไร : D

เรติน่า 43 ไบต์

:`
0x128$*5
:`5
3
;{:`33
0f
0(f+)(0+)
0$2$1

ลองออนไลน์!

คำอธิบาย

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

:`
0x128$*5

สิ่งนี้จะแทนที่อินพุตว่างด้วย0xตามด้วย 128 วิ5และพิมพ์เพื่อสร้างบรรทัดแรก

:`5
3

อันนี้แทนที่5s ด้วย3s เพื่อสร้างบรรทัดที่สองและพิมพ์เช่นกัน

;{:`33
0f

นี่เป็นบรรทัดพิเศษที่ใส่เข้าไปครั้งสุดท้ายและจะเปลี่ยนทุกสอง3วินาที0fเพื่อสร้างบรรทัดที่สาม สิ่งนี้จะเริ่มวนซ้ำผ่านสองขั้นตอนสุดท้าย ( {) อย่างไรก็ตามสเตจนี้จะไม่ทำอะไรเลยหลังจากทำซ้ำครั้งแรกยกเว้นพิมพ์สถานะปัจจุบัน ;ไม่ใส่การส่งออกที่ปลายสุดของโปรแกรมที่จะหลีกเลี่ยงการทำซ้ำบรรทัดสุดท้าย

0(f+)(0+)
0$2$1

การแทนที่นี้จะแปลงแต่ละบรรทัดเป็นถัดไปโดยการสลับคู่ของfs และ0s อื่น ๆ เงื่อนไข "ทุกคู่อื่น ๆ " ถูกบังคับใช้โดยการจับคู่ศูนย์ด้านหน้าfซึ่งทำให้ไม่สามารถจับคู่คู่กันได้เนื่องจากการจับคู่ไม่สามารถทับซ้อนกัน

เป็นกลุ่ม 32 ไบต์

i5<CR>3<Esc>qqYpVrf$<C-V>{yPG1vr0q6@q<C-V>{I0x<Esc>

ฉันเพียงต้องการที่จะเขียนเป็นครั้งแรกด้วยตนเอง5และ3และแมโครดูแลส่วนที่เหลือ "เสแสร้งนับบิต" ในแต่ละครั้งที่มันวิ่ง ลำดับขั้นตอนในมาโครนั้นค่อนข้างแปลก (ทำการขึ้นfบรรทัดใหม่คัดลอกบล็อกฉลาดนำขนาดบล็อกภาพกลับมาใส่ใหม่0ในfบรรทัด) แต่มันเป็นตัวแปรที่เร็วที่สุดที่ฉันพบ

Pyth, 26 ไบต์

V9%"0x%0128x"/^2 512h^2^2N

พอร์ตของคำตอบ Python ของฉัน

J, 46 34 ไบต์

ฉันกำลังเล่นกอล์ฟอยู่ แต่เด็กคนนี้ชอบอยู่ที่ 46 ไบต์ ...ไม่อีกต่อไป! -12 ไบต์ขอบคุณไมล์!

'0x',"1'5','3','0f'(128$#)"{~2^i.7

ลองออนไลน์! : D

ผล

   '0x',"1'5','3','0f'(128$#)"{~2^i.7
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

สำหรับคำตอบนี้ฉันต้องการคำกริยาที่มีอันดับ (นึกคิด) 0 1เพื่อใช้ในการu"vกำหนดอันดับ; แม้กระนั้นไมล์ก็สังเกตเห็นว่า0 _เพียงพอสำหรับงานในมือ

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 0 0│_ 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│- │-.│-:│% │%.│%:│^ │^.│$ │$.│$:│~.│~:│0 0 0│0 _ _│0 _ _│0 0 0│2 _ 2│0 0 0│0 0 0│0 0 0│_ 1 _│_ _ _│_ _ _│_ 0 0│_ 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│| │|.│, │,.│,:│; │;:│# │#.│#:│! │/:│\:│0 0 0│_ 1 _│_ _ _│_ _ _│_ _ _│_ _ _│1 _ _│_ 1 _│1 1 1│_ 1 0│0 0 0│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│[ │[:│] │{ │{.│{:│}.│}:│".│":│? │?.│a │_ _ _│_ _ _│_ _ _│1 0 _│_ 1 _│_ 0 0│_ 1 _│_ 0 0│1 _ _│_ 1 _│0 0 0│_ 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│A │A.│b │C │C.│d │D │e │e.│E │E.│f │H │_ _ _│1 0 _│_ _ _│_ _ _│1 1 _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│0 _ _│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│i │i.│i:│I │I.│j │j.│L │L.│M │o │o.│p │_ _ _│1 _ _│0 _ _│_ _ _│1 _ _│_ _ _│0 0 0│_ _ _│_ 0 0│_ _ _│_ _ _│0 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│p.│p:│q │q:│r │r.│s │s:│S │t │T │u:│x:│1 1 0│0 _ _│_ _ _│0 0 0│_ _ _│0 0 0│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

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

ที่จริงแล้ว 25 ไบต์

9r`╙╙u9╙╙\#"0x%0128x"%`Mi

ลองออนไลน์!

วิธีการแก้ปัญหานี้ใช้ความจริงที่ว่าf(n) = 2**512//(2**2**n + 1)(ที่ไหน//คือการแบ่งพื้น) เพื่อรวบรวมค่า

คำอธิบาย:

9r`╙╙u9╙╙\#"0x%0128x"%`Mi
9r`╙╙u9╙╙\#"0x%0128x"%`M   for n in range(1, 10):
      9╙╙\                   2**2**9//
   ╙╙u                                (2**2**n + 1)
          #"0x%0128x"%       pad with zeroes to 128 digits, prefix with "0x"
                        i  flatten and implicitly print

JavaScript (Firefox 30+), 139 113 112 92 83 80 ไบต์

_=>[for(x of"970123456")(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)].join`
`

ในที่สุดก็ตีจุดหวานซ้ำ :-) ใช้ความเข้าใจสตริงที่มีประโยชน์ -dandy เพื่อบันทึก 3 ไบต์มากกว่า.map:

_=>[..."970123456"].map(x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)).join`
`

.replace ยัง 83 ไบต์:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)+`
`)

หากอนุญาตให้ขึ้นบรรทัดใหม่ได้ก็จะเป็น 80 ไบต์:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):`
0x`)(128))

Python 2 , 60 ไบต์

k=1
exec"print'0x%0128x'%int(256/k*('0'*k+'1'*k),2);k*=2;"*9

ลองออนไลน์!

Bubblegum , 65 ไบต์

00000000: c5cb 4501 0441 1043 d17b d4fc 254b d110  ..E..A.C.{..%K..
00000010: f7cb 9761 9e7a 8d45 e451 4ce4 564c 04d7  ...a.z.E.QL.VL..
00000020: 2e11 b02b 8f08 80df aa5e 11fe fc77 762c  ...+.....^...wv,
00000030: 428b 5b8e ae8b 30c1 13b6 ce8b b091 377a  B.[...0.......7z
00000040: 01                                       .

คำตอบ Bubblegum บังคับ

Haskell, 84 72 ไบต์

คำตอบของการย้าย @ orlp:

import Text.Printf
mapM(\n->printf"0x%0128x\n"$div(2^2^9)$2^2^n+1)[0..8]

ทางเลือก 94 ไบต์ที่ไม่มีพลังของText.Printf:

import Data.List
mapM(putStrLn.("0x"++))$transpose$("53"++).reverse<$>sequence(["0f"]<*[1..7])

r=[0..127]
mapM(putStrLn.("0x"++))$('5'<$r):('3'<$r):[["0f"!!mod(div x(2^y))2|x<-r]|y<-[0..6]]

PowerShell v2 +, 68 ไบต์

5,3|%{"0x"+"$_"*128}
($a=1)..7|%{"0x"+('0'*$a+'f'*$a)*(128/($a*=2))}

PowerShell ไม่มีจำนวนเต็มความแม่นยำโดยพลการโดยไม่ใช้ [bigint]โทรและสิ่งเหล่านั้นไม่สามารถแปลงเป็นเลขฐานสิบหกได้อย่างง่ายดายดังนั้นเราจึงถือว่าสิ่งนี้เป็นความท้าทายแบบสตริง

บรรทัดแรกจัดการการทำซ้ำ5และ3เพียงแค่ทำการคูณสตริงออกไปยัง128ตัวละครและตรึง0xที่ด้านหน้า

บรรทัดถัดไปจะวนจาก$a=1ไปเป็น7ซ้ำแต่ละครั้งจะแสดงสตริงอื่น อีกครั้งเรามีการ0xตรึงไว้ที่ด้านหน้าและเรากำลังทำการคูณสตริงที่อยู่ตรงกลางเพื่อสร้างจำนวนที่เหมาะสม0และfต่อกันเข้าด้วยกันแล้วทำการคูณสตริงของอักขระนั้นกับจำนวนอักขระที่เหมาะสม โปรดทราบว่าเราใช้ตัวแปร$aที่นี่และไม่ใช่ตัวนับลูป$_ดังนั้นเราจึงสามารถปรับขนาดได้อย่างเหมาะสม (ไม่เช่นนั้นเราจำเป็นต้องวนซ้ำ1,2,4,8,16,32,64|%{...}ซึ่งยาวกว่า)

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

V , 43 ไบต์

64i0fòYpÓ¨¨0«©¨f«©©û2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

ลองออนไลน์!

นี่ใช้หนึ่งใน regexes ที่ถูกบีบอัดที่ยาวที่สุดที่ฉันต้องการในคำตอบ V นี่เป็นเวอร์ชันที่อ่านได้มากกว่าซึ่งฉันเพิ่มไบต์สำหรับ regexes ที่อ่านได้และเปลี่ยนอักขระ escape ที่ไม่สามารถพิมพ์ได้<esc>

64i0f<esc>òYpÓö((0+)(f+)){2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

คำอธิบาย (ใช้รุ่นที่อ่านได้):

64i0f<esc>                                          " Insert 64 "0f"s and escape to normal mode
          ò                      ò                  " Recursively:
           Yp                                       "   Duplicate this line
             Ó                                      "   Substitute:
              ö                                     "     (Optionally Turn the readable version on)
               ((0+)(f+))                           "     One or more '0's followed by one or more 'f's
                         {2}                        "     Repeated twice
                            /                       "   With:
                             ²²                     "     The second capture group twice (the '0's)
                               ³³                   "     Followed by the third capture group twice (the 'f's)
                                                    "   Once the search is not found, the loop will break
                                  dd                " Delete a line (because we have one too many)
                                    {               " Move to the first line
                                     3Ä             " Make three copies of this line
                                       Ò5           " Replace the first one with '5's
                                         jÒ3        " Move down a line and replace the second with '3's
                                            Î       " On every line:
                                             i0x    "   Insert a '0x'

JavaScript (ES6), 74 72 70 ไบต์

รวมบรรทัดใหม่ที่เป็นตัวเลือกต่อท้าย

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

console.log(f())

Pyth - 31 30 ไบต์

เพื่อให้ได้รูปแบบการยกเว้น3'และ5' s มันสะสมลดทุกครั้งเสแสร้งชิ้น

jm+"0x".[dd128+`3+`5.u.iNN6"0f

ลองออนไลน์ได้ที่นี่ลองมันออนไลน์ได้ที่นี่

แบตช์, 216 ไบต์

@echo off
set s=5
call:c
set s=3
call:c
set a=0
set b=f
for /l %%i in (1,1,7)do call:l %%i
exit/b
:l
set s=%a%%b%
:c
for /l %%j in (0%1,1,6)do call set s=%%s%%%%s%%
echo 0x%s%
set a=%a%%a%
set b=%b%%b%

เป็นกลุ่ม 72 ไบต์

i0x128a5Ypll128r3o0x64a0fa0Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

TryItOnline!

Unprintables:

i0x^[128a5^[Ypll128r3o0x^[64a0f^[a0^[Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

@wตอนท้ายของ4 กำลังบากฉัน แต่เพราะฉันพึ่งที่@qจะล้มเหลวในตอนท้ายของบรรทัดมันก็ล้มเหลว @ @ ด้วย ฉันอาจลองเรียกใช้คิว 32 ครั้งและดูว่ามันเลอะเทอะในภายหลังหรือไม่

C, 146 ไบต์

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){char s[131]={'0','x'};F'5'P F'3'P for(j=1;(j*=2)<129;){F(i-1)%j<j/2?'0':'f'P}}

Ungolfed:

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){
  char s[131]={'0','x'};
  F'5'P
  F'3'P
  for(j=1;(j*=2)<129;){
    F(i-1)%j<j/2?'0':'f'P 
  }
}

brainfuck , 211 ไบต์

+++++++>++>>-[>>>>+<<++<+<-----]>--->>++++++++++>++<<<<<<[->----[>+++<--]>-->.<.++++++++[->>>>.<<<<]>>>.>--[<]<<]+<[->>----[>+++<--]>-->.<.++++++++[<<[>+>->.<<<-]>[<+>>->>.<<<-]>]>>>.<<<<[-<+>]<[->++<]>[-<+>]<<]

ลองออนไลน์!

GNU sed 4.2.2 , 77

s/^/0x5/
:
s/x5{,127}$/&5/
t
p
y/5/3/
p
s/33/0f/gp
:a
s/(f+)(0+f+)/\2\1/gp
ta

ลองออนไลน์

Ruby , 66 60 45 ไบต์

x=2;9.times{puts"0x%0128x"%(2**512/-~x);x*=x}

ลองออนไลน์!

ไอเดียถูกขโมยจากorlp

C #, 168 ไบต์

()={string R="",o="0",f="f";for(int i=0,j;i<9;i++){R+="0x";if(i>2){o+=o;f+=f;}for(j=0;j<128;){R+=i<1?"5":i<2?"3":o+f;j+=i>1?(int)Math.Pow(2,i-1):1;}R+="\n";}return R;};

Stax , 19 ไบต์

⌡hÅék╝94"ºé♪╛#V┐5í╒

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

คลายกล่อง ungolfed และแสดงความคิดเห็นมันมีลักษณะเช่นนี้

512r        [0..511]
{:Brm       convert each to bits and reverse each
M           transpose matrix, filling missing elements in rectangle with zero
m           map over each element of array, using the rest of the program.  outputs implicitly.
  4/        split bits into groups of 4
  {:b|Hm    convert each 4-bit binary number to single digit hex string
  .0xp      print "0x" without newline

เรียกใช้อันนี้

/// , 193 ไบต์

/*/\/\///X/
0x*F/5555*G/FFFF*T/3333*U/TTTT*o/0f0f*1/oooo*t/00ff*2/tttt*g/0000*h/ffff*4/ghgh*6/gghh*7/gggg*8/hhhh*9/7788/0xGGGGGGGGXUUUUUUUUX11111111X22222222X44444444X66666666X78787878X99X77988

ลองออนไลน์!