Questa sfida consiste nell'output sul tuo terminale, finestra, tela o schermo i numeri da zero a 10 inclusi. Ogni numero in uscita deve essere mostrato come un nybble largo a 4 bit, quindi zero deve essere visualizzato come 0000e così via.

È possibile separare ciascun numero generato con uno spazio, una virgola o un ritorno a capo. La soluzione più piccola vince ma i numeri possono essere visualizzati nell'ordine che preferisci purché nella sequenza non vi siano numeri che si ripetono.

Le voci in linguaggi binari di basso livello non devono preoccuparsi della virgola o dei separatori di spazi bianchi se non è possibile eseguire l'output con virgole o spazi bianchi (ovvero, l'output standard è limitato solo al binario o la soluzione è per un kit di computer iniziale come il KIM-1 che ha un display digitale limitato).

SmileBASIC, 26 byte

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

MATL , 6 byte

0:10YB

Provalo su MATL Online

Spiegazione

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 byte

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

Provalo online!

JavaScript, 46 byte

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

Perché usare una funzione di riempimento quando puoi semplicemente aggiungere 16 a ciascun numero e tagliare la prima cifra binaria?

Japt , 7 byte

GôA,_¤Å

E qui stavo pensando che Japt fosse condannato ad essere più lungo di ogni altra lingua del golf ...

Provalo online!

Spiegazione

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 le virgole possono essere rimosse in Japt, ma questa è lì a causa di un bug: _normalmente significa function(Z){Z, ma per qualche motivo il compilatore pensa che A_significhi function(A,Z){Z.

Utilità Bash + GNU, 26

• 4 byte salvati grazie a @Dennis

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

Provalo online .

Utilità Bash + Unix, 29 26 byte

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

Provalo online!

Questa è la stessa lunghezza della soluzione di @ DigitalTrauma / @ Dennis, ma utilizza un metodo completamente diverso.

L'output è:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(È consentito qualsiasi ordine.)

Pure Bash , 34 byte

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

Prova la versione pura di Bash online!

L'output è:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 byte

#:i.11

Grazie a miglia per averlo ridotto a 6 byte!

Gelatina , 7 byte

2Bṗ4ṫ6Y

Provalo online!

(5 byte se sono consentite righe finali di nybbles, 2Bṗ4Y )

Come?

Stampa in ordine 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

Un'alternativa a 7 byte è 2ṗ4Ịṫ6Y, [1,0]viene sostituita con [1,2]ed Ịè la "è insignificante" monade ( abs(z)<=1), convertendo 2s in 0s.

Python 3.6, 36 35 byte

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

-1 byte grazie a @JonathanAllan

Python 3.5 e precedenti:

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

Provalo online!

PHP, 33 byte

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

CJam , 12 byte

B{G+2b1>}%N*

Provalo online!

Spiegazione

L'approccio del potere cartesiano sarebbe stato la mia scelta, ma era già stato adottato.

Quindi questo genera numeri da 0 a 10 e per ciascuno aggiunge 16 e si converte in binario. L'aggiunta di 16 garantisce che vengano prodotti gli zeri iniziali richiesti, insieme a uno iniziale aggiuntivo che viene rimosso.

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 byte

dec2bin(0:10)

Demo online

Gelatina , 10, 9 , 8 byte

⁴r26BḊ€Y

Provalo online!

Non sono così bravo con la gelatina, quindi sarei aperto a qualsiasi consiglio!

Questo utilizza il primo algoritmo di Emigna

Grazie a Dennis per essermi rasato due byte facendomi legare la sua risposta. : P

Spiegazione:

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

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

Grazie a @DJMcMayhem per giocare a golf con 2 byte!

Provalo online!

Gelatina , 8 byte

2Ḷṗ4ḣ11Y

Provalo online!

Come funziona

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 byte

~16.aL1{2B26q}:

Questa è stata una molto buona modivation per aggiungere una padfunzione di. La totalità di]L4\-'0'\m\. , più della metà del codice, è pad.

_Salvata di 6 byte grazie a @ETHProductions , questa è la funzione pad tagliata a metà.

spiegato

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

Provalo online!

Retina , 36 33 byte

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

Provalo online!

Spiegazione

%%%%

Sostituire l'ingresso vuoto (inesistente) con %%%%.

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

Alla prima esecuzione di questa fase, corrisponderà ^%e essenzialmente sostituirà il testo %%%%con le due righe 0%%%e 1%%%. Lo stage eseguirà il loop fino a quando l'uscita non smette di cambiare. Alla seconda esecuzione, corrisponderà \b%(poiché le cifre contano come caratteri di parole e %non), e sostituirà i gruppi duplicandoli e aggiungendoli 0a una copia e 1all'altra: 0%%%diventa le linee 00%%e 01%%(e lo stesso tipo di cose per 1%%%). Attraverso questo loop verranno prodotte tutte e 16 le stringhe di bit, separate dall'alimentazione di linea.

11!`\d+

\d+Vengono recuperate le prime 11 partite di (una corsa di almeno 1 cifra). Le corrispondenze vengono emesse in un elenco separato da avanzamento riga.

Rubino, 25 byte

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

BF, 121 101 byte

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

Richiede una nuova riga finale. Usa il !simbolo (quindi, seleziona la casella che dice !) con questo interprete (provalo online!) .

Potenzialmente 51 byte se ogni operatore fosse considerato come 4 bit

C #, 96 byte

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

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

Uscite

• v1.0 - 96 bytes- Soluzione iniziale.

C 170 120 byte

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

Versione non golfata:

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

Può sicuramente essere abbreviato !?

@Ahemone Fantastica idea, grazie!

Dovrebbe funzionare ora! Provalo online!

R - 23

Possiamo usare la intToBinfunzione dal R.utilspacchetto:

R.utils::intToBin(0:10)

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

C, 75 68 69 byte

Approccio 1: 75 73 74 byte

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

Provalo online!

Approccio 2: 68 69 byte

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

Provalo online!

Python 2, 44 byte

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

Questo utilizza la zfillfunzione che funziona come rjustse non fosse sempre paddy in 0modo da non sprecare byte su un argomento.

Pyke, 8 byte

TFw0+b2t

Provalo qui!

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

Anche 8 byte:

TF 4@b2t

Provalo qui!

   4@    - set_bit(4, i)

Pyth - 8 7 byte

<5^_`T4

Provalo online qui .

impilato , 30 byte

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

Provalo online!

11:>è un intervallo da 0a 10. Il resto è piuttosto autoesplicativo.

Altre soluzioni che ho trovato:

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

Rubino, 38 byte

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

BF , 134 byte

Sono sicuro che questo può essere abbreviato - è praticamente il mio primo golf BF.

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

Provalo online! Presuppone un nastro infinito in entrambe le direzioni, come usa l'interprete di TIO. Un interprete in cui <all'estremità sinistra del nastro è presente un no-op salverebbe tre byte.

Spiegazione

Più della metà del codice (i primi 77 byte, per essere precisi) viene impiegata per inizializzare il nastro. I passaggi vanno così:

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

Le celle inizializzate per 1memorizzare i bit del nostro numero più 1: 1rappresenta un bit zero e2 rappresenta uno.

La fase di inizializzazione si è conclusa con il puntatore sul 11. Ora usiamo questa cella per eseguire 11 iterazioni del nostro 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
]