Parece uma tarefa impossível, certo? Bem, na verdade não é tão difícil. Se escrevermos a palavra Infinitycomo código ASCII binário de 8 bits, obteremos:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

Isso pode ser concatenado e convertido no valor decimal 5291279215216915577. Agora é com esse número que podemos trabalhar ...

A maneira como você fará a contagem regressiva é:

1. Saída da string original como um número decimal (como mostrado acima)
2. Remova os 0s iniciais em sua representação binária (se houver)
3. Alterne os bits na representação binária (1-> 0, 0-> 1)
4. Emita o número em decimal
5. Repita as etapas 2 a 4 como até atingir 0.

Desafio:

Crie um programa ou função que use uma string como entrada e produza (em qualquer formato adequado) os números que você obterá ao executar o procedimento acima.

Caso de teste:

Acho que o desafio será fácil de entender, mesmo que seja apenas um caso de teste. Vou usar em Infvez de Infinitymanter isso bastante curto.

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

Seu código deve suportar seqüências de caracteres que podem ser representadas como um número binário até o limite do seu idioma. Todas as seqüências conterão apenas caracteres ASCII imprimíveis de 32 a 126 (espaço para til).

Entre os melhores

var QUESTION_ID=98274,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Geléia , 15 10 bytes

-5 bytes graças a @Dennis (converta diretamente da base 256 após o lançamento ordinal)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

Quão?

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 

Python 2, 89 82 77 76 75 bytes

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

Teste em Ideone .

Como funciona

Depois de inicializar n para 0 , a segunda linha executa a conversão de seqüência de caracteres em número inteiro especificada nos desafios da seguinte maneira.

Em cada etapa, n é deslocado 8 unidades para a esquerda e, em seguida, OR- bit bit com o ponto de código do próximo caractere c . Para entrada Inf , é o seguinte.

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

Agora estamos prontos para gerar a saída. Para inverter os bits de n , procedemos da seguinte maneira.

Primeiro, calculamos os bits na representação binária de n sem zeros à esquerda. Vamos chamar o resultado k . Em seguida, calculamos a potência k ^k de 2 , que possui k + 1 dígito binário: um único 1 , seguido por k 0 's. Subtraímos 1 do resultado, produzindo um número composto por k ones, que depois XOR com n para inverter seus bits. Para entrada inf, é o seguinte.

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

Um obstáculo adicional na implementação é que precisamos imprimir n antes da primeira etapa, após a última etapa e em todas as etapas intermediárias. O Python não possui loops do-while e uma única instrução de impressão custa 8 bytes, portanto, fazemos o seguinte.

Na implementação direta da etapa de atualização, ou seja,

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

substituímos o loop por um infinito ( while 1) e calculamos 1o loop como n/n. Isso é equivalente a n> 0 .

Uma vez que n = 0 , nós ficar no loop, imprimir o estado mais uma vez, em seguida, tentar atualizá-lo. No entanto, 0/0dispara um ZeroDivisionError , interrompendo o loop e saindo com um erro. Observe que isso causa saída dispersa para STDERR, que é permitido por padrão .

JavaScript, 82 bytes

Guardou um byte graças a @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

Uma das poucas vezes em que um programa completo supera uma função (e o ES6 não supera o ES5) ...

O texto acima suporta palavras de até 4 letras. Adicione 4 bytes para suportar palavras de até 6 letras:

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

Na verdade , 14 bytes

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

Experimente online!

Explicação:

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

05AB1E , 18 bytes

Usa a codificação CP-1252 .

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

Experimente online!

Explicação

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

MATL , 13 bytes

8W:qZA`tB~XBt

Experimente online!

Explicação

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

Mathematica, 99 bytes

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

Função anônima. Pega uma string como entrada e retorna uma lista de números como saída.

Haskell, 109 123 118 102 97 bytes

Obrigado a @nimi por salvar 5 bytes!

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

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

Garantido para trabalhar com números de até 29 bits pelo idioma, geralmente trabalha com números de até 63 bits em sistemas de 64 bits. Use map(fromIntegral.fromEnum)(+14 bytes) para suportar números arbitrariamente grandes.

Funciona para o intervalo unicode [0..255]. Vira recursivamente os bits.

PHP, 132 126 123 120 108 107 bytes

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));

• imprimir 0 após o loop em vez do valor inicial antes do loop salva 6 bytes.
• unpackem vez de str_splittornar ord()obsoleto -> -3 bytes
• sublinhado _como o separador salva 3.
• bindecem vez de ltrimremover os zeros à esquerda: -12
• echono corpo do loop economiza 1 byte printna cabeça do loop.

Perl, 65 bytes

Código de 53 bytes + 12 para -Mbigint -p.

Obrigado a @ Dada por me salvar 13 bytes!

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

Uma abordagem bastante direta, apenas diferente da maioria deles, é que o número é armazenado como binário e impresso em decimal. Tenho certeza de que pode ser aprimorado, talvez com o armazenamento de detalhes em uma matriz. -Mbiginté um pouco inconveniente, mas necessário.

Uso

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

Pitão, 12 bytes

.usi!MjN2 2C

Um programa que recebe a entrada de uma string entre aspas e imprime o resultado como uma lista de números inteiros.

Verifique todos os casos de teste

Como funciona

.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

Python 3, 99 95 bytes

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

A idéia principal é converter a string em bytes em número. Cada iteração imprime a saída e o XOR com todos os 1s para avançar para zero.

Python 2, 117 115 bytes

Economizando 2 bytes graças ao Cyoce.

Assume a entrada entre aspas, por exemplo "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

mconta até o dígito mais alto, assim m-1como uma máscara XOR para executar a operação desejada. A parte mais longa é converter a entrada na sequência de bits inicial.

Exemplo:

"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

Ruby, 104 101 100 81 80 65 bytes

19 bytes salvos graças a @WayneConrad!
15 bytes salvos graças ao @philomory!
1 byte salvo graças a @LeeW!

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

Recebe entrada por meio de argumentos de linha de comando.

Inspirado na resposta Python de @ JimmyJohnson

Labirinto , 104 103 bytes

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

Experimente Online!

Explicação:

O ponteiro de instruções começa com o caractere que não é de parede, no canto superior esquerdo (as paredes incluem espaços e qualquer letra, exceto v).

Laranja:

Esse loop obtém a entrada um caractere de cada vez como um código ASCII, adicionando-o ao valor atual e multiplicando o valor atual por 256.

• ' No-op
• ,Empurre o código ascii do próximo caractere de entrada para o topo da pilha ou -1 se EOF. Nesse ponto, se a entrada foi recebida, o código vira à direita (movendo-se para baixo) porque a parte superior da pilha é potente. Caso contrário, ele ficará à esquerda, porque a parte superior da pilha é negativa.
• | Retire os dois itens principais da pilha e empurre o resultado de um OR bit a bit.
• _ Empurre zero
• 256Cada dígito visto aparece xe pressiona x*10+digit. Portanto, isso combinado com o push zero do push anterior 256 para o topo da pilha.
• *Pop y, pop x, empurre x*y. Nesse ponto, como a parte superior da pilha é positiva, o código vira à direita para continuar no loop.

Azul:

• )Incremente o topo da pilha. Quando o final da entrada é alcançado, o código vira à esquerda para chegar a esse ponto com um -1 na pilha, que será incrementado para zero.
• 256 Ter o topo da pilha 0 nos permite empurrar esse 256.
• /Pop y, pop xpush x/y(divisão inteira). Como multiplicamos a entrada por 256 em cada loop, precisamos reverter a última multiplicação.
• : Duplique a parte superior da pilha para ter uma cópia do valor atual para mais tarde.
• ! Coloque a parte superior da pilha e imprima o valor inteiro em STDOUT.
• \ Imprima uma nova linha.
• _2 Empurre dois para o topo da pilha.
• } Mova a parte superior da pilha para a parte superior da pilha auxiliar.

Vermelho:

Esse loop inverte os bits do valor atual por XOR com um valor específico calculado no loop interno (verde). Em seguida, gera o valor atual e sai do programa se o valor atual for zero.

• _ Pressione zero (fluxo de controle).
• ; Descarte a parte superior da pilha (fluxo de controle).
• :Duplique o valor atual. A cópia será usada para calcular o XOR.
• _ Pressione zero (fluxo de controle).
• (Laço verde)
• $Pop y, pop x, Push x XOR y.
• :! Duplique o valor atual e imprima a representação inteira.
• Se o valor atual for 0, continuamos direto para @e terminamos.
• \ Imprima uma nova linha.
• _2} Pressione 2 e vá para a pilha auxiliar.
• _1 Pressione 1 (fluxo de controle).

Verde:

Este loop calcula o valor pelo qual precisamos XOR o valor atual. Isso é feito duplicando repetidamente a parte superior da pilha auxiliar enquanto reduz pela metade uma cópia do valor atual na parada da pilha principal até atingir 0.

• _ Pressione zero (fluxo de controle).
• ; Descarte o valor atual que é usado apenas para impor o fluxo de controle.
• _2 Pressione 2 para reduzir pela metade o valor atual.
• / Dividir
• { Mova a parte superior da pilha auxiliar para a parte superior da pilha principal.
• _2* Dobrar o topo da pilha
• } Mova a parte superior da pilha principal de volta para a pilha auxiliar.
• _1 Pressione um para o fluxo de controle.
• Depois de sair do loop:
• ; Descarte a esquerda acima de zero do cálculo do XOR.
• { Mova o XOR calculado para a pilha principal.
• ( Subtrair um do valor XOR.

PowerShell v2 +, 158 bytes

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}

Sim, portanto, converter bases no PowerShell é realmente péssimo . E conseguimos fazer isso duas vezes aqui.

OK, então isso é apenas um forloop ativado $a- ou seja, rodamos enquanto $aexistir. Eventualmente, alcançaremos uma string vazia (que é falsey), e é assim que terminaremos.

A configuração do loop, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})pega a entrada $args[0], lança como um chararray e percorre cada caractere. Usamos o .NET [convert]::ToString(int,base)para converter cada um em uma string binária. No entanto, isso não inclui zeros à esquerda, portanto, precisamos relançar essa sequência como [int]e chamar seu .ToString() método com 8zeros como máscara. Em seguida, essas seqüências são encapsuladas em parênteses e edificadas -joinjuntas, e então salvas em $a.

Dentro do loop, [convert]::ToInt64(string,base)convertemos o número binário em um número decimal. Isso fica no pipeline e é liberado posteriormente quando o loop é redefinido (e, portanto, implicitamente impresso). A próxima seção executa os cálculos - .TrimStart()removeremos quaisquer zeros -split0à esquerda, dividir em zeros e obter uma stringmatriz de 1s, -replaceaqueles com zeros, e finalmente -joina matriz de volta com 1s. Então, o loop começa novamente.

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

CJam , 17 16 18 bytes

q256b0{_p2b:!2bj}j

Experimente online!

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

NOTA: A versão antiga de 16 bytes não se comportava corretamente com cadeias de caracteres vazias:

q256b{_p2b:!2b}h

Além disso, obrigado a Dennis por sugerir pque economiza 1 byte ao N\colocar novas linhas na pilha.

J, 24 bytes

256-.&.#:^:*^:a:@#.a.&i.

A explicação virá mais tarde!

Retina, 116 bytes

A contagem de bytes assume a codificação ISO 8859-1. A linha 5 contém bytes não imprimíveis. É 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

Experimente online

Não tente fazer isso com entrada com mais de dois caracteres. (É atingido o tempo limite usando o intérprete on-line.) Temos que converter o binário em unário antes do decimal. : D

Infelizmente, há um zero e avanço de linha, mas decidi assumir que estava tudo bem, porque a saída ainda está correta.

Explicação

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

Ruby - 70 bytes

λ 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>'

O programa é encerrado com uma exceção após a conclusão, mas meu entendimento é que isso é bom, desde que a saída de erro vá para STDERR em vez de STDOUT (o que ocorre).

C, 147 135 133 125 122 121 117 115 103 bytes

Guardado 5 bytes graças a @Cyoce!

Economizou 2 bytes graças a @Cyoce e @cleblanc!

Guardado 12 bytes graças a @ceilingcat

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

Ungolfed:

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

C, 129 120 117 110 107 105 Bytes

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

Testado com

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

resultado

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,

C #, 360 359 bytes

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

Programa completo:

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