Esse desafio é enviar para o seu terminal, janela, tela ou tela os números de zero a 10, inclusive. Cada número emitido deve ser mostrado como um nybble de 4 bits de largura; portanto, zero deve ser exibido 0000assim por diante.

Você pode separar cada número gerado com um espaço, vírgula ou retorno de carro. A menor solução vence, mas os números podem ser exibidos em qualquer ordem que você quiser, desde que não haja números repetidos em sua sequência.

As entradas em idiomas binários de baixo nível não precisam se preocupar com os separadores de vírgula ou espaço em branco, se não for possível gerar vírgulas ou espaços em branco (ou seja, a saída padrão é limitada apenas ao binário ou sua solução é para um kit de computador antigo) como o KIM-1, que possui um display digital limitado).

SmileBASIC, 26 bytes

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

MATL , 6 bytes

0:10YB

Experimente no MATL Online

Explicação

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

Experimente online!

JavaScript, 46 bytes

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

Por que usar uma função de preenchimento quando você pode simplesmente adicionar 16 a cada número e cortar o primeiro dígito binário?

Japonês , 7 bytes

GôA,_¤Å

E aqui eu estava pensando que Japt estava fadado a ser mais longo do que qualquer outra língua do golfe ...

Teste online!

Explicação

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

Normalmente, vírgulas podem ser removidas no Japt, mas esta existe por causa de um erro: _normalmente significa function(Z){Z, mas por algum motivo o compilador pensa que A_significa function(A,Z){Z.

Utilitários Bash + GNU, 26

• 4 bytes salvos graças a @Dennis

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

Experimente online .

Utilitários Bash + Unix, 29 26 bytes

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

Experimente online!

Tem o mesmo tamanho da solução @ DigitalTrauma / @ Dennis, mas usa um método completamente diferente.

A saída é:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Qualquer pedido é permitido.)

Pure Bash , 34 bytes

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

Experimente a versão pura do Bash online!

A saída é:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 bytes

#:i.11

Graças a milhas por reduzi-lo para 6 bytes!

Geléia , 7 bytes

2Bṗ4ṫ6Y

Experimente online!

(5 bytes se linhas finais de nybbles forem permitidas 2Bṗ4Y)

Quão?

Imprime em ordem decrescente.

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

Um 7-byter alternativo é 2ṗ4Ịṫ6Y, o [1,0]é substituído por [1,2]e Ịé a mônada "é insignificante" ( abs(z)<=1), convertendo 2s para 0s.

Python 3.6, 36 35 bytes

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

-1 byte graças a @JonathanAllan

Python 3.5 e versões anteriores:

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

Experimente online!

PHP, 33 bytes

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

CJam , 12 bytes

B{G+2b1>}%N*

Experimente online!

Explicação

A abordagem do poder cartesiano teria sido minha escolha, mas já foi adotada.

Portanto, isso gera números de 0 a 10 e, para cada um, adiciona 16 e converte em binário. A adição de 16 garante que os zeros iniciais necessários sejam produzidos, juntamente com um zERO inicial extra que é removido.

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 / oitava, 13 bytes

dec2bin(0:10)

Demo Online

Gelatina , 10, 9 , 8 bytes

⁴r26BḊ€Y

Experimente online!

Eu não sou tão bom em geléia, então eu estaria aberto a qualquer dica!

Isso usa o primeiro algoritmo de Emigna

Agradeço a Dennis por cortar dois bytes, fazendo-me amarrar sua própria resposta. : P

Explicação:

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

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

Obrigado a @DJMcMayhem por jogar fora 2 bytes!

Experimente online!

Gelatina , 8 bytes

2Ḷṗ4ḣ11Y

Experimente online!

Como funciona

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

Esta foi uma modificação muito boa para adicionar uma padfunção. A totalidade de]L4\-'0'\m\. , mais da metade do código, é preenchida.

_Guardado 6 bytes graças ao @ETHProductions , essa é a função pad cortada ao meio.

Explicado

~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.

Experimente online!

Retina , 36 33 bytes

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

Experimente online!

Explicação

%%%%

Substitua a entrada vazia (inexistente) por %%%%.

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

Na primeira execução deste estágio, ele corresponderá ^%e substituirá essencialmente o texto %%%%pelas duas linhas 0%%%e 1%%%. O estágio girará até que a saída pare de mudar. Na segunda execução, ele corresponderá \b%(já que os dígitos contam como caracteres de palavra e% não) e substitui os grupos duplicando-os e adicionando 0a uma cópia e 1à outra: 0%%%torna - se as linhas 00%%e 01%%(e o mesmo tipo de coisa para 1%%%) Através desse loop, todas as 16 seqüências de bits serão produzidas, com avanço de linha separado.

11!`\d+

As 11 primeiras correspondências de \d+(uma execução de pelo menos 1 dígito) são recuperadas. As correspondências são exibidas em uma lista separada por avanço de linha.

Ruby, 25 bytes

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

BF, 121 101 bytes

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

Requer uma nova linha à direita. Utiliza o !símbolo (portanto, marque a caixa que diz !) com este intérprete (experimente online!) .

Potencialmente 51 bytes se cada operador foi considerado como 4 bits

C #, 96 bytes

Golfe

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

Código completo

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

Lançamentos

• v1.0 - 96 bytes- Solução inicial.

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

Versão não destruída:

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

Definitivamente pode ser encurtado !?

@Ahemone Ideia impressionante, obrigado!

Deve funcionar agora! Experimente online!

R - 23

Podemos usar a intToBinfunção do R.utilspacote:

R.utils::intToBin(0:10)

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

C, 75 68 69 bytes

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

Experimente online!

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

Experimente online!

Python 2, 44 bytes

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

Isso usa a zfillfunção que funciona como, rjustexceto que ela sempre funciona 0para que você não perca bytes em um argumento.

Pyke, 8 bytes

TFw0+b2t

Experimente aqui!

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

Também 8 bytes:

TF 4@b2t

Experimente aqui!

   4@    - set_bit(4, i)

Pitão - 8 7 bytes

<5^_`T4

Experimente online aqui .

empilhados , 30 bytes

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

Experimente online!

11:>é um intervalo de 0até 10. O resto é bastante auto-explicativo.

Outras soluções que encontrei:

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

Tenho certeza de que isso pode ser reduzido - é praticamente o meu primeiro golfe BF.

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

Experimente online! Assume uma fita infinita nas duas direções, como o intérprete do TIO usa. Um intérprete onde< em que a extremidade esquerda da fita fica sem operação economiza três bytes.

Explicação

Mais da metade do código (os primeiros 77 bytes, para ser mais preciso) é gasto na inicialização da fita. Os passos são assim:

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

As células inicializadas para 1armazenar os bits do nosso número mais 1: 1representam um bit zero e2 representam um bit.

A fase de inicialização terminou com o ponteiro no 11. Agora usamos essa célula para executar 11 iterações do nosso 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
]