Sembra un compito impossibile vero? Beh, in realtà non è così difficile. Se scriviamo la parola Infinitycome codice binario ASCII a 8 bit, otterremo:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

Questo può essere concatenato e convertito nel valore decimale 5291279215216915577. Questo è un numero con cui possiamo lavorare ...

Il modo in cui conto alla rovescia è:

1. Emette la stringa originale come un numero decimale (come mostrato sopra)
2. Rimuovi gli 0 iniziali nella sua rappresentazione binaria (se presente)
3. Attiva / disattiva i bit nella rappresentazione binaria (1-> 0, 0-> 1)
4. Emette il numero in decimale
5. Ripeti i passaggi da 2 a 4 fino a quando non raggiungi 0.

Sfida:

Crea un programma o una funzione che accetta una stringa come input e genera (in qualsiasi formato adatto) i numeri che otterrai quando esegui la procedura sopra.

Caso di prova:

Penso che la sfida sarà abbastanza facile da capire, anche se è solo un caso di prova. Userò Infinvece di Infinitymantenerlo abbastanza breve.

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

Il tuo codice deve supportare stringhe che possono essere rappresentate come un numero binario fino al limite della tua lingua. Tutte le stringhe conterranno solo caratteri ASCII stampabili da 32-126 (dallo spazio alla tilde).

Classifica

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>

Gelatina , 15 10 byte

-5 byte grazie a @Dennis (converti direttamente dalla base 256 dopo il cast ordinale)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

Come?

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 byte

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

Provalo su Ideone .

Come funziona

Dopo aver inizializzato n su 0 , la seconda riga esegue la conversione da stringa a intero specificata nelle sfide come segue.

In ogni passaggio, n viene spostato di 8 unità a sinistra, quindi bit- OR o -ed con il punto di codice del carattere successivo c . Per l'ingresso Inf , questo è il seguente.

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

Ora siamo pronti per generare l'output. Per invertire i bit di n , procediamo come segue.

Innanzitutto, calcoliamo i bit nella rappresentazione binaria di n senza zeri iniziali. Chiamiamo il risultato k . Quindi, calcoliamo la potenza k ^k di 2 , che ha k + 1 cifre binarie: un singolo 1 , seguito da k 0 's. Sottraiamo 1 dal risultato, producendo un numero composto da k , che poi XOR con n per invertire i suoi bit. Per l'input inf questo vale come segue.

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

Un ulteriore ostacolo nell'implementazione è che dobbiamo stampare n prima del primo passaggio, dopo l'ultimo passaggio e in tutti i passaggi intermedi. Python non ha loop do-while e una singola istruzione di stampa costa 8 byte, quindi facciamo invece quanto segue.

Nella semplice implementazione della fase di aggiornamento, ovvero

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

sostituiamo il ciclo con uno infinito ( while 1) e calcoliamo il 1nel ciclo come n/n. Questo è equivalente mentre n> 0 .

Una volta n = 0 , restiamo nel ciclo, stampiamo ancora lo stato, quindi proviamo ad aggiornarlo. Tuttavia, 0/0attiva ZeroDivisionError , interrompendo il ciclo e terminando con un errore. Si noti che ciò causa l'output errato su STDERR, che è consentito per impostazione predefinita .

JavaScript, 82 byte

Salvataggio di un byte grazie 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

Una delle pochissime volte in cui un programma completo supera una funzione (e ES6 non supera ES5) ...

Quanto sopra supporta fino a 4 lettere. Aggiungi 4 byte per supportare fino a parole di 6 lettere:

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

In realtà , 14 byte

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

Provalo online!

Spiegazione:

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 byte

Utilizza la codifica CP-1252 .

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

Provalo online!

Spiegazione

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

8W:qZA`tB~XBt

Provalo online!

Spiegazione

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 byte

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

Funzione anonima. Accetta una stringa come input e restituisce un elenco di numeri come output.

Haskell, 109 123 118 102 97 byte

Grazie a @nimi per aver salvato 5 byte!

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"

Garantito per lavorare su numeri fino a 29 bit in base alla lingua, in genere funziona fino a numeri a 63 bit su sistemi a 64 bit. Utilizzare map(fromIntegral.fromEnum)invece (+14 byte) per supportare numeri arbitrariamente grandi.

Funziona per l'intervallo unicode [0..255]. Capovolge ricorsivamente i bit.

PHP, 132 126 123 120 108 107 byte

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

• la stampa di 0 dopo il ciclo invece del valore iniziale prima che il ciclo salti 6 byte.
• unpackinvece di str_splitrendere ord()obsoleti -> -3 byte
• sottolinea _che il separatore salva 3.
• bindecinvece di ltrimrimuovere gli zeri iniziali: -12
• echoin loop body salva 1 byte sopra printin loop head.

Perl, 65 byte

53 byte codice + 12 per -Mbigint -p.

Grazie a @Dada per avermi salvato 13 byte!

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

Approccio abbastanza semplice, solo diverso dalla maggior parte di questi è che il numero è memorizzato come binario e stampato in decimale. Sono sicuro che può essere migliorato, forse con la memorizzazione dei dettagli in un array. -Mbigintè un po 'scomodo ma necessario.

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

Pyth, 12 byte

.usi!MjN2 2C

Un programma che accetta l'input di una stringa tra virgolette e stampa il risultato come un elenco di numeri interi.

Verifica tutti i casi di test

Come funziona

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

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

L'idea principale è di convertire la stringa in byte in numero. Ogni iterazione stampa l'output e XOR con tutti gli 1 per avanzare verso zero.

Python 2, 117 115 byte

Risparmio di 2 byte grazie a Cyoce.

Presuppone input racchiusi tra virgolette, ad es "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 fino alla cifra più alta, quindi m-1è una maschera XOR per eseguire l'operazione desiderata. La parte più lunga sta convertendo l'ingresso nella sequenza di bit iniziale.

Esempio:

"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

Rubino, 104 101 100 81 80 65 byte

19 byte salvati grazie a @WayneConrad!
15 byte salvati grazie a @philomory!
1 byte salvato grazie a @LeeW!

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

Accetta input tramite argomenti della riga di comando.

Ispirato dalla risposta Python di @JimmyJohnson

Labyrinth , 104 103 byte

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

Provalo online!

Spiegazione:

Il puntatore dell'istruzione inizia dal carattere più a sinistra in alto a sinistra (i muri includono spazi e qualsiasi lettera tranne v).

Arancia:

Questo loop ottiene l'input di un carattere alla volta come un codice ASCII, aggiungendolo al valore corrente e moltiplicando il valore corrente per 256.

• ' No-op
• ,Spingere il codice ascii del prossimo carattere di input in cima allo stack o -1 se EOF. A questo punto, se l'input è stato ricevuto, il codice girerà a destra (spostandosi verso il basso) perché la parte superiore dello stack è potente. Altrimenti girerà a sinistra perché la parte superiore della pila è negativa.
• | Apri i primi due oggetti dallo stack e invia il risultato di un OR bit a bit.
• _ Spingere zero
• 256Ogni cifra vista si apre xe spinge x*10+digit. Quindi questo combinato con il push zero push precedente 256 nella parte superiore dello stack.
• *Pop y, pop x, push x*y. A questo punto, poiché la parte superiore dello stack è positiva, il codice girerà a destra per continuare attorno al ciclo.

Blu:

• )Incrementa la parte superiore della pila. Quando viene raggiunta la fine dell'input, il codice girerà a sinistra per arrivare a questo punto con un -1 nello stack che verrà incrementato a zero.
• 256 Avere la cima dello stack 0 ci permette di spingere questo 256.
• /Pop y, pop xpush x/y(divisione intera). Poiché moltiplicavamo l'input per 256 per ogni loop, dobbiamo ripristinare l'ultima moltiplicazione.
• : Duplica la parte superiore dello stack in modo da avere una copia del valore corrente per dopo.
• ! Fai apparire la parte superiore dello stack e stampa il valore intero su STDOUT.
• \ Stampa una nuova riga.
• _2 Spingi due in cima alla pila.
• } Spostare la parte superiore della pila nella parte superiore della pila ausiliaria.

Rosso:

Questo loop inverte i bit del valore corrente di XOR con un valore particolare calcolato nel loop interno (verde). Emette quindi il valore corrente ed esce dal programma se il valore corrente è zero.

• _ Spingere zero (flusso di controllo).
• ; Scarta la parte superiore della pila (flusso di controllo).
• :Duplica il valore corrente. La copia verrà utilizzata per calcolare l'XOR.
• _ Spingere zero (flusso di controllo).
• (Anello verde)
• $Pop y, pop x, Push x XOR y.
• :! Duplica il valore corrente e stampa la rappresentazione intera.
• Se il valore corrente è 0, continuiamo direttamente nel @e terminiamo.
• \ Stampa una nuova riga.
• _2} Premere 2 e passare allo stack ausiliario.
• _1 Premere 1 (flusso di controllo).

Verde:

Questo ciclo calcola il valore con cui è necessario XOR il valore corrente. Questo viene fatto raddoppiando ripetutamente la parte superiore dello stack ausiliario mentre dimezzando una copia del valore corrente sull'arresto dello stack principale fino a raggiungere 0.

• _ Spingere zero (flusso di controllo).
• ; Elimina il valore corrente utilizzato solo per imporre il flusso di controllo.
• _2 Premere 2 per dimezzare il valore corrente.
• / Dividere
• { Spostare la parte superiore della pila ausiliaria nella parte superiore della pila principale.
• _2* Raddoppia la parte superiore della pila
• } Sposta la parte superiore dello stack principale nello stack aux.
• _1 Premere uno per il flusso di controllo.
• Dopo essere usciti dal loop:
• ; Scarta il rimanente su zero dal calcolo dell'XOR.
• { Sposta lo XOR calcolato nello stack principale.
• ( Sottrai uno dal valore XOR.

PowerShell v2 +, 158 byte

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}

Sì, quindi, convertire le basi in PowerShell è davvero schifoso . E lo facciamo due volte qui.

OK, quindi questo è solo un forloop $a- cioè, siamo in loop finché $aesiste. Alla fine raggiungeremo una stringa vuota (che è falso), quindi è così che termineremo.

La configurazione del loop, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})prende l'input $args[0], lo lancia come una charmatrice e scorre in sequenza ogni personaggio. Usiamo .NET [convert]::ToString(int,base)per convertire ciascuno in una stringa binaria. Tuttavia, ciò non include gli zeri iniziali, quindi è necessario ripetere il cast di quella stringa come an [int]e chiamarne il .ToString() metodo con 8zeri come maschera. Quindi quelle stringhe vengono incapsulate in parentesi ed edite -joininsieme, quindi salvate in $a.

All'interno del loop, [convert]::ToInt64(string,base)convertiamo il numero binario in un numero decimale. Questo viene lasciato sulla pipeline e viene successivamente svuotato quando il loop viene ripristinato (e quindi stampato implicitamente). La sezione successiva esegue i calcoli: .TrimStart()rimuoviamo eventuali zeri iniziali , -split0suddividiamo su zeri e otteniamo un stringarray di 1s, -replacequelli con zeri e infine -joinl'array di nuovo insieme a 1s. Quindi, il ciclo ricomincia.

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 byte

q256b0{_p2b:!2bj}j

Provalo 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: la vecchia versione a 16 byte non si comportava correttamente con stringhe vuote:

q256b{_p2b:!2b}h

Inoltre, grazie a Dennis per aver suggerito pche consente di risparmiare 1 byte rispetto N\all'inserimento di nuove righe nello stack.

J, 24 byte

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

La spiegazione arriverà più tardi!

Retina, 116 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1. La riga 5 contiene byte non stampabili. Lo è 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

Provalo online

Non provarlo con input più lunghi di due caratteri. (Scade usando l'interprete online.) Dobbiamo convertire il binario in unario prima del decimale. : D

Sfortunatamente, c'è uno zero finale e un avanzamento riga, ma ho deciso di presumere che andasse bene perché l'output è ancora corretto.

Spiegazione

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

Rubino - 70 byte

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

Il programma esce con un'eccezione dopo il completamento, ma la mia comprensione è che va bene fino a quando l'output dell'errore va a STDERR piuttosto che a STDOUT (cosa che fa).

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

5 byte salvati grazie a @Cyoce!

Salvato 2 byte grazie a @Cyoce e @cleblanc!

Salvato 12 byte grazie 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 byte

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

Testato con

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

produzione

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 byte

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

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