Diese Herausforderung besteht darin, die Zahlen 0 bis 10 (einschließlich) auf Ihrem Terminal, Fenster, Canvas oder Bildschirm auszugeben. Jede ausgegebene Zahl muss als 4 Bit breites Nybble angezeigt werden, daher muss Null als 0000und so weiter angezeigt werden .

Sie können jede ausgegebene Zahl durch ein Leerzeichen, ein Komma oder einen Wagenrücklauf trennen. Die kleinste Lösung gewinnt, aber die Zahlen können in beliebiger Reihenfolge angezeigt werden, solange Ihre Sequenz keine sich wiederholenden Zahlen enthält.

Einträge in einfachen Binärsprachen müssen sich nicht um Kommas oder Leerzeichen kümmern, wenn keine Ausgabe mit Kommas oder Leerzeichen möglich ist (dh die Standardausgabe ist nur auf Binär beschränkt oder Ihre Lösung ist für ein frühes Computer-Kit wie das KIM-1, das eine begrenzte Digitalanzeige hat).

SmileBASIC, 26 Bytes

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

MATL , 6 Bytes

0:10YB

Probieren Sie es bei MATL Online aus

Erläuterung

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

Probieren Sie es online!

JavaScript, 46 Bytes

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

Warum sollten Sie eine Auffüllfunktion verwenden, wenn Sie jeder Zahl einfach 16 hinzufügen und die erste Binärziffer abschneiden können?

Japt , 7 Bytes

GôA,_¤Å

Und hier dachte ich, dass Japt zum Scheitern verurteilt ist, länger zu sein als jede andere Golfsprache ...

Testen Sie es online!

Erläuterung

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

Normalerweise können Kommas in Japt entfernt werden, aber dieses ist wegen eines Fehlers vorhanden: _Normalerweise bedeutet dies function(Z){Z, aber aus irgendeinem Grund denkt der Compiler, dass dies A_Mittel ist function(A,Z){Z.

Bash + GNU-Utils, 26

• 4 Bytes gespart dank @Dennis

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

Probieren Sie es online aus .

Bash + Unix-Dienstprogramme, 29 26 Bytes

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

Probieren Sie es online!

Dies entspricht der Länge von @ DigitalTrauma / @ Dennis, verwendet jedoch eine völlig andere Methode.

Ausgabe ist:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Jede Bestellung ist erlaubt.)

Pure Bash , 34 Bytes

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

Probieren Sie die reine Bash-Version online aus!

Ausgabe ist:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 Bytes

#:i.11

Dank Meilen für die Reduzierung auf 6 Bytes!

Gelee , 7 Bytes

2Bṗ4ṫ6Y

Probieren Sie es online!

(5 Bytes, wenn nachstehende Zeilen von Nybbles erlaubt sind 2Bṗ4Y)

Wie?

Druckt in absteigender Reihenfolge.

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

Ein alternativer 7-byter ist 2ṗ4Ịṫ6Y, die [1,0]ersetzt werden durch [1,2]und Ịist die „unbedeutend“ monadisch ( abs(z)<=1), Umwandeln 2s 0s.

Python 3.6, 36 35 Bytes

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

-1 Byte danke an @JonathanAllan

Python 3.5 und früher:

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

Probieren Sie es online!

PHP, 33 Bytes

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

CJam , 12 Bytes

B{G+2b1>}%N*

Probieren Sie es online!

Erläuterung

Der kartesische Machtansatz wäre meine Wahl gewesen, wurde aber bereits getroffen.

Dies generiert also Zahlen von 0 bis 10 und addiert für jede Zahl 16 und konvertiert sie in Binärdaten. Das Addieren von 16 stellt sicher, dass die erforderlichen führenden Nullen zusammen mit einer zusätzlichen führenden Null erzeugt werden, die entfernt wird.

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)

Online Demo

Jelly , 10, 9 , 8 Bytes

⁴r26BḊ€Y

Probieren Sie es online!

Ich bin nicht so gut in Gelee, also wäre ich offen für alle Tipps!

Hierbei wird der erste Algorithmus von Emigna verwendet

Vielen Dank an Dennis für das Abschneiden von zwei Bytes , die mich dazu gebracht haben, seine eigene Antwort zu finden. : P

Erläuterung:

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

Danke an @DJMcMayhem für das Golfen mit 2 Bytes!

Probieren Sie es online!

Gelee , 8 Bytes

2Ḷṗ4ḣ11Y

Probieren Sie es online!

Wie es funktioniert

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

Dies war eine sehr gute Modifikation, um eine padFunktion hinzuzufügen . Das Ganze ]L4\-'0'\m\., mehr als die Hälfte des Codes, ist aufzufüllen.

_Saved 6 Bytes dank @ETHProductions , das ist die Pad-Funktion halbiert.

Erklärt

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

Probieren Sie es online!

Retina , 36 33 Bytes

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

Probieren Sie es online!

Erläuterung

%%%%

Ersetzen Sie die leere (nicht vorhandene) Eingabe durch %%%%.

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

Beim ersten Durchlauf dieser Phase wird ^%der Text %%%%mit den beiden Zeilen 0%%%und abgeglichen und im Wesentlichen ersetzt 1%%%. Die Stufe wird wiederholt, bis sich der Ausgang nicht mehr ändert. Beim zweiten Durchlauf wird eine Übereinstimmung gefunden \b%(da Ziffern als Wortzeichen gelten und %nicht) und die Gruppen durch Duplizieren und Hinzufügen 0zu einer Kopie und 1zur anderen ersetzt: 0%%%werden die Zeilen 00%%und 01%%(und das Gleiche für 1%%%). Durch diese Schleife werden alle 16 Bitstrings zeilenweise getrennt erzeugt.

11!`\d+

Die ersten 11 Übereinstimmungen von \d+(ein Lauf mit mindestens einer Ziffer) werden abgerufen. Die Übereinstimmungen werden in einer durch Zeilenvorschub getrennten Liste ausgegeben.

Ruby, 25 Bytes

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

BF, 121 101 Bytes

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

Benötigt einen abschließenden Zeilenumbruch. Verwendet mit diesem Interpreter ein! Symbol (also kreuzen Sie das Kästchen an, das besagt !) (versuchen Sie es online!) .

Möglicherweise 51 Bytes, wenn jeder Operator als 4 Bits betrachtet wurde

96 Bytes

Golf gespielt

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

Vollständiger 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- Anfangslösung.

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

Kann definitiv gekürzt werden !?

@Ahemone Super Idee, danke!

Sollte jetzt funktionieren! Probieren Sie es online!

R - 23

Wir können intToBinfunktion aus dem R.utilspaket:

R.utils::intToBin(0:10)

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

C 75 68 69 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Python 2, 44 Bytes

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

Dabei wird die zfillFunktion verwendet, die wie rjustfolgt funktioniert: Es wird immer mit Pads aufgefüllt, 0sodass Sie keine Bytes für ein Argument verschwenden.

Pyke, 8 Bytes

TFw0+b2t

Probieren Sie es hier aus!

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

Auch 8 Bytes:

TF 4@b2t

Probieren Sie es hier aus!

   4@    - set_bit(4, i)

Pyth - 8 7 Bytes

<5^_`T4

Probieren Sie es hier online aus .

gestapelt , 30 Bytes

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

Probieren Sie es online!

11:>ist ein Bereich von 0bis 10. Der Rest ist eher selbsterklärend.

Andere Lösungen, die ich gefunden habe:

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

Ich bin mir sicher, dass dies verkürzt werden kann - es ist so ziemlich mein erstes BF-Golf.

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

Probieren Sie es online! Nimmt ein Band unendlich in beide Richtungen an, wie es der Interpreter bei TIO verwendet. Ein Dolmetscher wo< am linken Ende des Bandes ein No-Op steht, würde drei Bytes einsparen.

Erläuterung

Mehr als die Hälfte des Codes (um genau zu sein die ersten 77 Bytes) wird für die Initialisierung des Bandes aufgewendet. Die Schritte gehen so:

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

Die Zellen, die initialisiert wurden, 1um die Bits unserer Zahl plus 1 zu speichern: 1repräsentiert ein Nullbit und2 repräsentiert ein Einbit.

Die Initialisierungsphase endete mit dem Zeiger auf 11. Jetzt verwenden wir diese Zelle, um 11 Iterationen unserer Schleife auszuführen:

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