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

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

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

SmileBASIC, 26 байтов

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

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

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

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

JavaScript, 46 байт

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

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

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.

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

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

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

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

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

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

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

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

Выход:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

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

Чистый Баш , 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

J, 6 байт

#:i.11

Спасибо миль за сокращение до 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с.

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

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

PHP, 33 байта

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

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

MATLAB / Octave, 13 байт

dec2bin(0:10)

Демо онлайн

Желе , 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

Python 2 , 38 36 байт

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.

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.

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

Сетчатка , 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 цифры) извлекаются. Совпадения выводятся в списке с разделением строк.

Рубин, 25 байт

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

BF, 121 101 байт

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

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

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

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- Исходное решение.

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 Отличная идея, спасибо!

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

R - 23

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

R.utils::intToBin(0:10)

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

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

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

Python 2, 44 байта

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

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

Пайк, 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)

Pyth - 8 7 байт

<5^_`T4

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

сложено , 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

Рубин, 38 байт

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

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
]