Có một thuật toán phức tạp nổi tiếng để đếm số lượng bit được đặt trong một số nguyên không dấu 32 bit:

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

Tôi sẽ không giải thích nó ở đây. Nhưng hãy tưởng tượng mã tương tự cho số nguyên 512 bit! Các hằng số thập lục phân sẽ rất lớn và tạo thành một mô hình đẹp. Nhiệm vụ của bạn chỉ đơn giản là in đầu ra chính xác này :

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

Không có dấu cách, xin vui lòng - mặc dù một dòng mới duy nhất là tùy chọn.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

05AB1E , 26 22 21 byte

05AB1E sử dụng mã hóa CP-1252 .

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

Hãy thử trực tuyến!

Giải trình

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

Các phiên bản khác có thể được cải thiện

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 byte

Số thứ k được đưa ra bởi 2**512/(2**2**k + 1). Đây là số 512 bit, vì vậy việc mở rộng mẫu thành các chiều rộng khác nhau là chuyện nhỏ.

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

3 byte được lưu nhờ Dennis.
3 byte được lưu nhờ xnor.

PHP, 111 110 108 byte

Một byte được lưu nhờ vào @ 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)));

Những gì dữ liệu mô hình cho 1024 bit? : D

Võng mạc , 43 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này giúp sử dụng nhiều :tùy chọn thường được sử dụng cho phép bạn in kết quả trung gian, vì nó ngắn hơn rất nhiều để sửa đổi một dòng so với xây dựng toàn bộ đầu ra.

:`
0x128$*5

Điều này thay thế đầu vào trống 0xbằng 128 5giây và in nó để tạo dòng đầu tiên.

:`5
3

Cái này thay thế 5s bằng 3s để tạo dòng thứ hai và in nó.

;{:`33
0f

Đây là dòng có vỏ đặc biệt cuối cùng và nó biến mỗi hai 3giây thành 0fdòng thứ ba. Điều này cũng bắt đầu một vòng lặp thông qua hai giai đoạn cuối ( {). Tuy nhiên, giai đoạn này sẽ không làm gì sau lần lặp đầu tiên ngoại trừ in trạng thái hiện tại. Việc ;triệt tiêu đầu ra ở cuối chương trình để tránh trùng lặp dòng cuối cùng.

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

Sự thay thế này bây giờ biến đổi mỗi dòng thành dòng tiếp theo, bằng cách hoán đổi mọi cặp fs và 0s khác. Điều kiện "mọi cặp khác" được thi hành bằng cách khớp số 0 ở trước f, điều này khiến cho không thể khớp các cặp liên tiếp vì các kết quả khớp không thể trùng nhau.

Vim, 32 byte

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

Tôi chỉ cần viết thủ công đầu tiên 5và 3, macro sẽ chăm sóc phần còn lại, "nhân đôi số bit" mỗi khi nó chạy. Thứ tự các bước trong macro hơi kỳ lạ (tạo một fdòng mới , sao chép khối, sử dụng lại kích thước khối trực quan để đặt 0s vào fdòng), nhưng đó là biến thể nhanh nhất tôi tìm thấy.

Bình thường, 26 byte

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

Cổng câu trả lời Python của tôi.

J, 46 34 byte

Tôi đang làm việc để chơi gôn này, nhưng em bé này thích ở mức 46 byte ... Không còn nữa! -12 bytes nhờ dặm!

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

Hãy thử trực tuyến! : D

Kết quả

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

Đối với câu trả lời này, tôi cần (lý tưởng) một động từ có thứ hạng 0 1để sử dụng nó trong u"vđịnh nghĩa về thứ hạng; Tuy nhiên, dặm quan sát thấy rằng 0 _đã đủ cho nhiệm vụ trong tầm tay.

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 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│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Ở đây bạn thấy một loạt các biểu diễn chuỗi của động từ với các cấp bậc tương ứng của chúng. Đây là kịch bản tôi đã sử dụng để tạo ra nó.

Trên thực tế , 25 byte

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

Hãy thử trực tuyến!

Giải pháp này sử dụng thực tế là f(n) = 2**512//(2**2**n + 1)(nơi //được phân chia nổi) để tính toán các giá trị.

Giải trình:

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 byte

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

Cuối cùng đạt đến điểm ngọt đệ quy :-) Sử dụng cách hiểu chuỗi tiện dụng để tiết kiệm 3 byte trên .map:

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

.replace cũng là 83 byte:

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

Nếu một dòng mới hàng đầu được cho phép, thì đây cũng sẽ là 80 byte:

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

Python 2 , 60 byte

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

Hãy thử trực tuyến!

Bong bóng , 65 byte

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                                       .

Câu trả lời bắt buộc Bubblegum.

Haskell, 84 72 byte

Câu trả lời của @ orlp:

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

94 byte thay thế mà không có sức mạnh của 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 byte

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

PowerShell không có số nguyên chính xác tùy ý mà không sử dụng [bigint] các cuộc gọi và chúng không thể dễ dàng chuyển đổi thành thập lục phân, vì vậy chúng tôi thay vào đó coi đây là một thách thức dựa trên chuỗi.

Dòng đầu tiên xử lý việc lặp lại 5và 3chỉ bằng cách thực hiện một chuỗi nhân cho các 128ký tự và xử lý một0x ở phía trước.

Các vòng lặp tiếp theo từ $a=1đến 7, mỗi lần lặp xuất ra một chuỗi khác. Một lần nữa, chúng ta đã giải 0xquyết vấn đề ở phía trước và chúng ta đang thực hiện phép nhân chuỗi ở giữa để xây dựng số lượng thích hợp 0và fnối với nhau, sau đó thực hiện phép nhân chuỗi đó với số lượng ký tự phù hợp. Lưu ý rằng chúng tôi đang sử dụng biến $aở đây chứ không phải bộ đếm vòng lặp $_, vì vậy chúng tôi có thể chia tỷ lệ chính xác (nếu không chúng tôi cần phải lặp như1,2,4,8,16,32,64|%{...} , dài hơn).

Các chuỗi kết quả được để lại trên đường ống và đầu ra thông qua ẩn Write-Outputxảy ra khi hoàn thành chương trình, với một dòng mới giữa các phần tử.

V , 43 byte

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

Hãy thử trực tuyến!

Điều này sử dụng một trong những biểu thức nén dài nhất mà tôi từng cần trong câu trả lời V. Đây là phiên bản dễ đọc hơn, trong đó tôi đã thêm một byte cho các biểu thức chính có thể đọc được và thay đổi ký tự thoát không thể in thành<esc>

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

Giải thích (sử dụng phiên bản có thể đọc được):

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 byte

Bao gồm các dòng mới tùy chọn.

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 byte

Để có được mô hình ngoại trừ 3's và 5là nó tích lũy giảm, mỗi lần tăng gấp đôi khối.

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

Hãy thử trực tuyến tại đây .

Mẻ, 216 byte

@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%

Vim 72 byte

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

Dùng thử trực tuyến!

Không thể in

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

4 @wgiây ở cuối đang làm phiền tôi, nhưng vì tôi đã dựa vào việc @qthất bại ở cuối dòng, nó cũng thất bại với @w. Tôi có thể thử chỉ chạy q 32 lần và xem nó có làm rối các dòng sau không.

C, 146 byte

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

Ung dung:

#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 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến.

Ruby , 66 60 45 byte

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

Hãy thử trực tuyến!

Ý tưởng bị đánh cắp từ orlp

C #, 168 byte

()={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 byte

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

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa, và nhận xét, nó trông như thế này.

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

Chạy cái này

/// , 193 byte

/*/\/\///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

Hãy thử trực tuyến!