Це завдання полягає у виведенні на ваш термінал, вікно, полотно або екранування цифр від нуля до 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-байт є 2ṗ4Ịṫ6Y, [1,0]замінюється на [1,2]і Ịє "несуттєвою" монадою ( abs(z)<=1), перетворюючи 2s в 0s.

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 / Октава, 13 байт

dec2bin(0:10)

Демонстрація в Інтернеті

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

⁴r26BḊ€Y

Спробуйте в Інтернеті!

Я не такий чудовий в желе, тому я б відкритий до будь-яких порад!

Для цього використовується перший алгоритм Еміньї

Дякую Деннісу за те, що поголив два байти, змусивши мене пов'язати його власну відповідь. : P

Пояснення:

      Ḋ€    # 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 цифри). Збіги виводяться у відокремленому рядком стрічці.

Ruby, 25 bytes

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

BF, 121 101 bytes

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

Requires a trailing newline. Makes use of ! symbol (so, check the box that says !) with this interpreter (try it online!).

Potentially 51 bytes if each operator was considered as 4 bits

C#, 96 bytes

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

Full code

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

Releases

• v1.0 - 96 bytes - Initial solution.

C 170 120 bytes

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

Ungolfed version:

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

Can definitely be shortened!?

@Ahemone Awesome idea, Thanks!

Should work now! Try it online!

R - 23

We can use intToBin function from the R.utils package:

R.utils::intToBin(0:10)

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

C, 75 68 69 bytes

Approach 1: 75 73 74 bytes

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

Try it online!

Approach 2: 68 69 bytes

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

Try it online!

Python 2, 44 bytes

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

This uses the zfill function which works like rjust except it always padds with 0 so you don't waste bytes on an argument.

Pyke, 8 bytes

TFw0+b2t

Try it here!

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

Also 8 bytes:

TF 4@b2t

Try it here!

   4@    - set_bit(4, i)

Pyth - 8 7 bytes

<5^_`T4

Try it online here.

stacked, 30 bytes

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

Try it online!

11:> is a range from 0 to 10. The rest is rather self-explanatory.

Other solutions that I've found:

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

Ruby, 38 bytes

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

BF, 134 bytes

I'm sure this can be shortened--it's pretty much my first BF golf.

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

Try it online! Assumes a tape infinite in both directions, like the interpreter at TIO uses. An interpreter where < at the left end of the tape is a no-op would save three bytes.

Explanation

More than half of the code (the first 77 bytes, to be precise) is spent initializing the tape. The steps go like this:

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

The cells initialized to 1 store the bits of our number plus 1: 1 represents a zero bit and 2 represents a one bit.

The initialization phase ended with the pointer on the 11. Now we use this cell to run 11 iterations of our loop:

[>          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
]