魔术弹出数

25

有一个著名的棘手算法可以计算 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

请不要在结尾添加空格-尽管单个结尾的换行符是可选的。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

code-golf  string  kolmogorov-complexity  hexadecimal 
— 林恩
source
我们是否可以接受输入（例如0x0x0x0x0x0x0x0x0x0x）？
— ouflak
@ouflak号———
— 林恩

Answers:

3

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ÿ,
— 艾米尼亚
source
21

Python 2，52 49 46字节

第k个数字由给出2**512/(2**2**k + 1)。这是针对512位数字的，因此将模式扩展到不同的宽度很简单。

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

感谢Dennis，节省了3个字节。
多亏了xnor，节省了3个字节。

— 奥尔普
source
2
任意精度整数的优点...
— ETHproductions'December
真好 这样可以节省一些字节。
— 丹尼斯，
保持平方的时间更短：l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9
— xnor
1
看到Python进入投票领先令我感到
— 振奋
4
@TuukkaX我只是有一些乱七八糟的黑客经验。我经常使用Wolfram Alpha来简化求和等。但基本上我做的模式01010101，00010001，00000001，再乘以那些1，11，1111以获得正确的二进制模式。例如，01010101您可以通过执行确定sum 2^(2*k) for k = 0, w/2 - 1并找到公式w来获得特定宽度w的公式(2**w - 1)/3。
— orlp
7

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

— 提图斯
source
1
您可以使用$x<65而不是保存一个字节$i++<7。这次我测试了所有内容。
— user59178 '16
6

视网膜，43字节

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

在线尝试！

说明

这充分利用了通常未被充分利用的:选项，该选项使您可以打印中间结果，因为修改单行比建立整个输出要短得多。

:`
0x128$*5

这将空输入替换为0x128 ，然后将其5打印以生成第一行。

:`5
3

该代码用5s 替换3s来生成第二行并打印。

;{:`33
0f

这是最后一个特殊情况的行，它将每两秒3转换成0f第三行。这也将启动最后两个阶段（{）的循环。但是，除了打印当前状态外，此阶段在第一次迭代后将不执行任何操作。在;抑制了在节目的最后输出，以避免重复的最后一行。

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

现在，此替换通过交换每对fs和0s 将每行转换为下一行。通过匹配前面的零来强制执行“其他所有对”条件f，这使得无法匹配连续的对，因为匹配不能重叠。

— 马丁·恩德
source
6

Vim，32个字节

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

我只需要手动编写第一个5和3，宏就会处理其余的事情，每次运行时都会“加倍计数”。宏中步骤的顺序有点奇怪（创建新f行，逐块复制，重复使用可视块大小以将0s放入f行中），但这是我找到的最快的变体。

— 乌迪欧卡
source
5

Pyth，26个字节

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

我的Python回答的端口。

— 奥尔普
source
5

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│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

在这里，您可以看到一堆动词的字符串表示形式以及它们各自的等级。这是我用来生成脚本的脚本。

— 科纳·奥布莱恩
source
有等级的动词0 _在这里很好。您可以将其缩短为34个字节，其中包含'0x',"1'5','3','0f'(128$#)"{~2^i.7
— miles
@miles呵呵。我以为我尝试过...好酷！我忘记了J的自动行填充功能，再次感谢！
— 科纳·奥布赖恩
4

其实 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
— 梅果
source
4

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

最后到达递归的最佳位置:-)使用方便的字符串理解功能，可以节省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))
— ETH生产
source
3

泡泡糖，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                                       .

强制性泡泡糖答案。

— 军团哺乳动物978
source
3

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]]
— 昂斯
source
@nimi糟糕，必须已Control.Monad在REPL中加载。固定。
— 2016年
3

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即可。

下一行从循环$a=1到7，每次迭代输出另一个字符串。再次0x强调，我们在中间进行字符串乘法，以构造适当数量的，0并将其f串联在一起，然后对该字符串进行字符串乘法，以得出适当数量的字符。请注意，我们在$a这里使用的是变量，而不是循环计数器$_，因此我们可以适当缩放（否则，我们需要像那样循环1,2,4,8,16,32,64|%{...}，这要更长一些）。

结果字符串留在管道上，并Write-Output在程序完成时通过隐式发生输出，并在元素之间添加换行符。

— AdmBorkBork
source
3

V，43字节

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

在线尝试！

这使用了我在V答案中需要的最长的压缩正则表达式之一。这是更具可读性的版本，在其中我为可读的正则表达式添加了一个字节，并将不可打印的转义符更改为<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'
— DJMcMayhem
source
3

JavaScript（ES6），74 72 70字节

包括可选的尾随换行符。

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

显示代码段

— Arnauld
source
2

批处理，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%
— 尼尔
source
2

Vim 72字节

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

TryItOnline！

无法打印的内容：

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

最后的4 @ws困扰着我，但是由于我依赖于@q在行尾失败，所以@w也失败了。我可能会尝试只运行q 32次，看看是否弄乱了后面的行。

— nmjcman101
source
2

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

取消高尔夫：

#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 
  }
}
— 卡尔·纳普夫
source
— ceilingcat
2

笨蛋，211字节

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

在线尝试！

— ბიმო
source
1
通过一些不同的循环检查获得197个字节。我敢肯定的x发生器可循环外，现在移动
— 乔金
1

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;};
— 约德尔
source
1

Stax，19 个字节

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

运行并调试

拆开包装，松开包装并进行评论，看起来像这样。

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

运行这个

— 递归的
source
1

///，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

在线尝试！

— 暴民埃里克
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.