[Question]
  [
This challenge is to output to your terminal, window, canvas or screen the numbers zero to 10 inclusive. Each outputted number must be shown as a 4-bit wide nybble, so zero must show as `0000` and so on.
You may separate each number outputted with a space, comma or carriage return. Smallest solution wins but the numbers can be displayed in any order you like as long as there are no repeating numbers in your sequence.
Entries in low-level binary languages need not worry about the comma or white space separators if it is not possible to output with commas or white spaces (i.e., the standard output is limited to binary only, or your solution is for an early computer kit such as the [KIM-1](http://www.floodgap.com/retrobits/kim-1/) which has a limited digital display). 
  
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 6 bytes
```
0:10YB
```
Try it at [**MATL Online**](https://matl.io/?code=0%3A10YB&inputs=&version=19.7.4)
**Explanation**
```
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
        
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 8 bytes
```
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
```
[Try it online!](https://tio.run/nexus/05ab1e#@x9icnhxUIjdocWHdv//DwA "05AB1E – TIO Nexus")
[Answer]
## JavaScript, 46 bytes
```
for(i=15;i++<26;)alert(i.toString(2).slice(1))
```
Why use a padding function when you can simply add 16 to each number and slice off the first binary digit?
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
```
GôA,_¤Å
```
And here I was thinking Japt was doomed to be longer than every other golfing language...
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.4&code=R/RBLF+kxQ==&input=)
### Explanation
```
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
```
Normally commas can be removed in Japt, but this one is there because of a bug: `_` normally means `function(Z){Z`, but for some reason the compiler thinks `A_` means `function(A,Z){Z`.
[Answer]
# Bash + GNU utils, 26
* 4 bytes saved thanks to @Dennis
```
seq -w 0 1010|sed /[2-9]/d
```
[Try it online](https://tio.run/nexus/bash#@1@cWqigW65goGBoYGhQU5yaoqAfbaRrGauf8v8/AA).
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Unix utilities, ~~29~~ 26 bytes
```
dc -e2o8927II^*8/p|fold -4
```
[Try it online!](https://tio.run/nexus/bash#@5@SrKCbapRvYWlk7ukZp2WhX1CTlp@ToqBr8v8/AA "Bash – TIO Nexus")
This is the same length as @DigitalTrauma/@Dennis's solution, but uses a completely different method.
Output is:
```
1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000
```
(Any order is allowed.)
---
# Pure [Bash](https://www.gnu.org/software/bash/), 34 bytes
```
echo 0{0,1}{0,1}{0,1} 10{00,01,10}
```
[Try the pure Bash version online!](https://tio.run/nexus/bash#@5@anJGvYFBtoGNYiyAUDIEiBjoGhjqGBrX//wMA "Bash – TIO Nexus")
Output is:
```
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010
```
[Answer]
# J, 6 bytes
```
#:i.11
```
Thanks to miles for cutting it down to 6 bytes!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
2Bṗ4ṫ6Y
```
**[Try it online!](https://tio.run/nexus/jelly#@2/k9HDndJOHO1ebRf7/DwA "Jelly – TIO Nexus")**
(5 bytes if trailing lines of nybbles are allowed, `2Bṗ4Y`)
### How?
Prints in descending order.
```
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
```
An alternative 7-byter is `2ṗ4Ịṫ6Y`, the `[1,0]` is replaced with `[1,2]` and `Ị` is the "is insignificant" monad (`abs(z)<=1`), converting `2`s to `0`s.
[Answer]
# Python 3.6, ~~36~~ 35 bytes
```
i=11
while i:i-=1;print(f"{i:04b}")
```
-1 byte thanks to @JonathanAllan
### Python 3.5 and earlier:
```
i=11
while i:i-=1;print("{:04b}".format(i))
```
[Try it online!](https://tio.run/nexus/python3#@59pa2jIVZ6RmZOqkGmVqWtraF1QlJlXoqFUbWVgklSrpJeWX5SbWKKRqan5/z8A "Python 3 – TIO Nexus")
[Answer]
# PHP, 33 bytes
```
while($i<11)printf('%04b ',$i++);
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 12 bytes
```
B{G+2b1>}%N*
```
[Try it online!](https://tio.run/nexus/cjam#@@9U7a5tlGRoV6vqp/X/PwA "CJam – TIO Nexus")
### Explanation
The Cartesian power approach would have been my choice, but was already taken.
So this generates numbers from 0 to 10, and for each it adds 16 and converts to binary. Adding 16 ensures that the required leading zeros are produced, together with an extra leading one which is removed.
```
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
```
[Answer]
# [Intel 8080 machine code](https://en.wikipedia.org/wiki/Intel_8080), [MITS Altair 8800](https://en.wikipedia.org/wiki/Altair_8800), 10 bytes
```
00 00 00 00 00 00 00 00 76
```
Listing:
```
0000   00   NOP      
0001   00   NOP      
0002   00   NOP      
0003   00   NOP      
0004   00   NOP      
0005   00   NOP      
0006   00   NOP      
0007   00   NOP      
0008   00   NOP      
0009   00   NOP      
000A   76   HLT 
```
Uses the CPU's program counter (PC, aka instruction pointer) to count from 0 to 10 then halt. The output display is conveniently in nibble format already.
**Output:**
Output is displayed on [Blinkenlights](https://commons.wikimedia.org/wiki/File:Blinkenlights-original.png#/media/File:Blinkenlights-original.png) A3-A0.
[![enter image description here](https://i.stack.imgur.com/wM78o.gif)](https://i.stack.imgur.com/wM78o.gif)
[Try it online!](https://s2js.com/altair/sim.html)
[Answer]
# MATLAB / Octave, 13 bytes
```
dec2bin(0:10)
```
[Online Demo](http://ideone.com/sHy3Vm)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10, 9~~, 8 bytes
```
⁴r26BḊ€Y
```
[Try it online!](https://tio.run/nexus/jelly#@/@ocUuRkZnTwx1dj5rWRP7/DwA "Jelly – TIO Nexus")
I'm not that great at jelly, so I'd be open to any tips!
This uses [Emigna's first algorithm](https://codegolf.stackexchange.com/revisions/110172/1)
---
*Thanks to Dennis for ~~shaving off two bytes~~ making me tie his own answer. :P*
Explanation:
```
      Ḋ€    # 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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
2Ḷṗ4ḣ11Y
```
[Try it online!](https://tio.run/nexus/jelly#@2/0cMe2hzunmzzcsdjQMPL/fwA "Jelly – TIO Nexus")
### How it works
```
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.
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~38~~ 36 bytes
```
n=16;exec"print bin(n)[3:];n+=1;"*11
```
*Thanks to @DJMcMayhem for golfing off 2 bytes!*
[Try it online!](https://tio.run/nexus/python2#@59na2hmnVqRmqxUUJSZV6KQlJmnkacZbWwVa52nbWtoraRlaPj/PwA "Python 2 – TIO Nexus")
[Answer]
# SmileBASIC, 26 bytes
```
FOR I=0TO&HA?BIN$(I,4)NEXT
```
[Answer]
# RProgN, 15 Bytes
```
~16.aL1{2B26q}:
```
~~This has been a *very* good modivation to add a `pad` function. The entirety of `]L4\-'0'\m\.`, more than half the code, is to pad.~~
\_Saved 6 bytes thanks to [@ETHProductions](https://codegolf.stackexchange.com/users/42545/ethproductions), that's the pad function cut in half.
## Explained
```
~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.
```
[Try it online!](https://tio.run/nexus/rprogn#@19naKaX6GNYbeRkZFZYa/X/PwA "RProgN – TIO Nexus")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~36~~ 33 bytes
```
%%%%
+`(^|\b)%
0$%'¶$%`1
11!`\d+
```
[Try it online!](https://tio.run/nexus/retina#@8@lCgRc2gkacTUxSZqqXAYqquqHtqmoJhhyGRoqJsSkaP//DwA "Retina – TIO Nexus")
**Explanation**
```
%%%%
```
Replace the empty (non-existent) input with `%%%%`.
```
+`(^|\b)%
0$%'¶$%`1
```
On the first run of this stage, it will match `^%` and essentially replace the text `%%%%` with the two lines `0%%%` and `1%%%`. The stage will loop until the output stops changing. On the second run, it will match `\b%` (since digits count as word characters and `%` doesn't), and replace the groups by duplicating them and adding `0` to one copy and `1` to the other: `0%%%` becomes the lines `00%%` and `01%%` (and the same sort of thing for `1%%%`). Through this loop all 16 bitstrings will be produced, linefeed separated.
```
11!`\d+
```
The first 11 matches of `\d+` (a run of at least 1 digit) are retrieved. The matches are output in a linefeed-separated list.
[Answer]
## Ruby, 25 bytes
```
11.times{|n|puts"%04b"%n}
```
[Answer]
# 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!)](https://fatiherikli.github.io/brainfuck-visualizer/#LC4uLi4+LC48Li4uKy4+LjwtLi4rLi0uPi48Li4rLi4+LjwtLisuLS4uPi48LisuLS4rLj4uPC0uKy4uLS4+LjwuKy4uLj4uPC4tLi4uPi48Ky4tLi4rLj4uPC4tLisuLS4hMAo=).
Potentially 51 bytes if each operator was considered as 4 bits
[Answer]
## 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' ) );
}
```
---
[Answer]
## 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!](https://tio.run/nexus/c-gcc#FYzBCoMwEAX/JSBkMaFRvL2uPyI5FIqwSLZi7Snk29PkMocZmKpOXHLHtkTOoSC9RC3l/XPZxAHpyVPjOFJWTpCmeoJCujs2iazQB88oPQgvkDVAvKfzEr13a4a3aX/xUxxmwvm7v9YYQim1/gE "C (gcc) – TIO Nexus")
[Answer]
## 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"
```
[Answer]
# 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!](https://tio.run/nexus/c-gcc#@5@rk6eTb52moVmdll@kkWtraGidq6trrQni5dnm6uTbmlrnAwXytGyNNAtKS5IzEos08u3z1CzsTSytTCysLDWta/9n5pUo5CZm5mmAGFU6CiBVWlqVmgrVXAoKCkDTreF07X8A "C (gcc) – TIO Nexus")
---
**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!](https://tio.run/nexus/c-gcc#@5@rk6eTb52moVmdll@kkWtraGidq6trrQni5dnm6uTbmlrnAwXytGyNNAtKS5IzEos08u3z1CzsTSytTCysLDWta/9n5pUo5CZm5mmAGFU6CiBVWlqVmgrVXAoKCkDTreF07X8A "C (gcc) – TIO Nexus")
[Answer]
# C, 68 bytes
```
f(){puts("0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010");}
```
Somehow, this is the shortest C answer so far…
EDIT: I was missing `1000` somehow. Well, it’s still winning.
[Answer]
# Commodore VIC-20/VC-20/C64 - 95 69 68 67 tokenized BASIC bytes used (obfuscated and minimized)
```
0dEfnb(x)=sgn(xandb):fOi=0to10:b=8:fOj=0to3:?rI(stR(fnb(i)),1);:b=b/2:nE:?:nE
```
Copy and paste the above text into WinVice, for instance. Just about fits onto 80 characters on a Commodore 64.
Here's the non-obfuscated symbolic listing for illustrative purposes:
```
0 DEF FN B(X)=SGN(X AND B)
1 FOR I=0 TO 10
2  LET B=8
3  FOR J=0 TO 3
4   PRINT RIGHT$(STR$(FN B(I)),1);
5   LET B=B/2
6  NEXT J
7  PRINT
8 NEXT I
```
Of course this may be minimised and further obfuscated. Explanation:
The `DEF FN` command in line zero is a simple function which accepts one numeric parameter. This will give the algebraic sign the number passed to it as a parameter, in this case is `AND`ed with the value `B` (declared elsewhere, but becomes global once declared).
Line 1 starts the loop counter `I`
Line 2 sets the value of the 3rd BIT.
Line 3 starts loop counter `J` (we want bits 0 - 3 essentially).
Line 4 gets the `STR$` value (string value) of the function `FN B(I)`, this is then passed to the `RIGHT$` command as CBM BASIC auto-pads outputted numbers with a white space, so we get the last character in the string created by `STR$`.
Line 5 moves the BIT counter down one (like `x >> 1` in C I suppose).
Line 6 moves the `J` loop up one.
Line 7 prints a new line (line `echo PHP_EOL;` in PHP).
Line 8 moves the `I` loop up one.
I've 'nested' the listing in the example to better show the loop and loop order.
[![C64 counting in nybbles](https://i.stack.imgur.com/6nsF7.png)](https://i.stack.imgur.com/6nsF7.png)
[Answer]
# 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.
[Answer]
## Pyke, 8 bytes
```
TFw0+b2t
```
[Try it here!](http://pyke.catbus.co.uk/?code=TFw0%2Bb2t)
```
TFw0+b2t - for i in range(10):
  w0+    -    i+16
     b2  -   bin(^)
       t -  ^[:-1]
```
Also 8 bytes:
```
TF 4@b2t
```
[Try it here!](http://pyke.catbus.co.uk/?code=TF+4%40b2t)
```
   4@    - set_bit(4, i)
```
[Answer]
# Pyth - ~~8~~ 7 bytes
```
<5^_`T4
```
[Try it online here](http://pyth.herokuapp.com/?code=%3C5%5E_%60T4&debug=0).
]