Обратный отсчет от «Бесконечности»

47

Похоже на невыполнимую задачу, верно? Ну, на самом деле это не так сложно. Если мы напишем слово Infinityкак 8-битный двоичный код ASCII, мы получим:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

Это можно объединить и преобразовать в десятичное значение 5291279215216915577. Теперь с этим номером мы можем работать ...

Способ обратного отсчета:

  1. Выведите исходную строку в виде десятичного числа (как показано выше)
  2. Удалить начальные 0 в двоичном представлении (если есть)
  3. Переключить биты в двоичном представлении (1-> 0, 0-> 1)
  4. Выведите число в десятичном виде
  5. Повторите шаги 2-4, пока не достигнете 0.

Вызов:

Создайте программу или функцию, которая принимает строку в качестве входных данных и выводит (в любом подходящем формате) числа, которые вы получите при выполнении описанной выше процедуры.

Прецедент:

Я думаю, что задачу будет довольно легко понять, хотя это всего лишь один контрольный пример. Я буду использовать Infвместо того, Infinityчтобы держать это довольно коротким.

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

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

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

Ваш код должен поддерживать строки, которые могут быть представлены в виде двоичного числа вплоть до ограничения вашего языка. Все строки будут содержать только печатаемые символы ASCII от 32 до 126 (от пробела до тильды).


Leaderboard

Стьюи Гриффин
источник
31
Чак Норрис , 8 байтов:Inf:-1:0
Луис Мендо
2
@LuisMendo Чак Норрис 'NARS-APL:∞..0
Адам
5
@ LuisMendo Вы уверены, что не имеете в виду Джона Скита ?
mbomb007

Ответы:

12

Желе , 15 10 байт

-5 байт благодаря @Dennis (конвертируется напрямую из базы 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 
Джонатан Аллан
источник
1
Первая часть просто Oḅ⁹.
Деннис
О боже, как я это пропустил ?!
Джонатан Аллан
11

Python 2, 89 82 77 76 75 байт

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

Проверьте это на Ideone .

Как это устроено

После инициализации от n до 0 вторая строка выполняет преобразование строки в целое число, указанное в запросах следующим образом.

На каждом шаге n сдвигается на 8 единиц влево, а затем по битам ИЛИ с кодовой точкой следующего символа c . Для ввода Inf это происходит следующим образом.

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

Теперь мы готовы генерировать вывод. Чтобы инвертировать биты n , мы поступим следующим образом.

Сначала мы вычисляем биты в двоичном представлении n без начальных нулей. Давайте назовем результат k . Затем мы вычисляем k k степень 2 , которая имеет k + 1 двоичных цифр: один 1 , за которым следуют k 0 . Мы вычитаем 1 из результата, получая число, состоящее из k единиц, которое затем XOR с n, чтобы инвертировать его биты. Для ввода 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 перед первым шагом, после последнего шага и на всех промежуточных этапах. В Python нет циклов do-while, и один оператор print стоит 8 байт, поэтому вместо этого мы делаем следующее.

В простой реализации этапа обновления, т. Е.

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

мы заменим цикл на бесконечный ( while 1) и вычислим 1цикл как n/n. Это эквивалентно, пока n> 0 .

Как только n = 0 , мы остаемся в цикле, печатаем состояние еще раз, затем пытаемся его обновить. Тем не менее, 0/0запускает ZeroDivisionError , выход из цикла и выход с ошибкой. Обратите внимание, что это приводит к случайному выводу в STDERR, что разрешено по умолчанию .

Деннис
источник
2
Мне нравится этот -n/nтрюк :-)
ETHproductions
Можешь объяснить чем n/nтрюк? Возможно, это было объяснено в другом ответе где-то, но я не нашел его. Что это здесь делает?
Стьюи Гриффин
@StewieGriffin n / n равно 1, пока n не равно 0, затем выдает ошибку и вызывает остановку программы.
Jazzpi
С сообщением об ошибке (надеюсь)?
Стьюи Гриффин
1
@ StewieGriffin Действительно. Python мучительно многословен, когда дело доходит до сообщений об ошибках. Я отредактировал свой ответ, чтобы включить объяснение.
Деннис
8

JavaScript, 82 байта

Сохраненный байт благодаря @Arnuald

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

Один из очень немногих случаев, когда полная программа превосходит функцию (а ES6 не превосходит ES5) ...


Выше поддерживается до 4-х буквенных слов. Добавьте 4 байта для поддержки до 6 букв:

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

ETHproductions
источник
g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0(-1)
Тит
@ Титус Спасибо! Не уверен, почему я не подумал об этом
ETHproductions
n<<8|y.charCodeAt()должен сохранить байт. for(;n;)for(i=!alert(n);i<=n;i*=2)n^=iсохранит еще один байт, но вы не отобразите 0, что, вероятно, требуется.
Арнаулд
@ Arnauld Спасибо. Я думал об этом n<<8раньше, но решил, что это не сработает, потому что оно сломается для n с более чем 31 битом Полагаю, теперь это не имеет значения, поскольку я уже разделил его между 31-разрядной и 53-разрядной версиями ... И, к сожалению, я не думаю, что смогу что-либо сохранить в предупреждении, предупреждая обе первые итерация и последняя.
ETHproductions
7

На самом деле , 14 байтов

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

Попробуйте онлайн!

Объяснение:

2@├¿W■├♂≈♂Y2@¿
 @├             encode input in binary
2  ¿            convert from binary to decimal
    W           while the number is not 0:
     ■            print the number without popping
      ├           convert number to binary
       ♂≈         convert each character to an int
         ♂Y       boolean negate each int
           2@¿    convert from binary to decimal
Мего
источник
6

05AB1E , 18 байт

Использует кодировку CP-1252 .

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

Попробуйте онлайн!

объяснение

Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join
Emigna
источник
4

MATL , 13 байт

8W:qZA`tB~XBt

Попробуйте онлайн!

объяснение

8W:q            % Push array [0 1 ... 255]
    ZA          % Take input string and convert it from the base defined by the
                % alphabet [0 1 ... 255] to decimal
      `         % Do...while
       t        % Duplicate
        B       % Convert to binary
         ~      % Negate
          XB    % Convert to decimal
            t   % Duplicate. Used as loop condition: exit if zero
Луис Мендо
источник
4

Mathematica, 99 байтов

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

Анонимная функция. Принимает строку в качестве входных данных и возвращает список чисел в качестве выходных данных.

LegionMammal978
источник
4

Haskell, 109 123 118 102 97 байт

Спасибо @nimi за сохранение 5 байтов!

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

Использование: (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"

Гарантируется, что язык работает с числами до 29 бит, обычно работает с 64-битными числами в 64-битных системах. map(fromIntegral.fromEnum)Вместо этого используйте (+14 байт) для поддержки произвольно больших чисел.

Работает для диапазона Юникод [0..255]. Рекурсивно переворачивает биты.

Angs
источник
1
Вы можете заменить takeWhile(>0)на fst.span(>0). Если вы идете без очков, вы можете отказаться от имени f, поэтому ваша основная функция (++[0]) ... map fromEnum.
Nimi
@nimi спасибо, удаление имени решает проблему вывода типа, с которой я столкнулся f.
Angs
Почему fromIntegral? Из задачи: «должен поддерживать ... до 63 бит ... или предел вашего языка», так что Intдолжно быть хорошо. Если вы хотите сохранить его, переместите его в map, т. Е. Свою старую версию foldl1и map(fromIntegral.fromEnum).
Ними
@nimi OP разместил здесь комментарий (так как удален), спрашивая, поддерживает ли он 63 бита, поэтому я предположил, что это было его намерением. Бьет меня
Angs
4

PHP, 132 126 123 120 108 107 байт

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));
  • печать 0 после цикла вместо начального значения перед циклом сохраняет 6 байтов.
  • unpackа str_splitделает ord()устаревшими -> -3 байтов
  • подчеркивание _как разделитель сохраняет 3.
  • bindecвместо того, ltrimчтобы удалить ведущие нули: -12
  • echoв теле цикла экономит 1 байт printв заголовке цикла.
Titus
источник
Не может $n=$n*256+$i;for(print$n;$n;)быть написано как for(print$n=$n*256+$i;$n;)? Поскольку часть задания будет выполнена один раз, это должно сработать. И вместо echo _.$n=[...], вы должны использовать echo _,$n=[...]вместо. Он не сохранит ни одного байта, но ускорит код крошечным крошечным крошечным кусочком и разделит операторы. Это означает, что, например, echo _,$a?5:6;можно написать вместо echo _.($a?5:6);. Это может быть полезно в будущем.
Исмаэль Мигель
@IsmaelMiguel Часть задания - это цикл. Я на самом деле использую запятую, когда мне не нужна точка; это остаток от printв этом случае. Один не стоит редактировать; но спасибо.
Тит
О, верно ... Это внутри foreach(unpack("C*",$argv[1])as$i)... Глупая я ... И да, изменение точки с запятой для того же эффекта не стоит проблем.
Исмаэль Мигель
4

Perl, 65 байт

Код 53 байта + 12 для -Mbigint -p.

Спасибо @ Dada за спасение мне 13 байтов!

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

Довольно простой подход, отличающийся только от большинства из них, заключается в том, что число сохраняется в двоичном виде и распечатывается в десятичном виде. Я уверен, что это может быть улучшено, возможно, с сохранением деталей в массиве. -Mbigintнемного неудобно, но необходимо.

использование

echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0
echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0
Дом Гастингс
источник
1
Распакуй моего друга, распакуй! perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'(Я понятия не имею, как использовать распаковку обычно, мне просто повезло, когда гуглил, как преобразовать строку в двоичную ;-))
Dada
Аааа, я всегда забываю о unpackсинтаксисе, всегда поражает воображение! Я обновлю, спасибо!
Дом Гастингс
Существует perlpacktut, который должен помочь ... Я прочитал первые 10 строк десятки раз, но мне действительно нужно время, чтобы прочитать остальное!
Дада
@ Дада, я уверен, что я читал это много раз, просто он никогда не остается ... Спасибо еще раз -13 не маленький подвиг! Я должен был переключиться на echo -nэто единственное другое изменение.
Дом Гастингс
4

Pyth, 12 байт

.usi!MjN2 2C

Программа, которая принимает ввод строки в кавычках и печатает результат в виде списка целых чисел.

Проверьте все контрольные примеры

Как это устроено

.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print
TheBikingViking
источник
3

Python 3, 99 95 байт

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

Основная идея - преобразовать строку в байты в число. На каждой итерации выводятся выходные данные и XOR со всеми 1, чтобы перейти к нулю.

Джимми Джонсон
источник
Вам не нужны круглые скобки 2**x.bit_length()-1. Порядок операций по мощности и вычитанию выше, чем xor. Кроме того, это whileможет быть в одной строке.
mbomb007
Напишите цикл while на одной строке (удалите
символ
Попробуйте запустить программу с, P=printа затем использовать P()вместоprint()
Cyoce
3

Python 2, 117 115 байт

Экономия 2 байта благодаря Cyoce.

Предполагается, что ввод заключен в кавычки, например "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
Карл Напф
источник
Вы можете заменить -i-1на~i
Cyoce
3

Рубин, 104 101 100 81 80 65 байт

19 байтов сохранено благодаря @WayneConrad!
15 байтов сохранено благодаря @philomory!
1 байт сохранен благодаря @LeeW!

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

Принимает ввод через аргументы командной строки.

Вдохновленный ответом Python @ JimmyJohnson

Cyoce
источник
Вы можете сохранить несколько символов, заменив i.to_s(2).rjust 8,'0'на"%08b"%i
Уэйн Конрад
Кроме того, я думаю, что inject(:+)можно заменить наjoin
Уэйн Конрад
@WayneConrad спасибо за помощь! Не уверен, как я забыл о них
Cyoce
Рад, что смог помочь! Спасибо, что научили меня методу #bit_length, о котором я не знал.
Уэйн Конрад
1
Переключение на режим с unpackпоследующим [0]указанием вместо того, чтобы возиться gsub, сэкономит 11 байт. Переключение на $*[0]вместо gets.chop(использование аргумента командной строки вместо консольного ввода) сохранит еще 9, первая строка станет p n=$*[0].unpack('B*')[0].to_i(2).
Philomory
3

Лабиринт , 104 103 байта

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

Попробуйте онлайн!

Объяснение:

Цветное изображение исходного кода

Указатель инструкций начинается с верхнего левого наиболее нестеночного символа (стены содержат пробелы и любые буквы, кроме v).

Оранжевый:

Этот цикл получает вход по одному символу за раз в виде кода ASCII, добавляя его к текущему значению и умножая текущее значение на 256.

  • ' Нет-оп
  • ,Вставьте код ascii следующего входного символа в верхнюю часть стека или -1, если EOF. В этот момент, если ввод был получен, код повернет направо (двигаясь вниз), потому что вершина стека является положительной. В противном случае он повернет налево, потому что вершина стека отрицательна.
  • | Извлеките два верхних элемента из стека и вставьте результат побитового ИЛИ.
  • _ Толчок ноль
  • 256Каждая увиденная цифра трещит xи толкает x*10+digit. Таким образом, это в сочетании с пуш-ноль предыдущего пуш 256 на вершину стека.
  • *Поп y, поп x, толчок x*y. В этот момент, поскольку вершина стека положительна, код повернет вправо, чтобы продолжить цикл.

Синий:

  • )Увеличьте вершину стека. Когда будет достигнут конец ввода, код повернется влево, чтобы добраться до этой точки с -1 в стеке, который будет увеличиваться до нуля.
  • 256 Наличие вершины стека 0 позволяет нам выдвинуть это 256.
  • /Pop y, pop xpush x/y(целочисленное деление). Поскольку мы умножали входные данные на 256 в каждом цикле, нам нужно вернуть последнее умножение.
  • : Дублируйте вершину стека, чтобы у нас была копия текущего значения для дальнейшего использования.
  • ! Вставьте вершину стека и выведите целочисленное значение в STDOUT.
  • \ Распечатать новую строку.
  • _2 Нажмите два к вершине стека.
  • } Переместите вершину стека к вершине вспомогательного стека.

Красный:

Этот цикл переворачивает биты текущего значения по XOR с определенным значением, вычисленным во внутреннем (зеленом) цикле. Затем он выводит текущее значение и выходит из программы, если текущее значение равно нулю.

  • _ Нажмите ноль (контроль потока).
  • ; Откажитесь от вершины стека (поток управления).
  • :Дублируйте текущее значение. Копия будет использована для расчета XOR.
  • _ Нажмите ноль (контроль потока).
  • (Зеленая петля)
  • $Поп y, поп x, толчок x XOR y.
  • :! Дублируйте текущее значение и выведите целочисленное представление.
  • Если текущее значение равно 0, мы продолжаем прямо в @и заканчиваем.
  • \ Распечатать новую строку.
  • _2} Нажмите 2 и перейдите к вспомогательному стеку.
  • _1 Нажмите 1 (контроль потока).

Зеленый цвет:

Этот цикл вычисляет значение, на которое нам нужно XOR текущего значения. Это делается путем многократного удвоения вершины вспомогательного стека при одновременном уменьшении вдвое копии текущего значения на остановке основного стека до достижения 0.

  • _ Нажмите ноль (контроль потока).
  • ; Отменить текущее значение, которое используется только для обеспечения потока управления.
  • _2 Нажмите 2, чтобы вдвое сократить текущее значение.
  • / Делить
  • { Переместите верхнюю часть вспомогательного стека в верхнюю часть основного стека.
  • _2* Двойная вершина стека
  • } Переместите верхнюю часть основного стека обратно в дополнительный стек.
  • _1 Нажмите один для контроля потока.
  • После выхода из цикла:
  • ; Откажитесь от нуля слева от расчета XOR.
  • { Переместите вычисленный XOR в основной стек.
  • ( Вычтите одно из значения XOR.
Роберт Хикман
источник
2

PowerShell v2 +, 158 байт

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

Да, так что преобразование баз в PowerShell действительно отстойно . И мы сделаем это дважды здесь.

ОК, так что это просто forцикл, $aт. Е. Мы выполняем цикл , пока $aсуществует. В конечном итоге мы достигнем пустой строки (что неверно), и вот как мы закончим.

Настройка цикла, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})принимает входные данные $args[0], charпреобразует их как -array и перебирает каждый символ. Мы используем .NET [convert]::ToString(int,base)для преобразования каждого в двоичную строку. Однако это не включает ведущие нули, поэтому нам нужно повторно привести эту строку в качестве [int]и вызвать ее .ToString() метод с 8нулями в качестве маски. Затем эти строки заключаются в скобки и -joinобъединяются, а затем сохраняются в $a.

Внутри цикла мы [convert]::ToInt64(string,base)должны преобразовать двоичное число в десятичное число. Это остается в конвейере и впоследствии сбрасывается, когда цикл сбрасывается (и, следовательно, неявно печатается). В следующем разделе выполняются вычисления - мы .TrimStart()удаляем любые начальные нули, -split0разбиваем на нули и получаем stringмассив- 1s, -replaceте, что с нулями, и, наконец, -joinмассив обратно вместе с 1s. Затем цикл начинается снова.

PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0
AdmBorkBork
источник
2

CJam , 17 16 18 байт

q256b0{_p2b:!2bj}j

Попробуйте онлайн!

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

ПРИМЕЧАНИЕ . Старая 16-байтовая версия некорректно работала с пустыми строками:

q256b{_p2b:!2b}h

Кроме того, спасибо Деннису за предложение, pкоторое экономит 1 байт по сравнению с N\переносом строк в стек.

Линус
источник
_p2b:!2bсохраняет байт. Кроме того, вы должны использовать l; rпотерпит неудачу, если вход содержит пробелы.
Деннис
@Dennis Спасибо, хотя теперь это заставляет меня волноваться, если пустая строка является проблемой.
Линус
Правильно. qбудет работать правильно с пустыми строками.
Деннис
2

J, 24 байта

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

Объяснение придет позже!

Олиус
источник
2
Добро пожаловать в PPCG! Постоянная ссылка для заинтересованных: попробуйте онлайн!
Деннис
1

Сетчатка, 116 байт

Число байтов предполагает кодировку ISO 8859-1. Строка 5 содержит непечатаемые байты. Это T`\x00-\xFF.

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

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


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

)M`1
^0+

T`01`10

Попробуйте онлайн

Не пытайтесь сделать это с вводом длиннее двух символов. (Время ожидания истекает при использовании онлайн-переводчика.) Мы должны преобразовать двоичный код в унарный до десятичного. : D

К сожалению, есть конечный ноль и перевод строки, но я решил предположить, что все в порядке, потому что вывод все еще правильный.

объяснение

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

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


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

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

T`01`10     # Flip bits; (implicit loop end)
mbomb007
источник
1

Рубин - 70 байт

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

Программа завершается с исключением после завершения, но, насколько я понимаю, это нормально, если вывод ошибок идет в STDERR, а не в STDOUT (что и происходит).

philomory
источник
1

C, 147 135 133 125 122 121 117 115 103 байтов

Сохранено 5 байтов благодаря @Cyoce!

Сохранено 2 байта благодаря @Cyoce и @cleblanc!

Сохранено 12 байтов благодаря @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 */
    }
}
Noodle9
источник
Я думаю, что вы можете пропустить intдекларации
Cyoce
Вы также можете сохранить байт, преобразовав последний whileцикл в forцикл
Cyoce
И вы можете изменить while(1)наfor(;;)
Cyoce
@Cyoce Я попытался удалить intобъявления везде и получил gcc -std=89ошибки. Но спасибо за for(;;)совет. Я буду продолжать пытаться удалить intобъявления :)))
Noodle9
извините, я не проверял это. Я думаю, что это будет работать, если вы переместите их наверх ( i;main(c,v)char**v;{...}). На мобильном телефоне прямо сейчас, так что я не могу быть уверен
Cyoce
0

C, 129 120 117 110 107 105 байт

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

Протестировано с

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

выход

5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,
cleblanc
источник
Я думаю, что вы можете перейти i=0к объявлению iи оставить раздел инициализации forцикла пустым
Cyoce
@Cyoce Функция должна работать каждый раз, когда она iвызывается, и, поскольку она является неявным глобальным int, она должна инициализироваться каждый раз, когда вызывается f (...).
cleblanc
@Cyoce Ты был прав в конце концов. Функция не завершает работу до тех пор, iпока снова не станет равной нулю, поэтому она все еще может использоваться повторно.
cleblanc
102 байта
floorcat
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
    }
}
Yodle
источник
Я не делаю C #, но может var t="";var f="";быть var t="",f=""вместо этого? Сохраняет 5 байтов.
CorsiKa
@corsiKa Да, я пробовал это, но это дало мне ошибку, я думаю, потому что это переменная, а не строка.
Йодле
На самом деле, строка сохраняет один байт, так что, думаю, я так и сделаю.
Йодл
Также вы можете сделать переменную az для нуля, чтобы сохранить эти неприятные кавычки?
CorsiKa
Только что попробовал, он на самом деле поднимает байтовый счет, потому что я не могу заменить и строку «0», и символ «0» :(
Yodle