Ce défi consiste à sortir sur votre terminal, fenêtre, toile ou écran les chiffres de zéro à 10 inclus. Chaque nombre sorti doit être affiché comme un nybble de 4 bits de large, donc zéro doit s'afficher au fur 0000et à mesure.

Vous pouvez séparer chaque numéro émis par un espace, une virgule ou un retour chariot. La plus petite solution l'emporte, mais les chiffres peuvent être affichés dans l'ordre que vous souhaitez tant qu'il n'y a pas de numéros répétitifs dans votre séquence.

Les entrées dans les langages binaires de bas niveau ne doivent pas se soucier des virgules ou des séparateurs d'espaces blancs s'il n'est pas possible de sortir avec des virgules ou des espaces blancs (c'est-à-dire que la sortie standard est limitée au binaire uniquement, ou votre solution est pour un kit informatique précoce comme le KIM-1 qui a un affichage numérique limité).

SmileBASIC, 26 octets

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

MATL , 6 octets

0:10YB

Essayez-le sur MATL Online

Explication

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 octets

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

Essayez-le en ligne!

JavaScript, 46 octets

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

Pourquoi utiliser une fonction de remplissage lorsque vous pouvez simplement ajouter 16 à chaque nombre et couper le premier chiffre binaire?

Japt , 7 octets

GôA,_¤Å

Et ici, je pensais que Japt était voué à être plus long que toutes les autres langues de golf ...

Testez-le en ligne!

Explication

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

Normalement, les virgules peuvent être supprimées dans Japt, mais celui-ci est là à cause d'un bogue: _signifie normalement function(Z){Z, mais pour une raison quelconque, le compilateur pense que cela A_signifie function(A,Z){Z.

Utilitaires Bash + GNU, 26

• 4 octets enregistrés grâce à @Dennis

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

Essayez-le en ligne .

Utilitaires Bash + Unix, 29 26 octets

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

Essayez-le en ligne!

C'est la même longueur que la solution de @ DigitalTrauma / @ Dennis, mais utilise une méthode complètement différente.

La sortie est:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Toute commande est autorisée.)

Pure Bash , 34 octets

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

Essayez la version pure Bash en ligne!

La sortie est:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 octets

#:i.11

Merci aux miles pour l'avoir réduit à 6 octets!

Gelée , 7 octets

2Bṗ4ṫ6Y

Essayez-le en ligne!

(5 octets si les lignes de fin de Nybbles sont autorisées, 2Bṗ4Y )

Comment?

Imprime dans l'ordre décroissant.

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

Une alternative à 7 octets est 2ṗ4Ịṫ6Y, la [1,0]est remplacée par [1,2]et Ịest la monade ( abs(z)<=1) est "insignifiante" , convertissant 2s en 0s.

Python 3.6, 36 35 octets

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

-1 octet grâce à @JonathanAllan

Python 3.5 et versions antérieures:

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

Essayez-le en ligne!

PHP, 33 octets

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

CJam , 12 octets

B{G+2b1>}%N*

Essayez-le en ligne!

Explication

L'approche cartésienne du pouvoir aurait été mon choix, mais a déjà été retenue.

Donc, cela génère des nombres de 0 à 10, et pour chacun, il ajoute 16 et convertit en binaire. L'ajout de 16 garantit que les zéros de tête requis sont produits, ainsi qu'un autre de tête qui est supprimé.

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 octets

dec2bin(0:10)

Démo en ligne

Gelée , 10, 9 , 8 octets

⁴r26BḊ€Y

Essayez-le en ligne!

Je ne suis pas si bon en gelée, donc je serais ouvert à tous les conseils!

Cela utilise le premier algorithme d'Emigna

Merci à Dennis d'avoir rasé deux octets, ce qui m'a fait lier sa propre réponse. : P

Explication:

      Ḋ€    # 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 octets

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

Merci à @DJMcMayhem d'avoir joué au golf sur 2 octets!

Essayez-le en ligne!

Jelly, 8 bytes

2Ḷṗ4ḣ11Y

Try it online!

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.

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, 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!

Retina, 36 33 bytes

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

Try it online!

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.

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
]