Este desafío es enviar a su terminal, ventana, lienzo o pantalla los números del cero al 10 inclusive. Cada número de salida debe mostrarse como un nybble de 4 bits de ancho, por lo que cero debe mostrarse como 0000y así sucesivamente.

Puede separar cada número generado con un espacio, una coma o un retorno de carro. La solución más pequeña gana, pero los números se pueden mostrar en el orden que desee, siempre que no haya números repetidos en su secuencia.

Las entradas en lenguajes binarios de bajo nivel no deben preocuparse por los separadores de comas o espacios en blanco si no es posible generar comas o espacios en blanco (es decir, la salida estándar está limitada solo a binarios, o su solución es un kit de computadora anterior como el KIM-1 que tiene una pantalla digital limitada).

SmileBASIC, 26 bytes

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

MATL , 6 bytes

0:10YB

Pruébalo en MATL Online

Explicación

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

Pruébalo en línea!

JavaScript, 46 bytes

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

¿Por qué usar una función de relleno cuando simplemente puede agregar 16 a cada número y cortar el primer dígito binario?

Japt , 7 bytes

GôA,_¤Å

Y aquí estaba pensando que Japt estaba condenado a ser más largo que cualquier otro idioma de golf ...

¡Pruébalo en línea!

Explicación

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, las comas se pueden eliminar en Japt, pero esta está allí debido a un error: _normalmente significa function(Z){Z, pero por alguna razón el compilador piensa que A_significa function(A,Z){Z.

Bash + GNU utils, 26

• 4 bytes guardados gracias a @Dennis

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

Pruébalo en línea .

Bash + Unix utilidades, 29 26 bytes

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

Pruébalo en línea!

Esta es la misma longitud que la solución de @ DigitalTrauma / @ Dennis, pero utiliza un método completamente diferente.

Salida es:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Se permite cualquier pedido).

Pure Bash , 34 bytes

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

¡Prueba la versión pura de Bash en línea!

Salida es:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 bytes

#:i.11

¡Gracias a las millas por reducirlo a 6 bytes!

Jalea , 7 bytes

2Bṗ4ṫ6Y

Pruébalo en línea!

(5 bytes si se permiten líneas finales de nybbles, 2Bṗ4Y)

¿Cómo?

Imprime en orden descendente.

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

Una alternativa de 7 bytes es 2ṗ4Ịṫ6Y, [1,0]se reemplaza con [1,2]y Ịes la mónada "es insignificante" ( abs(z)<=1), convirtiendo 2s en 0s.

Python 3.6, 36 35 bytes

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

-1 byte gracias a @JonathanAllan

Python 3.5 y versiones anteriores:

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

Pruébalo en línea!

PHP, 33 bytes

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

CJam , 12 bytes

B{G+2b1>}%N*

Pruébalo en línea!

Explicación

El enfoque de poder cartesiano habría sido mi elección, pero ya fue tomado.

Entonces esto genera números del 0 al 10, y para cada uno agrega 16 y los convierte a binario. Agregar 16 asegura que se produzcan los ceros iniciales requeridos, junto con uno inicial adicional que se elimina.

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 bytes

dec2bin(0:10)

Demo en línea

Gelatina , 10, 9 , 8 bytes

⁴r26BḊ€Y

Pruébalo en línea!

No soy tan bueno en gelatina, ¡así que estaría abierto a cualquier consejo!

Esto usa el primer algoritmo de Emigna

Gracias a Dennis por reducir dos bytes y hacerme atar su propia respuesta. :PAG

Explicación:

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

¡Gracias a @DJMcMayhem por jugar golf en 2 bytes!

Pruébalo en línea!

Jalea , 8 bytes

2Ḷṗ4ḣ11Y

Pruébalo en línea!

Cómo 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 ha sido una muy buena modificación para agregar una padfunción. La totalidad de ]L4\-'0'\m\., más de la mitad del código, es para rellenar.

_Ahorró 6 bytes gracias a @ETHProductions , esa es la función de pad reducida a la mitad.

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.

Pruébalo en línea!

Retina , 36 33 bytes

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

Pruébalo en línea!

Explicación

%%%%

Reemplace la entrada vacía (inexistente) con %%%%.

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

En la primera ejecución de esta etapa, coincidirá ^%y esencialmente reemplazará el texto %%%%con las dos líneas 0%%%y 1%%%. La etapa se repetirá hasta que la salida deje de cambiar. En la segunda ejecución, coincidirá \b%(ya que los dígitos cuentan como caracteres de palabras y %no), y reemplazará los grupos al duplicarlos y agregarlos 0a una copia y 1a la otra: se 0%%%convierten en las líneas 00%%y 01%%(y el mismo tipo de cosas para 1%%%) A través de este bucle, se producirán las 16 cadenas de bits separadas por salto de línea.

11!`\d+

Se \d+recuperan las primeras 11 coincidencias de (una ejecución de al menos 1 dígito). Las coincidencias se muestran en una lista separada por salto de línea.

Rubí, 25 bytes

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

BF, 121101 bytes

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

Requiere una nueva línea final. Hace uso del !símbolo (por lo tanto, marque la casilla que dice !) con este intérprete (¡pruébelo en línea!) .

Potencialmente 51 bytes si cada operador se considera como 4 bits

C #, 96 bytes

Golfed

()=>{for(int i=0;i++<11;)System.Console.WriteLine(System.Convert.ToString(i,2).PadLeft(4,'0'));}

Sin golf

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

Lanzamientos

• v1.0 - 96 bytes- Solución 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("");}}

Versión sin golf:

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 se puede acortar?

@Ahemone Idea genial, ¡Gracias!

¡Debería funcionar ahora! Pruébalo en línea!

R - 23

Podemos usar la intToBinfunción del R.utilspaquete:

R.utils::intToBin(0:10)

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

C, 75 68 69 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Python 2, 44 bytes

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

Utiliza la zfillfunción que funciona como, rjustexcepto que siempre se rellena 0para que no desperdicies bytes en un argumento.

Pyke, 8 bytes

TFw0+b2t

Pruébalo aquí!

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

También 8 bytes:

TF 4@b2t

Pruébalo aquí!

   4@    - set_bit(4, i)

Pyth - 8 7 bytes

<5^_`T4

Pruébelo en línea aquí .

apilado , 30 bytes

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

Pruébalo en línea!

11:> es un rango de 0 a 10. El resto se explica por sí mismo.

Otras soluciones que he encontrado:

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

Rubí, 38 bytes.

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

BF , 134 bytes

Estoy seguro de que esto se puede acortar: es mi primer golf BF.

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

Pruébalo en línea! Asume una cinta infinita en ambas direcciones, como la que usa el intérprete en TIO. Un intérprete donde <en el extremo izquierdo de la cinta hay un no-op ahorraría tres bytes.

Explicación

Más de la mitad del código (los primeros 77 bytes, para ser precisos) se gasta inicializando la cinta. Los pasos van así:

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

Las celdas se inicializaron para 1almacenar los bits de nuestro número más 1: 1representa un bit cero y 2representa un bit.

La fase de inicialización terminó con el puntero en el 11. Ahora usamos esta celda para ejecutar 11 iteraciones de nuestro bucle:

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