从“无限”倒数

47

似乎是不可能完成的任务吧？好吧，实际上并不难。如果将单词写Infinity为8位二进制ASCII代码，则会得到：

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

可以串联并转换为十进制值5291279215216915577。现在是我们可以使用的数字...

您将倒数的方式是：

  1. 将原始字符串输出为十进制数字（如上所示）
  2. 删除其二进制表示形式中的前导0（如果有）
  3. 切换二进制表示形式的位（1-> 0，0-> 1）
  4. 输出十进制数字
  5. 重复步骤2-4，直到达到0。

挑战：

创建一个程序或函数，该程序或函数将字符串作为输入，并输出（以任何合适的格式）执行上述步骤时所得到的数字。

测试用例：

我认为这个挑战将非常容易理解，尽管它只是一个测试用例。我将使用Inf而不是Infinity使它简短。

Inf
4812390  (10010010110111001100110)
3576217  ( 1101101001000110011001)
618086   (   10010110111001100110)
430489   (    1101001000110011001)
93798    (      10110111001100110)
37273    (       1001000110011001)
28262    (        110111001100110)
4505     (          1000110011001)
3686     (           111001100110)
409      (              110011001)
102      (                1100110)
25       (                  11001)
6        (                    110)
1        (                      1)
0        (                      0)


Input: Inf 
Output:
4812390, 3576217, 618086, 430489, 93798, 37273, 28262, 4505, 3686, 409, 102, 25, 6, 1, 0 


Input: Infinity
Output:
5291279215216915577, 3932092821637860230, 679593196789527673, 473328307817319302, 103132444486104185, 40982743589751686, 31074850448176249, 4953946570787718, 4053252683953273, 450346943417222, 112603010004089, 28134478351238, 7049893737593, 1746199284614, 452823970937, 96931842950, 40507110521, 28212366214, 6147372153, 2442562438, 1852404857, 295078790, 241792121, 26643334, 6911097, 1477510, 619641, 428934, 95353, 35718, 29817, 2950, 1145, 902, 121, 6, 1, 0

您的代码必须支持可以用二进制数表示的字符串，最多可以使用您的语言。所有字符串将仅包含32-126（空格到波浪号）的可打印ASCII字符。

排行榜

显示代码段

code-golf  base-conversion  counting 
— 斯蒂夫·格里芬
source
31
查克·诺里斯（Chuck Norris），8个字节：Inf:-1:0
— 路易斯·门多
2
@LuisMendo Chuck Norris的NARS-APL：∞..0
— 2013年
5
@LuisMendo您确定您不是要说Jon Skeet吗？
— mbomb007 '16

Answers:

12

果冻，15 10 字节

@ Dennis，-5个字节（在有序转换后直接从基数256转换）

Oḅ⁹µBCḄµÐĿ

TryItOnline！

怎么样？

Oḅ⁹µBCḄµÐĿ - Main link: s                     e.g. "Inf"
O          - cast to ordinals                 e.g. [73,110,102]
 ḅ⁹        - convert from base 256 to integer e.g. 4812390
   µ   µ   - monadic chain separations
    B      -     convert to binary
     C     -     complement
      Ḅ    -     convert to integer
        ÐĿ - loop until no longer unique and collect results
— 乔纳森·艾伦
source
1
第一部分是正义Oḅ⁹。
— 丹尼斯，
哦，我，我怎么想念它？
— 乔纳森·艾伦，2016年
11

Python 2，89 82 77 76 75字节

n=0
for c in input():n=n<<8|ord(c)
while 1:print n;n^=2**n.bit_length()-n/n

在Ideone上进行测试。

这个怎么运作

在将n初始化为0之后，第二行执行挑战中指定的字符串到整数的转换，如下所示。

在每个步骤中，n都向左移动8个单位，然后与下一个字符c的代码点按位进行“ 或”运算。对于输入Inf，其操作如下。

n                                  0
a = n<<8                           0
b = 'I'                      1001001
n = a ^ b                    1001001
a = n<<8             100100100000000
b = 'n'                      1101110
n = a ^ b            100100101101110
a = n<<8     10010010110111000000000
b = 'f'                      1100110
n = a ^ b    10010010110111001100110

现在我们准备生成输出。为了反转n的位，我们进行如下操作。

首先，我们计算n的二进制表示形式中的位而没有前导零。我们将结果称为k。然后，我们计算ķ ķ的功率2，其具有K + 1级的二进制数字：一个单一的1，随后ķ 0的。我们从结果中减去1，得到一个由k个数组成的数字，然后将其与n进行XOR运算以反转其位。输入信息如下。

n         4812390   10010010110111001100110
k              23 
t = 2**k           100000000000000000000000
t -= 1              11111111111111111111111
n ^= t    3576217    1101101001000110011001
k              22
t = 2**k            10000000000000000000000
t -= 1               1111111111111111111111
n ^= t     618086      10010110111001100110
.
.
.
n               6                       110
k               3
t = 2**k                               1000
t -= 1                                  111
n ^= t          1                         1
k               1
t = 2**k                                 10
t -= 1                                    1
n ^= t          0                         0

在实施额外的障碍是，我们必须打印ñ的第一步之前，之后的最后一步，并在两者之间的所有步骤。Python没有do-while循环，并且单个print语句占用8个字节，因此我们改为执行以下操作。

在更新步骤的直接实现中，即

while n:print n;n^=2**n.bit_length()-1
print n

我们将循环替换为无限一个（while 1），并计算1循环中的n/n。当n> 0时，这是等效的。

一旦n = 0，我们将停留在循环中，再次打印状态，然后尝试对其进行更新。但是，0/0会触发ZeroDivisionError，它会跳出循环并退出并出现错误。请注意，这会导致杂散输出到STDERR，默认情况下允许。

— 丹尼斯
source
2
我喜欢这个-n/n把戏:-)
— ETHproductions'Nov
你能比n/n骗子解释吗？可能在其他地方的另一个答案中对此做了解释，但我还没有找到。它在这里做什么？
— Stewie Griffin
@StewieGriffin n / n为1，直到n为0，然后抛出错误并导致程序停止。
— jazzpi '16
出现错误消息（我希望）？
— Stewie Griffin
1
@StewieGriffin确实。在错误报告方面，Python 非常冗长。我已经编辑了答案，加入了解释。
— 丹尼斯
8

JavaScript，82个字节

感谢@Arnuald节省了一个字节

for(y of prompt(n=0))n=n<<8|y.charCodeAt()
for(;alert(n)|n;)for(i=1;i<=n;i*=2)n^=i
展开摘要

完整程序的性能优于功能（而ES6的性能不超过ES5）的极少数情况之一。

上面最多支持4个字母的单词。添加4个字节以支持最多6个字母的单词：

for(y of prompt(n=0))n=n*256+y.charCodeAt()
for(;alert(n)|n;n=i-n-1)for(i=1;i<=n;)i*=2
展开摘要

— ETH生产
source
g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0（-1）
— 泰特斯
@Titus谢谢！不知道为什么我没想到
— ETHproductions'Nov
n<<8|y.charCodeAt()应该保存一个字节。for(;n;)for(i=!alert(n);i<=n;i*=2)n^=i会保存另一个字节，但您不会显示0，这可能是必需的。
— Arnauld
@Arnauld谢谢。我想n<<8早点做，但决定不起作用，因为它将破坏n位超过31位。我想现在已经将它分为31位版本和53位版本了...这并不重要...可悲的是，我不认为我可以在警告第一个警告的同时保存任何内容迭代和最后。
— ETHproductions's
7

其实 14个位元组

2@├¿W■├♂≈♂Y2@¿

在线尝试！

说明：

2@├¿W■├♂≈♂Y2@¿
 @├             encode input in binary
2  ¿            convert from binary to decimal
    W           while the number is not 0:
     ■            print the number without popping
      ├           convert number to binary
       ♂≈         convert each character to an int
         ♂Y       boolean negate each int
           2@¿    convert from binary to decimal
— 麦高
source
6

05AB1E，18个字节

使用CP-1252编码。

Çžz+b€¦J[CÐ,_#bS_J

在线尝试！

说明

Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join
— 艾米尼亚
source
4

MATL，13字节

8W:qZA`tB~XBt

在线尝试！

说明

8W:q            % Push array [0 1 ... 255]
    ZA          % Take input string and convert it from the base defined by the
                % alphabet [0 1 ... 255] to decimal
      `         % Do...while
       t        % Duplicate
        B       % Convert to binary
         ~      % Negate
          XB    % Convert to decimal
            t   % Duplicate. Used as loop condition: exit if zero
— 路易斯·门多
source
4

Mathematica，99个字节

a=FromDigits;b=IntegerDigits;NestWhileList[a[1-#~b~2,2]&,a[Join@@b[ToCharacterCode@#,2,8],2],#>0&]&

匿名函数。将字符串作为输入，并返回数字列表作为输出。

— 军团哺乳动物978
source
4

Haskell中，109个 123 118 102 97字节

感谢@nimi节省了5个字节！

c 0=0
c n=1-mod n 2+2*c(div n 2)
(++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum

用法： (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"

通过该语言保证可以处理最多29位的数字，通常在64位系统上最多可以处理63位的数字。使用map(fromIntegral.fromEnum)替代（+14字节），可以支持任意大数。

适用于unicode范围[0..255]。递归翻转位。

— 昂斯
source
1
您可以替换takeWhile(>0)为fst.span(>0)。如果您没有意义，则可以删除名称f，因此主要功能是(++[0]) ... map fromEnum。
— nimi
@nimi谢谢，删除名称可以解决我遇到的类型推断问题f。
— 昂斯
为什么fromIntegral呢 面对挑战：“必须支持……最高63位……或您所用语言的限制”，所以Int应该没问题。如果要保留它，请将其移至map，即旧版本的foldl1和map(fromIntegral.fromEnum)。
— nimi
@nimi OP在这里发表评论（已删除），询问它是否支持63位，因此我认为这是他的意图。甘拜下风。
— 昂斯
4

PHP，132个 126 123 120 108 107字节

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));
  • 循环后打印0而不是循环前的初始值将节省6个字节。
  • unpack而不是str_split使ord()过时-> -3个字节
  • 下划线_作为分隔符可节省3。
  • bindec而不是ltrim删除前导零：-12
  • echoin循环体内的print循环头节省了1个字节。
— 泰特斯
source
不能$n=$n*256+$i;for(print$n;$n;)写成for(print$n=$n*256+$i;$n;)？由于分配部分将执行一次，因此应该可以工作。并且 echo _.$n=[...]应该使用echo _,$n=[...]代替。它不会保存任何字节，但会加速代码个小小个小小位，将分别发表声明。例如，这意味着echo _,$a?5:6;可以编写而不是echo _.($a?5:6);。这将来可能会有所帮助。
— 伊斯梅尔·米格尔
@IsmaelMiguel分配部分是一个循环。当我不需要点时，我实际上使用逗号。print在这种情况下是残留的。一个人不值得编辑；但是谢谢。
— 泰特斯
哦，对了。。。在里面foreach(unpack("C*",$argv[1])as$i)。。。傻了。。。是的，更改逗号的周期以产生相同的效果不值得麻烦。
— 伊斯梅尔·米格尔
4

Perl，65个字节

53字节代码+ 12 for -Mbigint -p。

感谢@Dada为我节省了13个字节！

$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0

相当简单的方法，与大多数方法不同的是，数字以二进制存储并以十进制打印出来。我确信可以改进它，也许可以将详细信息存储在数组中。-Mbigint有点不方便但有必要。

用法

echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0
— 唐·黑斯廷斯
source
1
打开我的朋友的行李，打开行李！perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'（我不知道通常如何使用unpack，在搜索如何将字符串转换为二进制时我只是很幸运；
— Dada
啊，我总是忘unpack了语法总是让我震惊！我会更新，谢谢！
— Dom Hastings
有perlpacktut应该会有所帮助...我已经阅读了前10行数十次，但是我真的应该花时间阅读其余的内容！
— 达达
@Dada我敢肯定我已经读过很多遍了，它永远不会停留在......再次感谢-13是一项不小的壮举！我不得不切换到echo -n是唯一的其他更改。
— Dom Hastings
4

Pyth，12个字节

.usi!MjN2 2C

该程序接受带引号的字符串的输入，并将结果打印为整数列表。

验证所有测试用例

这个怎么运作

.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print
— 骑自行车的维京人
source
3

Python 3，99 95字节

x=int.from_bytes(bytes(input(),'utf-8'),'big')
while x:print(x);x^=2**x.bit_length()-1
print(0)

主要思想是将字符串转换为字节再转换为数字。每次迭代都将输出和全为1的XOR输出到零。

— 吉米·约翰逊（Jimmy Johnson）
source
您不需要括号2**x.bit_length()-1。幂和减法的运算顺序高于xor。另外，while可以在一行上。
— mbomb007 '16
在一行上写while循环（删除换行并缩进）
— FlipTack
尝试P=print使用P()来启动程序，然后使用代替print()
— Cyoce
3

Python 2中，117个 115字节

由于Cyoce，节省了2个字节。

假定输入用引号引起来，例如 "Inf"

s=input()
n=sum(ord(s[-i-1])<<i*8for i in range(len(s)))
while n:
 print n;k,m=n,1
 while k:k/=2;m*=2
 n^=m-1
print 0

m计数到最高位数，因此m-1XOR掩码也可以执行所需的操作。最长的部分是将输入转换为初始位序列。

例：

"Inf"
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

"Infinity"
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0
— 卡尔·纳普夫
source
您可以替换-i-1为~i
— Cyoce，2016年
3

Ruby，104 101 100 81 80 65字节

@WayneConrad节省了19个字节！
@philomory节省了15个字节！
感谢@LeeW，节省了1个字节！

p n=$*[0].unpack('B*')[0].to_i(2)
p n^=2**n.bit_length-1while n>0

通过命令行参数获取输入。

受到@JimmyJohnson的Python答案的启发

— 乔斯
source
通过替换i.to_s(2).rjust 8,'0'为"%08b"%i
— Wayne Conrad，
此外，我认为inject(:+)可以替换为join
— Wayne Conrad
@WayneConrad感谢您的帮助！不确定我如何忘记这些
— Cyoce '16
很高兴我能帮上忙！感谢您教给我我不知道的#bit_length方法。
— 韦恩·康拉德
1
切换到unpack后跟[0]而不是混乱gsub将节省11个字节。切换为$*[0]而不是gets.chop（使用命令行参数代替控制台输入）将保存另外9，第一行变为p n=$*[0].unpack('B*')[0].to_i(2)。
— philomory '16
3

迷宫，104个 103字节

'  )25 }_';:_';_2/;{
''', 6 2 1   1   { (
 ' | / _ _   _}*2_ $
 * _ :!\ }2_\     !:
 652       @'''''''

在线尝试！

说明：

颜色编码的源代码图像

指令指针从最左上角的非墙字符开始（墙包含空格和除之外的任何字母v）。

橙子：

此循环一次将输入的一个字符作为ASCII码获取，将其添加到当前值并将当前值乘以256。

  • ' 无操作
  • ,将下一个输入字符的ascii代码推入堆栈的顶部，如果EOF，则将-1推入。此时，如果接收到输入，则代码将向右转（向下移动），因为堆栈的顶部是有效的。否则它将因为堆栈顶部为负数而向左转。
  • | 从堆栈中弹出顶部的两个项目，然后按位或的结果。
  • _ 推零
  • 256看到的每个数字都会弹出x并推动x*10+digit。因此，这与将零前一次推送256推送到堆栈顶部相结合。
  • *弹出y，弹出x，推送x*y。此时，由于栈顶为正，因此代码将向右转以继续循环。

蓝色：

  • )递增堆栈的顶部。当到达输入末尾时，代码将在堆栈上以-1的形式向左转，并递增为零。
  • 256 栈顶为0可使我们压入256。
  • /Pop y，pop xpush x/y（整数除法）。由于我们将每个循环的输入乘以256，因此我们需要还原最后的乘法。
  • : 复制堆栈的顶部，因此我们有当前值的副本供以后使用。
  • ! 弹出堆栈的顶部，然后将整数值打印到STDOUT。
  • \ 打印新行。
  • _2 将两个推入堆栈的顶部。
  • } 将堆栈顶部移至辅助堆栈顶部。

红色：

该循环将当前值的位与内部（绿色）循环中计算出的特定值进行异或运算。然后，它输出当前值，如果当前值为零，则退出程序。

  • _ 推零（控制流）。
  • ; 丢弃堆栈顶部（控制流）。
  • :复制当前值。该副本将用于计算XOR。
  • _ 推零（控制流）。
  • （绿色循环）
  • $弹出y，弹出x，推送x XOR y。
  • :! 复制当前值并打印整数表示。
  • 如果当前值为0，我们直接进入@并终止。
  • \ 打印新行。
  • _2} 按2并移至辅助堆栈。
  • _1 按1（控制流）。

绿色：

该循环计算需要对当前值进行XOR的值。这是通过将辅助堆栈的顶部重复加倍，同时在主堆栈的停止位置将当前值的副本减半直至达到0来完成的。

  • _ 推零（控制流）。
  • ; 丢弃仅用于执行控制流的当前值。
  • _2 按2以将当前值减半。
  • / 划分
  • { 将辅助堆栈的顶部移到主堆栈的顶部。
  • _2* 将堆栈顶部加倍
  • } 将主堆栈的顶部移回辅助堆栈。
  • _1 推动一个以控制流量。
  • 退出循环后：
  • ; 丢弃剩余的零来计算XOR。
  • { 将计算出的XOR移至主堆栈。
  • ( 从XOR值中减去1。
— 罗伯特·希克曼
source
2

PowerShell v2 +，158个字节

for($a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)});$a){[convert]::ToInt64($a,2);$a=$a.TrimStart('0')-split0-replace1,0-join1}

是的，因此，在PowerShell中转换基数真的很麻烦。我们在这里要做两次。

好，所以这只是一个for循环$a-即，只要$a存在就循环。我们最终将到达一个空字符串（这是错误的），所以这就是我们终止的方式。

循环的设置$a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})接受输入$args[0]，将其强制转换为char-array，并循环遍历每个字符。我们使用.NET [convert]::ToString(int,base)将每个转换为二进制字符串。但是，这不包括前导零，因此我们需要将该字符串重新转换为an [int]并以零作为掩码调用其 .ToString()方法8。然后将这些字符串封装在paren中并-join一起编辑，然后保存到中$a。

在循环内部，我们[convert]::ToInt64(string,base)将二进制数转换为十进制数。那留在管道上，随后在循环重置时被冲​​刷（因此隐式打印）。下一节将进行计算-我们.TrimStart()删除所有前导零，-split0以零分割为零，得到- string的1s 数组，-replace那些为零-join的数组，最后与1s 一起返回数组。然后，循环再次开始。

PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0
— AdmBorkBork
source
2

CJam，17 16 18字节

q256b0{_p2b:!2bj}j

在线尝试！

q256b   e# read printable ascii to integer
0       e# value for terminal case
{       e# recursive function
  _p    e#   print current number
  2b    e#   create binary representation with no leading zeros
  :!    e#   flip bits
  2b    e#   convert binary back to integer
  j     e#   recursive call
}j      e# end

注意：旧的16字节版本在使用空字符串时无法正确运行：

q256b{_p2b:!2b}h

另外，还要感谢Dennis的建议p，这比N\将换行符放入堆栈可以节省1个字节。

— 莱纳斯
source
_p2b:!2b保存一个字节。另外，您应该使用l; r如果输入包含空格，将失败。
— 丹尼斯
@Dennis谢谢，尽管这现在使我担心是否出现空字符串。
— 莱纳斯（Linus）
对。q将正确使用空字符串。
— 丹尼斯
1

视网膜，116字节

字节数假定为ISO 8859-1编码。第5行包含不可打印的字节。是T`\x00-\xFF。

-2`
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+
$*
+`(1+)\1
${1}0
01
1


{*(`1
01
+`10
011
^0+

)M`1
^0+

T`01`10

在线尝试

输入的字符不要超过两个字符。（使用在线解释器超时。）我们必须将二进制转换为十进制之前的一元。：D

不幸的是，有一个尾随零和换行符，但是我决定假定这没问题，因为输出仍然正确。

说明

-2`         # Convert ASCII to decimal (ord)
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+         # Decimal to binary
$*
+`(1+)\1
${1}0
01
1


{*(`1       # Loop; Loop print and undo; Convert binary to unary
01
+`10
011
^0+

)M`1        # Unary to decimal; End print and undo
^0+         # Remove leading zeros

T`01`10     # Flip bits; (implicit loop end)
— mbomb007
source
1

Ruby-70个字节

λ cat inf.rb
n,=$*[0].unpack 'B*';loop{p n.to_i(2);n.tr!('10','01').sub!(/^0*/,'')}
λ ruby inf.rb Hello
310939249775
788572378000
310939249775
238816564112
36061342831
32658133904
1701604463
445879184
90991727
43226000
23882863
9671568
7105647
1282960
814191
234384
27759
5008
3183
912
111
16
15
0
inf.rb:1:in `block in <main>': undefined method `sub!' for nil:NilClass (NoMethodError)
        from inf.rb:1:in `loop'
        from inf.rb:1:in `<main>'

该程序在完成后会异常退出，但是我的理解是，只要错误输出转到STDERR而不是STDOUT（就可以了）就可以了。

— 邮编
source
1

C，147 135 133 125 122 121 117 115 103字节

感谢@Cyoce，节省了5个字节！

感谢@Cyoce和@cleblanc，节省了2个字节！

@ceilingcat节省了12个字节

i,n;main(p,v)char**v;{while(*v[1])i=i*256+*v[1]++;for(;printf("%d\n",n=i),i;i^=p-1)for(p=2;n/=2;)p*=2;}

取消高尔夫：

int i;
int main (c,v) {
    char**v;
    while (*v[1]) /* put first command line argument into i as binary */
        i = i*256 + *v[1]++;
    while (i != 0) { 
        printf("%d\n",i);
        int p = 2,n = i;
        while (n /= 2) /* calculate smallest power of 2 > i */
            p *= 2;
        i ^= p - 1; /* flip bits */
    }
}
— 面9
source
我想你可以离开了int声明
— Cyoce
您还可以通过将最后一个while循环转换为for循环来节省一个字节
— Cyoce '16
您可以更改while(1)为for(;;)
— Cyoce '16
@Cyoce我尝试int到处删除声明并出现gcc -std=89错误。但是，谢谢你的for(;;)提示。我将继续尝试删除int声明:)））
— Noodle9 '16
抱歉，我没有测试。我认为，如果将它们移到顶部（i;main(c,v)char**v;{...}），它将起作用。现在在移动设备上，所以我不能确定
— Cyoce '16
0

C，129 120 117 110 107 105个字节

long long i,m,n;f(char*v){for(;*v;i<<=8,i+=*v++);for(;printf("%llu,",i),n=i;i^=m-1)for(m=2;n>>=1;m<<=1);}

经过测试

main (int c, char**v) {
    f(v[1]);
}

输出

5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,
— 克莱布朗
source
我认为您可以移至i=0的声明i并将for循环的初始化部分保留为空白
— Cyoce '16
@Cyoce该函数每次调用都需要工作，并且由于它i是隐式的全局int，因此每次调用f（...）时都需要对其进行初始化。
— cleblanc
@Cyoce你毕竟是对的。该函数直到i再次为零时才退出，因此仍可重复使用。
— cleblanc
— 最高限额
0

C＃，360个 359字节

using w=System.Console;using q=System.Convert;s={System.Func<int,int,string>S=q.ToString;string t="",f="";for(int i=0;i<s.Length;i++)t+=i>0?S(s[i],2).PadLeft(8,'0'):S(s[i],2);w.WriteLine(q.ToInt64(t,2).ToString());while(t!="0"){f="";foreach(var n in t)f+=n=='0'?'1':'0';t=f.TrimStart(new char[]{'0'});t+=t==""?"0":"";w.WriteLine(q.ToInt64(t,2).ToString());}};

完整程序：

using w = System.Console;
using q = System.Convert;

class a
{
    static void Main()
    {
        System.Action<string> b = s =>
        {
            System.Func<int,int,string> S = q.ToString;
            string t = "", f = ""; // Var does not work here
            for(int i = 0; i < s.Length; i++)
                t += i > 0 ? S(s[i], 2).PadLeft(8, '0') : S(s[i], 2);
            w.WriteLine(q.ToInt64(t, 2).ToString());
            while(t != "0")
            {
                f = "";
                foreach (var n in t) f += n== '0' ? '1' : '0';
                t = f.TrimStart(new char[] { '0' });
                t += t == "" ? "0" : "";
                w.WriteLine(q.ToInt64(t, 2).ToString());
            }
        };

        b("Inf");
        b("Infinity");
        w.Read(); // prevent close in VS
    }
}
— 约德尔
source
我不这样做C＃，但可以var t="";var f="";是var t="",f=""代替？节省5个字节。
— corsiKa
@corsiKa是的，我尝试过，但是它给了我一个错误，我想是因为它是var而不是字符串。
— Yodle
实际上，字符串确实节省了一个字节，所以我想我会那样做。
— Yodle
还可以将z变量设置为零以保存这些讨厌的引号吗？
— corsiKa 2016年
刚刚尝试过，它实际上提高了字节数，因为我不能同时替换字符串“ 0”和
— char'0
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.