Cela semble être une tâche impossible, non? En fait, ce n'est pas si difficile. Si nous écrivons le mot Infinitysous forme de code ASCII binaire 8 bits, nous aurons:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

Cela peut être concaténé et converti en valeur décimale 5291279215216915577. Voilà un nombre avec lequel nous pouvons travailler ...

Le compte à rebours est:

1. Afficher la chaîne d'origine sous forme de nombre décimal (comme indiqué ci-dessus)
2. Supprimer les 0 premiers dans sa représentation binaire (le cas échéant)
3. Basculer les bits dans la représentation binaire (1-> 0, 0-> 1)
4. Affiche le nombre en décimal
5. Répétez les étapes 2 à 4 jusqu'à ce que vous atteigniez 0.

Défi:

Créez un programme ou une fonction qui prend une chaîne en tant qu'entrée et génère (sous n'importe quel format approprié) les nombres que vous obtiendrez en effectuant la procédure ci-dessus.

Cas de test:

Je pense que le défi sera assez facile à comprendre, même s'il ne s'agit que d'un cas test. Je vais utiliser Infau lieu de Infinitygarder cela assez court.

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

Votre code doit prendre en charge des chaînes pouvant être représentées sous la forme d'un nombre binaire dans la limite de votre langue. Toutes les chaînes ne contiendront que des caractères ASCII imprimables compris entre 32 et 126 (espace au tilde).

Classement

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ée , 15 à 10 octets

-5 octets grâce à @Dennis (converti directement à partir de la base 256 après la conversion ordinale)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

Comment?

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 octets

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

Testez-le sur Ideone .

Comment ça fonctionne

Après l’initialisation de n à 0 , la deuxième ligne effectue la conversion de chaîne en entier spécifiée dans les défis comme suit.

À chaque étape, n est décalé de 8 unités vers la gauche, puis OR au bit près avec le point de code du caractère suivant c . Pour l'entrée Inf , ceci va comme suit.

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

Nous sommes maintenant prêts à générer la sortie. Pour inverser les bits de n , on procède comme suit.

Premièrement, nous calculons les bits dans la représentation binaire de n sans les zéros au début. Appelons le résultat k . Ensuite, nous calculons la k ^k puissance de 2 , qui a k + 1 chiffres binaires: un seul 1 , suivi de k 0 . Nous soustrayons 1 du résultat, ce qui donne un nombre composé de k unités, que nous avons ensuite XOR avec n pour inverser ses bits. Pour l'entrée inf, cela va comme suit.

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 obstacle supplémentaire à la mise en œuvre est que nous devons imprimer n avant la première étape, après la dernière étape et dans toutes les étapes intermédiaires. Python n'a pas de boucle do-while et une seule déclaration d' impression coûte 8 octets. Nous procédons donc comme suit.

Dans la simple mise en œuvre de l'étape de mise à jour, c'est-à-dire

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

nous remplaçons la boucle par un infini ( while 1) et calculons la 1dans la boucle comme n/n. Ceci est équivalent lorsque n> 0 .

Une fois que n = 0 , nous restons dans la boucle, imprimons l'état une fois de plus, puis essayons de le mettre à jour. Cependant, 0/0déclenche une erreur ZeroDivisionError , qui se détache de la boucle et se termine avec une erreur. Notez que cela entraîne une sortie parasite vers STDERR, autorisée par défaut .

JavaScript, 82 octets

Enregistré un octet grâce à @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

Une des rares fois où un programme complet surpasse une fonction (et ES6 ne surpasse pas ES5) ...

Ce qui précède prend en charge les mots de 4 lettres maximum. Ajoutez 4 octets pour prendre en charge les mots de 6 lettres maximum:

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

En fait , 14 octets

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

Essayez-le en ligne!

Explication:

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 octets

Utilise le codage CP-1252 .

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

Essayez-le en ligne!

Explication

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

8W:qZA`tB~XBt

Essayez-le en ligne!

Explication

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 octets

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

Fonction anonyme. Prend une chaîne en entrée et renvoie une liste de nombres en sortie.

Haskell, 109 123 118 102 97 octets

Merci à @nimi pour avoir économisé 5 octets!

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

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

Garanti de travailler sur des nombres allant jusqu'à 29 bits en fonction de la langue, fonctionne généralement jusqu'à des nombres de 63 bits sur des systèmes 64 bits. Utilisationmap(fromIntegral.fromEnum) plutôt (+14 octets) pour prendre en charge des nombres arbitrairement grands.

Fonctionne pour la plage unicode [0..255]. Retourne les bits récursivement.

PHP, 132 126 123 120 108 107 octets

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

• l'impression 0 après boucle au lieu de la valeur initiale avant boucle enregistre 6 octets.
• unpackau lieu de str_splitrend ord()obsolète -> -3 octets
• souligner _comme séparateur enregistre 3.
• bindecau lieu de ltrimsupprimer les zéros de gauche: -12
• echoin Loop corps économise 1 octet printdans la tête de boucle.

Perl, 65 octets

Code 53 octets + 12 pour -Mbigint -p.

Merci à @ Dada de m'avoir sauvé 13 octets!

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

Une approche assez simple, mais différente de la plupart d'entre eux, est que le nombre est stocké sous forme binaire et imprimé en décimal. Je suis sûr que cela peut être amélioré, peut-être en stockant les détails dans un tableau. -Mbigintest un peu gênant mais nécessaire.

Usage

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 octets

.usi!MjN2 2C

Un programme qui prend en entrée une chaîne entre guillemets et affiche le résultat sous forme de liste d'entiers.

Vérifier tous les cas de test

Comment ça fonctionne

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

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

L'idée principale est de convertir une chaîne d'octets en nombre. Chaque itération imprime la sortie et XOR avec tous les 1 pour progresser vers zéro.

Python 2, 117 115 octets

Enregistrement de 2 octets grâce à Cyoce.

Suppose que les entrées sont entre guillemets, par exemple "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 compte jusqu'au chiffre le plus élevé, donc m-1 qu'un masque XOR pour effectuer l'opération souhaitée. La partie la plus longue convertit l’entrée en séquence de bits initiale.

Exemple:

"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 octets

19 octets sauvés grâce à @WayneConrad!
15 octets sauvés grâce à @philomory!
1 octet enregistré grâce à @LeeW!

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

Prend la saisie via des arguments en ligne de commande.

Inspiré par la réponse de JimmyJohnson en Python

Labyrinth , 104 à 103 octets

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

Essayez-le en ligne!

Explication:

Le pointeur d'instruction commence au caractère non mur le plus en haut à gauche (les murs incluent des espaces et toute lettre sauf v).

Orange:

Cette boucle récupère l’entrée caractère par caractère sous forme de code ASCII, en l’ajoutant à la valeur actuelle et en la multipliant par 256.

• ' No-op
• ,Poussez le code ASCII du prochain caractère en entrée en haut de la pile ou -1 si EOF. À ce stade, si une entrée a été reçue, le code tournera à droite (en descendant) car le haut de la pile est actif. Sinon, il tournera à gauche car le sommet de la pile est négatif.
• | Pop les deux premiers éléments de la pile et pousse le résultat d'un OU au niveau des bits.
• _ Poussez zéro
• 256Chaque chiffre vu apparaît xet pousse x*10+digit. Donc, ceci combiné avec la poussée zéro précédente pousse 256 au sommet de la pile.
• *Pop y, pop x, pousse x*y. À ce stade, puisque le haut de la pile est positif, le code tourne à droite pour continuer le tour de la boucle.

Bleu:

• )Incrémenter le haut de la pile. Lorsque la fin de la saisie est atteinte, le code tourne à gauche pour atteindre ce point avec un -1 sur la pile qui sera incrémenté à zéro.
• 256 Avoir le haut de la pile 0 nous permet de pousser ce 256.
• /Pop y, pop xpush x/y(division entière). Puisque nous multiplions l'entrée 256 par chaque boucle, nous devons inverser la dernière multiplication.
• : Dupliquez le haut de la pile afin d'avoir une copie de la valeur actuelle pour plus tard.
• ! Déposez le haut de la pile et imprimez la valeur entière sur STDOUT.
• \ Imprimer une nouvelle ligne.
• _2 Poussez un deux en haut de la pile.
• } Déplacez le haut de la pile vers le haut de la pile auxiliaire.

Rouge:

Cette boucle retourne les bits de la valeur actuelle de XOR avec une valeur particulière calculée dans la boucle intérieure (verte). Il émet ensuite la valeur actuelle et quitte le programme si la valeur actuelle est zéro.

• _ Appuyez sur zéro (flux de contrôle).
• ; Jeter le haut de la pile (flux de contrôle).
• :Dupliquez la valeur actuelle. La copie sera utilisée pour calculer le XOR.
• _ Appuyez sur zéro (flux de contrôle).
• (Boucle verte)
• $Pop y, pop x, push x XOR y.
• :! Dupliquez la valeur actuelle et imprimez la représentation entière.
• Si la valeur actuelle est 0, nous continuons directement dans le @fichier et nous terminons.
• \ Imprimer une nouvelle ligne.
• _2} Appuyez sur 2 et passez à la pile auxiliaire.
• _1 Appuyez sur 1 (flux de contrôle).

Vert:

Cette boucle calcule la valeur par laquelle nous devons XOR la ​​valeur actuelle. Pour ce faire, vous devez doubler de façon répétée le sommet de la pile auxiliaire tout en divisant par deux le nombre de copies de la valeur actuelle à l'arrêt de la pile principale jusqu'à atteindre 0.

• _ Appuyez sur zéro (flux de contrôle).
• ; Ignore la valeur actuelle utilisée uniquement pour appliquer le flux de contrôle.
• _2 Appuyez sur 2 pour réduire de moitié la valeur actuelle.
• / Diviser
• { Déplacez le haut de la pile Aux vers le haut de la pile principale.
• _2* Double le sommet de la pile
• } Déplacez le haut de la pile principale vers la pile Aux.
• _1 Appuyez sur l'un pour contrôler le flux.
• Après avoir quitté la boucle:
• ; Jeter la gauche au-dessus de zéro de calculer le XOR.
• { Déplacez le XOR calculé vers la pile principale.
• ( Soustrayez un de la valeur XOR.

PowerShell v2 +, 158 octets

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}

Ouais, donc, convertir des bases dans PowerShell est vraiment nul . Et nous avons le faire deux fois ici.

OK, il ne s’agit que d’une forboucle $a- c’est-à-dire que nous bouclons tant qu’il $aexiste. Nous finirons par atteindre une chaîne vide (qui est falsey), c'est ainsi que nous terminerons.

La configuration de la boucle, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})prend l’entrée $args[0], la charconvertit en une matrice et parcourt chaque caractère. Nous utilisons le .NET [convert]::ToString(int,base)pour convertir chacun en chaîne binaire. Cependant, cela n'inclut pas les zéros au début, nous devons donc la reformuler en tant que [int]et appeler sa .ToString() méthode avec les 8zéros comme masque. Ensuite, ces chaînes sont encapsulées dans des parens et éditées -joinensemble, puis sauvegardées dans $a.

Dans la boucle, nous [convert]::ToInt64(string,base)convertissons le nombre binaire en nombre décimal. Cela reste sur le pipeline et est ensuite vidé lorsque la boucle est réinitialisée (et donc implicitement imprimée). La section suivante effectue les calculs - nous devons .TrimStart()supprimer tous les zéros non significatifs , -split0les scinder en zéros et obtenir un stringtableau de 1s, -replaceceux contenant des zéros, et enfin -joinle tableau revenant avec 1s. Ensuite, la boucle recommence.

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 octets

q256b0{_p2b:!2bj}j

Essayez-le en ligne!

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

REMARQUE: l'ancienne version de 16 octets ne se comportait pas correctement avec des chaînes vides:

q256b{_p2b:!2b}h

Merci également à Dennis d’ avoir suggéré ce pqui économise 1 octet par rapport à l’ N\ajout de nouvelles lignes à la pile.

J, 24 octets

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

L'explication viendra plus tard!

Retina, 116 octets

Le nombre d'octets suppose un codage ISO 8859-1. La ligne 5 contient des octets non imprimables. C'est 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

Essayez-le en ligne

N'essayez pas cela avec une saisie de plus de deux caractères. (Il utilise plus tard l'interprète en ligne.) Il faut convertir le binaire en unaire avant la décimale. :RÉ

Malheureusement, il y a un zéro final et un saut de ligne, mais j'ai décidé de supposer que c'était correct parce que la sortie est toujours correcte.

Explication

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

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

Le programme se ferme avec une exception après avoir terminé, mais je crois comprendre que c'est correct tant que la sortie d'erreur est renvoyée à STDERR plutôt qu'à STDOUT (ce qui est le cas).

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

5 octets sauvés grâce à @Cyoce!

2 octets sauvés grâce à @Cyoce et @cleblanc!

Sauvegardé 12 octets grâce à @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 octets

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

Testé avec

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

sortie

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 octets

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

Programme complet:

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