불가능한 일처럼 보입니까? 글쎄, 실제로 그렇게 어렵지는 않습니다. 단어 Infinity를 8 비트 이진 ASCII 코드로 작성하면 다음 과 같은 결과가 나타납니다.

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

이를 연결하여 10 진수 값으로 변환 할 수 있습니다 5291279215216915577. 이제 우리가 함께 할 수있는 숫자입니다 ...

카운트 다운하는 방법은 다음과 같습니다.

1. 원래 문자열을 10 진수로 출력합니다 (위 그림 참조).
2. 이진 표현에서 선행 0을 제거합니다 (있는 경우).
3. 이진 표현에서 비트를 토글합니다 (1-> 0, 0-> 1).
4. 숫자를 10 진수로 출력
5. 0에 도달 할 때까지 2-4 단계를 반복하십시오.

도전:

문자열을 입력으로 사용하고 위의 절차를 수행 할 때 얻을 수있는 숫자를 적절한 형식으로 출력하는 프로그램이나 함수를 만듭니다.

테스트 사례 :

하나의 테스트 사례이지만 도전 과제를 이해하기가 쉽다고 생각합니다. 나는 이것을 짧게 유지 하는 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 문자 만 포함됩니다.

리더 보드

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>

젤리 , 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 

파이썬 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 의 코드 포인트 로 비트 단위 OR 됩니다. 입력 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 비트를 반전시키기 위해 다음과 같이 진행합니다.

먼저, 선행 0없이 n 의 이진 표현으로 비트를 계산합니다 . 결과 k 라고합시다 . 그런 다음 k + 1 이진수 (단일 1 ,이어서 k 0) 를 갖는 k ^k 제곱 2를 계산합니다 . 결과에서 1 을 빼고 k 개의 1 로 구성된 숫자를 얻은 다음 n 으로 XOR 하여 비트를 반전시킵니다. 입력 INF 이것은 다음과 같이 진행한다.

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

구현의 추가 장애물 은 첫 번째 단계 전, 마지막 단계 후 및 그 사이의 모든 단계에서 n 을 인쇄해야한다는 것 입니다. 파이썬에는 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 을 업데이트하려고 다음, 우리는 루프에 남아 한 번 더 상태를 인쇄 할 수 있습니다. 그러나 ZeroDivisionError를0/0 트리거 하여 루프를 종료하고 오류와 함께 종료합니다. 이로 인해 stray 출력이 stderr로 출력 되며 기본적으로 허용됩니다 .

자바 스크립트, 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 글자 단어를 지원합니다. 최대 6 자의 단어를 지원하려면 4 바이트를 추가하십시오.

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

실제로 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

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

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

Mathematica, 99 바이트

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

익명의 기능. 문자열을 입력으로 사용하고 숫자 목록을 출력으로 반환합니다.

하스켈, 109 (123) 118 (102) 97 바이트

5 바이트를 절약 한 @nimi에게 감사합니다!

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 바이트)를 사용하십시오 .

유니 코드 범위에서 작동합니다 [0..255]. 비트를 재귀 적으로 뒤집습니다.

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.
• bindecltrim선행 0을 제거하는 대신 : -12
• echo루프 바디에서 1 바이트 print를 루프 헤드에 저장 합니다.

펄, 65 바이트

53 바이트 코드 + 12 -Mbigint -p.

저를 13 바이트 절약 해 주신 @ Dada 에게 감사드립니다 !

$_=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

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

파이썬 3, 99 95 바이트

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

주요 아이디어는 문자열을 바이트로 변환하여 숫자로 변환하는 것입니다. 각 반복은 출력과 XOR을 모두 1로 인쇄하여 0으로 진행합니다.

파이썬 2, 117115 바이트

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-1원하는 작업을 수행하기위한 XOR 마스크도 있습니다. 가장 긴 부분은 입력을 초기 비트 시퀀스로 변환하는 것입니다.

예:

"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

루비, 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 답변 에서 영감을 얻었습니다.

미로 , 104 103 바이트

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

온라인으로 사용해보십시오!

설명:

명령 포인터는 벽이 아닌 가장 왼쪽 상단 문자에서 시작합니다 (벽에는 공백과를 제외한 모든 문자가 포함됨 v).

주황색:

이 루프는 한 번에 한 문자 씩 ASCII 코드로 입력하여 현재 값에 추가하고 현재 값에 256을 곱합니다.

• ' 무 작동
• ,다음 입력 문자의 ASCII 코드를 스택 맨 위로 또는 EOF 인 경우 -1을 누릅니다. 이 시점에서 입력이 수신되면 스택의 상단이 강력하기 때문에 코드가 오른쪽으로 이동합니다 (아래로 이동). 그렇지 않으면 스택의 상단이 음수이므로 왼쪽으로 돌아갑니다.
• | 스택에서 상위 2 개 항목을 팝하고 비트 OR 결과를 푸시합니다.
• _ 제로 푸시
• 256보이는 각 숫자가 튀어 x나옵니다 x*10+digit. 따라서 이것은 스택의 맨 위로 푸시 0 이전 푸시 256과 결합되었습니다.
• *팝 y, 팝 x, 푸시 x*y. 이 시점에서 스택의 상단이 양수이기 때문에 루프 주위에서 계속 코드가 우회전합니다.

푸른:

• )스택 상단을 증가시킵니다. 입력의 끝에 도달하면 코드는 왼쪽으로 돌아가 스택에서 -1로이 지점에 도달하며 0으로 증가합니다.
• 256 스택 0의 상단을 가지면이 256을 푸시 할 수 있습니다.
• /Pop y, pop xpush x/y(정수 나누기). 입력에 각 루프에 256을 곱 했으므로 마지막 곱셈을 되돌려 야합니다.
• : 스택의 상단을 복제하여 나중에 현재 값의 사본을 얻습니다.
• ! 스택의 상단을 팝하고 정수 값을 STDOUT에 인쇄하십시오.
• \ 새 줄을 인쇄하십시오.
• _2 스택 상단으로 2를 밉니다.
• } 스택 상단을 보조 스택 상단으로 이동하십시오.

빨간:

이 루프는 내부 ​​(녹색) 루프에서 계산 된 특정 값으로 XOR에 의해 현재 값의 비트를 뒤집습니다. 그런 다음 현재 값을 출력하고 현재 값이 0이면 프로그램을 종료합니다.

• _ 0을 누릅니다 (제어 흐름).
• ; 스택 상단을 버리십시오 (제어 흐름).
• :현재 값을 복제하십시오. 사본은 XOR을 계산하는 데 사용됩니다.
• _ 0을 누릅니다 (제어 흐름).
• (녹색 루프)
• $팝 y, 팝 x, 푸시 x XOR y.
• :! 현재 값을 복제하고 정수 표현을 인쇄하십시오.
• 현재 값이 0이면 계속 진행 @하고 종료합니다.
• \ 새 줄을 인쇄하십시오.
• _2} 2를 누르고 보조 스택으로 이동하십시오.
• _1 1 (제어 흐름)을 누릅니다.

초록:

이 루프는 현재 값을 XOR하는 데 필요한 값을 계산합니다. 이 작업은 보조 스택의 상단을 반복해서 두 배로 늘리면서 주 스택의 정지시 현재 값의 사본을 절반에 도달 할 때까지 절반으로 줄임으로써 수행됩니다.

• _ 0을 누릅니다 (제어 흐름).
• ; 제어 흐름을 시행하는 데만 사용되는 현재 값을 폐기하십시오.
• _2 현재 값을 반으로 줄이려면 2를 누릅니다.
• / 분할
• { 보조 스택의 상단을 기본 스택의 상단으로 이동하십시오.
• _2* 스택 상단을 두 배로
• } 메인 스택의 상단을 다시 보조 스택으로 옮깁니다.
• _1 제어 흐름을 위해 하나를 누르십시오.
• 루프를 종료 한 후 :
• ; XOR 계산에서 왼쪽 0을 버립니다.
• { 계산 된 XOR을 기본 스택으로 이동하십시오.
• ( XOR 값에서 1을 뺍니다.

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)})input을 가져 와서 $args[0]이를 char배열 로 캐스트하고 각 문자를 반복합니다. .NET [convert]::ToString(int,base)을 사용하여 각각을 이진 문자열로 변환합니다. 그러나 앞에 0이 포함되어 있지 않으므로 해당 문자열을 다시 캐스트하고 0을 마스크로 사용하여 메서드를 [int]호출 해야 합니다. 그런 다음 해당 문자열을 parens로 캡슐화하고 함께 묶은 다음에 저장합니다 ..ToString()8-join$a

루프 내에서 [convert]::ToInt64(string,base)이진수를 10 진수로 변환합니다. 파이프 라인에 남겨지고 루프가 재설정 될 때 플러시됩니다 (따라서 암시 적으로 인쇄됩니다). 다음 섹션 수행하는 계산은 - 우리는 .TrimStart(), 앞에 0을 제거하는 -split00과 1 얻을에 분할에 string-array의 1,의 -replace마지막 제로로하는 사람, 그리고 -join함께 배열 다시 함께 1의. 그런 다음 루프가 다시 시작됩니다.

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 바이트

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

또한 줄 바꿈을 스택에 넣는 것 보다 1 바이트를 절약 할 수있는 Dennis 에게 감사드립니다 .pN\

J, 24 바이트

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

나중에 설명하겠습니다!

레티 나, 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

온라인으로 사용해보십시오

두 자보다 긴 입력으로 시도하지 마십시오. (온라인 인터프리터를 사용하면 시간이 초과됩니다.) 이진수를 십진수 전에 단항으로 변환해야합니다. :디

불행히도 후행 0과 줄 바꿈이 있지만 출력이 여전히 정확하기 때문에 괜찮다고 가정했습니다.

설명

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

루비-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>'

프로그램은 완료 후 예외와 함께 종료되지만 오류 출력이 STDOUT (STDOUT)이 아닌 STDERR로 이동하는 한 괜찮습니다.

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

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,

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