19

Эта задача заключается в выводе на ваш терминал, в окно, на холст или на экран чисел от 0 до 10 включительно. Каждое выведенное число должно быть показано как 4-битный nybble, поэтому ноль должен показываться как 0000и так далее.

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

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

code-golf kolmogorov-complexity binary

— Шон Бебберс
источник

Да, пробелы, запятые, запятая, а затем пробел или эквивалент "\ r \ n" на выбранном вами языке.

— Шон Бебберс

Не извините, так как это похоже на 4 отдельные нулевые цифры, а не на 4-разрядное двоичное число.

— Шон Бебберс

Не то чтобы я действительно уверен, что напишу такой ответ, но будет ли нормально вывести несколько дополнительных кусочков в дополнение к 11 обязательным?

— Арно

2

Они клев, а не клочья.

— 0WJYxW9FMN

Не в соответствии с Commodore 64 Справочное руководство программистов

— Шон Бебберс

2

SmileBASIC, 26 байтов

FOR I=0TO&HA?BIN$(I,4)NEXT

— 12Me21
источник

15

MATL , 6 байтов

0:10YB

Попробуйте это на MATL Online

объяснение

0:10    % Create the array [0...10]
YB      % Convert this array to a binary string where each number is 
        % placed on a new row
        % Implicitly display the result

— Suever
источник

15

05AB1E , 9 8 байт

T         # push 10
 4ã       # cartesian product repeat with 4
   R      # reverse list
    T>£   # take the first 11 elements of the list
      »   # join by newline and display

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

— Emigna
источник

10

Подождите ... декартово произведение цифр числа? Это просто ...

— ETHproductions

13

JavaScript, 46 байт

for(i=15;i++<26;)alert(i.toString(2).slice(1))

Зачем использовать функцию заполнения, если вы можете просто добавить 16 к каждому числу и вырезать первую двоичную цифру?

— ETHproductions
источник

9

Japt , 7 байт

GôA,_¤Å

И тут я подумал, что Джапт обречен быть длиннее любого другого языка игры в гольф ...

Проверьте это онлайн!

объяснение

GôA,_¤Å  // Implicit: A = 10, G = 16
GôA      // Create the inclusive range [G...G+A].
    _    // Map each item Z to Z
     ¤   //   .toString(2)
      Å  //   .slice(1).
         // Implicit: output result of last expression

Обычно в Japt могут быть удалены запятые, но эта есть из-за ошибки: _обычно означает function(Z){Z, но по какой-то причине компилятор считает, что это A_означает function(A,Z){Z.

— ETHproductions
источник

Хороший. Я застрял наAô_¤

— Оливер

8

Утилиты Bash + GNU, 26

4 байта сохранены благодаря @Dennis

seq -w 0 1010|sed /[2-9]/d

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

— Цифровая травма
источник

1

seq -w 0 1010должно сработать.

— Деннис

@ Деннис Спасибо - я не помню, -wчтобы seqраньше использовалась эта опция .

— Цифровая травма

7

Утилиты Bash + Unix, 29 26 байт

dc -e2o8927II^*8/p|fold -4

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

Это та же длина, что и у решения @ DigitalTrauma / @ Dennis, но использует совершенно другой метод.

Выход:

(Любой заказ разрешен.)

Чистый Баш , 34 байта

echo 0{0,1}{0,1}{0,1} 10{00,01,10}

Попробуйте чистую версию Bash онлайн!

Выход:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

— Митчелл Спектор
источник

7

J, 6 байт

#:i.11

Спасибо миль за сокращение до 6 байт!

— Блоки
источник

#:i.11должен работать так же хорошо

— мили

Я не уверен, что это верно, согласно ответу на удаленный комментарий .

— Адам

@ Adám Я не могу это просмотреть. Не могли бы вы объяснить, почему это не vaild?

— Блоки

Потому что он генерирует логический массив × 4, который печатается в виде цифр с пробелами между ними. Но комментарий, похоже, подразумевает, что пробелы не допускаются внутри двоичных чисел.

— Адам

6

Желе , 7 байт

2Bṗ4ṫ6Y

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

(5 байт, если разрешены завершающие строки nybbles, 2Bṗ4Y)

Как?

Печать в порядке убывания.

2Bṗ4ṫ6Y - Main link, no arguments
2B      - 2 converted to binary -> [1,0]
  ṗ4    - Cartesian 4th power -> [[1,1,1,1], [1,1,1,0], ..., [0,0,0,0]]
                            i.e.  16       , 15         ..., 0
    ṫ6  - tail from 6th item  -> [[1,0,1,0], [1,0,0,1], ..., [0,0,0,0]]
                            i.e.  10       , 9        , ..., 0
      Y - join with line feeds
        - implicit print

Альтернатива 7-byter это 2ṗ4Ịṫ6Y, то [1,0]заменяется [1,2]и Ịявляется «незначительно» Монада ( abs(z)<=1), преобразование 2с до 0с.

— Джонатан Аллан
источник

6

Python 3.6, 36 35 байт

i=11
while i:i-=1;print(f"{i:04b}")

-1 байт благодаря @JonathanAllan

Python 3.5 и более ранние версии:

i=11
while i:i-=1;print("{:04b}".format(i))

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

— овс
источник

1

i=11(новая строка) while i:i-=1;print(f"{i:04b}"), для 35.

— Джонатан Аллан

4

PHP, 33 байта

while($i<11)printf('%04b ',$i++);

— user63956
источник

4

CJam , 12 байт

B{G+2b1>}%N*

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

объяснение

Подход картезианской силы был бы моим выбором, но уже был принят.

Таким образом, это генерирует числа от 0 до 10, и для каждого это добавляет 16 и конвертирует в двоичный файл. Добавление 16 обеспечивает создание необходимых ведущих нулей вместе с дополнительным ведущим нулем, который удаляется.

B             e# Push 11
 {      }%    e# Map over "11", implicitly converted to the array [0 1 ... 10]
  G+          e# Add 16. This makes sure there will be 5 binary digits: a leading 1
              e# which will have to be removed and the remaining, valid digits
    2b        e# Convert to array of binary digits
      1>      e# Remove first digit
          N*  e# Join by newlines. Implicitly converts arrays to strings

— Луис Мендо
источник

3

MATLAB / Octave, 13 байт

dec2bin(0:10)

Демо онлайн

— Suever
источник

3

Желе , 10, 9 , 8 байтов

⁴r26BḊ€Y

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

Я не очень хорош в желе, поэтому буду открыт для любых советов!

Это использует первый алгоритм Emigna

Спасибо Деннису за то, что он ~~сбрил два байта и~~ заставил меня связать свой ответ. :П

Объяснение:

      Ḋ€    # Return all but the first element of each item in the list:
⁴r26        #   [16, 17, 18, ... 26]
     B      #   Converted to binary
        Y   # And joined with newlines

— DJMcMayhem
источник

Ḋ€сохраняет байт.

— Деннис

@ Деннис Ах, это имеет смысл. Благодарность!

— DJMcMayhem

⁴r27сохраняет еще один.

— Деннис

3

Python 2 , 38 36 байт

n=16;exec"print bin(n)[3:];n+=1;"*11

Спасибо @DJMcMayhem за игру в 2 байта!

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

— Деннис
источник

for n in range(11):print bin(n+16)[3:]также в 38 байтах.

— ETHproductions

n=16;exec"print bin(n)[3:];n+=1;"*11в два

— раза

@DJMcMayhem Это действительно так. Благодарность! :)

— Денис

2

Желе , 8 байт

2Ḷṗ4ḣ11Y

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

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

2Ḷṗ4ḣ11Y  Main link.

2Ḷ        Unlength 2; yield [0, 1].
  ṗ4      Take the fourth Cartesian power.
    ḣ11   Head 11; discard all but the first eleven elements.
       Y  Join, separating by linefeeds.

— Деннис
источник

2

RProgN, 15 байт

~16.aL1{2B26q}:

Это было очень хорошим дополнением для добавления padфункции. В целом ]L4\-'0'\m\., более половины кода, это дополнить.

_Сохранено 6 байтов благодаря @ETHProductions , это функция подушечки разрезать пополам.

Разъяснения

~16.aL1{2B26q}:
~               # Zero Space Segment
 16.            # The literal number 16
    aL          # The length of the Alphabet
      1         # The literal number 1
       {     }: # For each number between 16 and 26 inclusive
        2B      # Convert to base 2
          26q   # Get the characters between 2 and 6 inclusive.

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

— Ataco
источник

length of the AlphabetХороший способ сохранить байт ;-)

— ETHproductions

2

Сетчатка , 36- 33 байта


%%%%
+`(^|\b)%
0$%'¶$%`1
11!`\d+

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

объяснение


%%%%

Замените пустой (несуществующий) вход на %%%%.

+`(^|\b)%
0$%'¶$%`1

При первом запуске этого этапа он будет соответствовать ^%и по существу заменить текст %%%%двумя строками 0%%%и 1%%%. Этап будет зацикливаться, пока выход не перестанет изменяться. При втором запуске он будет соответствовать \b%(так как цифры считаются как символы слова, а %не как), и заменит группы, дублируя их и добавляя 0к одной копии 1к другой: 0%%%становится строками 00%%и 01%%(и тем же самым для 1%%%). Через этот цикл будут созданы все 16 цепочек битов, разделенных переводом строки.

11!`\d+

Первые 11 совпадений \d+(серия не менее 1 цифры) извлекаются. Совпадения выводятся в списке с разделением строк.

— Бизнес Кот
источник

Мне любопытно понять, как работает эта 0$%'¶$%линия 1`. Что $%, `1, '¶представляете?

— Kritixi Lithos

@KritixiLithos Извините, я не объяснил детали, это немного запутанно: P. $%`представляет все до матча в одной строке и $%'все после матча в одной строке. ¶это буквальный перевод строки. Таким образом, в основном замена соответствует первому %в строке и заменяет его на 0плюс остальную часть строки, на которой она была, символ новой строки, начало строки, на которой она находилась, и a 1. Конечно, начало и конец линии, на которой он находился, не затронуты заменой, потому что они не были частью матча.

— Business Cat

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

— Business Cat

Ах, спасибо, это было полезно :) (сейчас я пытаюсь выучить Retina)

— Kritixi Lithos,

В этом случае, я думаю, вы можете использовать G11`вместо последней строки регулярное выражение

— Kritixi Lithos

2

Рубин, 25 байт

11.times{|n|puts"%04b"%n}

— гигабайт
источник

2

BF, 121 101 байт

,....>,.<...+.>.<-..+.-.>.<..+..>.<-.+.-..>.<.+.-.+.>.<-.+..-.>.<.+...>.<.-...>.<+.-..+.>.<.-.+.-.!0

Требуется завершающий перевод строки. Использует !символ (поэтому установите флажок с надписью !) с этим переводчиком (попробуйте онлайн!) .

Потенциально 51 байт, если каждый оператор рассматривается как 4 бита

— Timtech
источник

Вы должны указать (или дополнительно добавить байт) для !включенного флажка.

— Конор О'Брайен

К сожалению, я новичок в этом и думал, что это закодировано в URL. Уточним ... подождите, собственно, я думаю, что это уже указано во втором предложении (?),

— Уточню,

2

C #, 96 байт

Golfed

()=>{for(int i=0;i++<11;)System.Console.WriteLine(System.Convert.ToString(i,2).PadLeft(4,'0'));}

Ungolfed

() => {
    for( int i = 0; i++ < 1; )
        System.Console.WriteLine( System.Convert.ToString( i, 2 ).PadLeft( 4, '0' ) );
}

Полный код

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            m();

            Console.ReadLine();
        }

        static void m() {
            for( Int32 i = 0; i++ < 11; )
                Console.WriteLine(
                    Convert.ToString( i, 2 ). // Converts the number to binary code
                    PadLeft( 4, '0' ) );      // Fills the number with the missing '0's
        }
    }
}

релизы

v1.0 - 96 bytes- Исходное решение.

— auhmaan
источник

Мне нравится версия релиза, которую вы добавили - вы также собираетесь включить версии RC? \ o /

— Шон Бебберс

1

Переход, если честно, не знаю , что RC значит ... Это , как я пытаюсь разместить свои решения в PPCG

— auhmaan

RC означает «Release Candidate» - то есть, вы отправите несколько версий с небольшими отличиями и будете ждать, какая из версий RC будет наиболее стабильной. Так что, если бы у вас была версия A и версия B, вы могли бы иметь v1.0-RCa и v1.0-RCb или что-то в этом роде.

— Шон Бебберс

1

Ах это. Нет. Если я делаю другую версию , я сразу увеличиваю номер версии .

— auhmaan

2

C 170 120 байтов

n,i,m,k[4]={0};f(){for(m=0;m<=10;m++){n=m;i=0;for(;n;i++){k[i]=n;n/=2;}for(i=4;i>0;i--)printf("%d",k[i-1]%2);puts("");}}

Безголовая версия:

void f()
{
    int n,i,m,k[4]={0};


   for(m=0;m<=10;m++)
   {
      n=m;
      i=0;

      for(;n;i++)
      {
         k[i]=n;
         n/=2;
      }  
      for(i=4;i>0;i--)
         printf("%d",k[i-1]%2);

      puts("");        
   }
}

Определенно можно укоротить !?

@ Ahemone Отличная идея, спасибо!

Должно работать сейчас! Попробуйте онлайн!

— Абель Том
источник

первый forцикл в вашей версии для гольфа должен быть равен 4, а не 3, но это не имеет значения, поскольку цикл может быть полностью исключен, а второй цикл for может начинаться с 0. Вы также можете просто использовать while(n), но сжать whileцикл до forцикл еще раз спасает. n/=2также сэкономит вам байт за смену. Вам также не хватает завершения }в версии для гольфа, что приводит к ошибке при компиляции.

— Ахемон,

@Ahemone Исправил }и улучшил код, на 50 байт короче, в зависимости от вашей идеи.

— Абель Том

102 байта

— floorcat

2

R - 23

Мы можем использовать intToBinфункцию из R.utilsпакета:

R.utils::intToBin(0:10)

[1] "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010"

— прыгучий мяч
источник

2

С 75 68 69 байтов

Подход 1: 75 73 74 байта

m;p(i){putchar(i?m&i?49:48:9);}r(){for(m=11;m--;p(4),p(2),p(1),p(0))p(8);}

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

Подход 2: 68 69 байт

m,n,o;f(){for(m=11;m--;)for(n=m,o=5;o--;n*=2)putchar(o?n&8?49:48:9);}

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

— Ahemone
источник

Предлагаю m,n;f(o)вместоm,n,o;f()

— floorcat

1

Python 2, 44 байта

for x in range(11):print bin(x)[2:].zfill(4)

При этом используется zfillфункция, которая работает аналогично, rjustза исключением того, что она всегда заполнена, 0поэтому вы не тратите байты на аргумент.

— Мастер пшеницы
источник

Подождите, что, все это время я трачу байты на создание собственной функции заполнения? ( lambda k,l:' '*(len(k)-l)+k) Вау ... +1 только из-за этого: D

— HyperNeutrino

1

Пайк, 8 байт

TFw0+b2t

Попробуй это здесь!

TFw0+b2t - for i in range(10):
  w0+    -    i+16
     b2  -   bin(^)
       t -  ^[:-1]

Также 8 байтов:

TF 4@b2t

Попробуй это здесь!

   4@    - set_bit(4, i)

— синий
источник

1

Pyth - 8 7 байт

<5^_`T4

Попробуйте это онлайн здесь .

— Maltysen
источник

1

сложено , 30 байтов

11:>[2 baserep'0'4 pad out]map

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

11:>это диапазон от 0до 10. Остальное довольно очевидно.

Другие решения, которые я нашел:

11:>[bits 4 dpad''join out]map
11:>[bits 4 dpad$tostrmap]map out
11~>15+[bits behead''join out]map
16 26|>[bits behead''join out]map

— Конор О'Брайен
источник

1

Рубин, 38 байт

11.times{|i|puts i.to_s(2).rjust 4,?0}

— dkudriavtsev
источник

-1 байт, избавившись от скобок:11.times{|i|puts i.to_s(2).rjust 4,?0}

— Конор О'Брайен,

1

BF , 134 байта

Я уверен, что это может быть сокращено - это в значительной степени мой первый гольф BF.

++++++++++[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]>>+>[-->>+>]<<<[<<<]>>[>[>>-[<<+.->]<[>]>-[<<.>]<[>]>++>]<-[<<<-]++<<[<<<]>.>-]

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

объяснение

Больше половины кода (первые 77 байтов, если быть точным) тратится на инициализацию ленты. Шаги идут так:

++++++++++
10|

[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]
 0|10|10|50| 0| 0|50| 0| 0|50| 0| 0|50|

>>+>[-->>+>]<<<[<<<]>>
 0|10|11|48| 0| 1|48| 0| 1|48| 0| 1|48| 0| 1|

Ячейки, инициализированные для 1хранения битов нашего числа плюс 1: 1представляют нулевой бит и 2представляют один бит.

Фаза инициализации завершилась указателем на 11. Теперь мы используем эту ячейку для запуска 11 итераций нашего цикла:

[>          Move to the first 48
 [>>-       While we're still on a 48, move 2 cells over and decrement
  [         The cell's value now equals the bit it represents; if it's not 0:
   <<+.-    Move to the 48, increment, output, and decrement again
   >        Move to the next cell, which holds a 0
  ]         Leave the loop
  <[>]>     Pointer shenanigans to get back on the cell representing the bit
  -         Decrement again: cell is 255 for a zero bit, 0 for a one bit
  [         If cell is not 0:
   <<.>     Move to the 48, output, and move to the 0 cell
  ]
  <[>]>++   Get back on the bit's cell; increment back to original value
  >         Move to the next 48
 ]          Loop exits once we've output all four bits
            Now we increment the binary number: a one bit turns into a zero bit and
            carries; a zero bit turns into a one bit and doesn't carry
 <-         Move back to the rightmost bit cell and decrement
 [          If it is not 0, it must represent a one
  <<<-      Leave it decremented, go to the next bit cell and decrement it too
 ]          Loop exits on a bit cell that represented a zero
 ++         Increment it twice (to represent a one)
 <<[<<<]    Move back to first cell on tape
 >.         Move to 10 cell and output (newline)
 >-         Move to loop counter cell and decrement
]

— DLosc
источник

Подсчет в двоичных ниблах

SmileBASIC, 26 байтов

MATL , 6 байтов

05AB1E , 9 8 байт

JavaScript, 46 байт

Japt , 7 байт

объяснение

Утилиты Bash + GNU, 26

Утилиты Bash + Unix, 29 26 байт

Чистый Баш , 34 байта

J, 6 байт

Желе , 7 байт

Как?

Python 3.6, 36 35 байт

Python 3.5 и более ранние версии:

PHP, 33 байта

CJam , 12 байт

объяснение

MATLAB / Octave, 13 байт

Желе , 10, 9 , 8 байтов

Python 2 , 38 36 байт

Желе , 8 байт

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

RProgN, 15 байт

Разъяснения

Сетчатка , 36- 33 байта

Рубин, 25 байт

BF, 121 101 байт

C #, 96 байт

C 170 120 байтов

R - 23

С 75 68 69 байтов

Python 2, 44 байта

Пайк, 8 байт

Pyth - 8 7 байт

сложено , 30 байтов

Рубин, 38 байт

BF , 134 байта

объяснение