Wyzwanie polega na wyświetleniu na terminalu, oknie, kanwie lub ekranie liczb od zera do 10 włącznie. Każda wyprowadzona liczba musi być pokazana jako 4-bitowa nibble, więc zero musi być pokazane jako 0000i tak dalej.

Możesz oddzielić każdą wyprowadzoną liczbę spacją, przecinkiem lub znakiem powrotu karetki. Najmniejsze rozwiązanie wygrywa, ale liczby mogą być wyświetlane w dowolnej kolejności, pod warunkiem, że w sekwencji nie ma powtarzających się liczb.

Wpisy w niskopoziomowych językach binarnych nie muszą martwić się o separatory przecinków lub białych znaków, jeśli nie można wyprowadzać przecinków lub białych znaków (tzn. Standardowe wyjście jest ograniczone tylko do plików binarnych lub twoje rozwiązanie jest dla wczesnego zestawu komputerowego takich jak KIM-1, który ma ograniczony wyświetlacz cyfrowy).

SmileBASIC, 26 bajtów

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

MATL , 6 bajtów

0:10YB

Wypróbuj w MATL Online

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

JavaScript, 46 bajtów

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

Po co korzystać z funkcji wypełniania, gdy można po prostu dodać 16 do każdej liczby i wyciąć pierwszą cyfrę binarną?

Japt , 7 bajtów

GôA,_¤Å

I tutaj myślałem, że Japt jest skazany na dłuższe niż każdy inny język golfowy ...

Przetestuj online!

Wyjaśnienie

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

Zwykle przecinki można usunąć w Japt, ale ten jest tam z powodu błędu: _zwykle oznacza function(Z){Z, ale z jakiegoś powodu kompilator myśli, że A_znaczy function(A,Z){Z.

Narzędzia Bash + GNU, 26

• 4 bajty zapisane dzięki @Dennis

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

Wypróbuj online .

Narzędzia Bash + Unix, 29 26 bajtów

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

Wypróbuj online!

Jest to ta sama długość co rozwiązanie @ DigitalTrauma / @ Dennis, ale używa zupełnie innej metody.

Dane wyjściowe to:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Każde zamówienie jest dozwolone.)

Pure Bash , 34 bajty

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

Wypróbuj czystą wersję Bash online!

Dane wyjściowe to:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 bajtów

#:i.11

Dzięki milom za zmniejszenie go do 6 bajtów!

Galaretka , 7 bajtów

2Bṗ4ṫ6Y

Wypróbuj online!

(5 bajtów, jeśli dozwolone są końcowe linie nybbles 2Bṗ4Y),

W jaki sposób?

Drukuje w kolejności malejącej.

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

Alternatywnym 7 byter jest 2ṗ4Ịṫ6YThe [1,0]zastępuje się [1,2]i Ịjest „nie ma znaczenia” monada ( abs(z)<=1), konwersja 2s na 0sekundę.

Python 3.6, 36 35 bajtów

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

-1 bajt dzięki @JonathanAllan

Python 3.5 i wcześniejsze:

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

Wypróbuj online!

PHP, 33 bajty

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

CJam , 12 bajtów

B{G+2b1>}%N*

Wypróbuj online!

Wyjaśnienie

Podejście kartezjańskie do władzy byłoby moim wyborem, ale zostało już podjęte.

To generuje liczby od 0 do 10, a dla każdego dodaje 16 i konwertuje na binarne. Dodanie 16 zapewnia wygenerowanie wymaganych zer wiodących wraz z dodatkowym wiodącym zeriem, który jest usuwany.

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 / oktawa, 13 bajtów

dec2bin(0:10)

Demo online

Galaretka , 10, 9 , 8 bajtów

⁴r26BḊ€Y

Wypróbuj online!

Nie jestem taka świetna w galaretce, więc byłbym otwarty na wszelkie wskazówki!

Wykorzystuje pierwszy algorytm Emigny

Dziękuję Dennisowi za wygolenie dwóch bajtów, co skłoniło mnie do związania własnej odpowiedzi. : P

Wyjaśnienie:

      Ḋ€    # 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 bajtów

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

Dzięki @DJMcMayhem za grę w golfa z 2 bajtów!

Wypróbuj online!

Galaretka , 8 bajtów

2Ḷṗ4ḣ11Y

Wypróbuj online!

Jak to działa

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 bajtów

~16.aL1{2B26q}:

To była bardzo dobra modyfikacja dodania padfunkcji. Całość ]L4\-'0'\m\.ponad połowę kodu jest podkładki.

_Oszczędność 6 bajtów dzięki @ETHProductions , to funkcja pad przecięta na pół.

Wyjaśniono

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

Wypróbuj online!

Siatkówka , 36 33 bajtów

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

Wypróbuj online!

Wyjaśnienie

%%%%

Zamień puste (nieistniejące) wejście na %%%%.

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

Przy pierwszym uruchomieniu tego etapu dopasuje ^%i zasadniczo zastąpi tekst %%%%dwoma liniami 0%%%i 1%%%. Scena będzie się zapętlać, aż wyjście przestanie się zmieniać. Przy drugim uruchomieniu dopasuje się \b%(ponieważ cyfry liczą się jako znaki słowne, a %nie), i zastąpi grupy, kopiując je i dodając 0do jednej kopii i 1do drugiej: 0%%%staje się liniami 00%%i 01%%(i to samo dla 1%%%). Poprzez tę pętlę zostanie wygenerowanych wszystkie 16 ciągów bitów, oddzielonych od linii.

11!`\d+

Pobieranych jest pierwsze 11 dopasowań \d+(serii co najmniej 1 cyfry). Dopasowania są wyprowadzane na liście oddzielonej od linii.

Rubin, 25 bajtów

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

BF, 121 101 bajtów

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

Wymaga końca nowej linii. Używa !symbolu (więc zaznacz pole z napisem !) w tym tłumaczu (spróbuj online!) .

Potencjalnie 51 bajtów, jeśli każdy operator był uważany za 4 bity

C #, 96 bajtów

Grał w golfa

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

Nie golfił

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

Pełny kod

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

Prasowe

• v1.0 - 96 bytes- Wstępne rozwiązanie.

C 170 120 bajtów

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

Wersja bez golfa:

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

Zdecydowanie można go skrócić !?

@Ahemone Świetny pomysł, dzięki!

Powinien działać teraz! Wypróbuj online!

R - 23

Możemy użyć intToBinfunkcji z R.utilspakietu:

R.utils::intToBin(0:10)

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

C, 75 68 69 bajtów

Podejście 1: 75 73 74 bajty

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

Wypróbuj online!

Podejście 2: 68 69 bajtów

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

Wypróbuj online!

Python 2, 44 bajty

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

Korzysta z zfillfunkcji, która działa podobnie, rjustz tym, że zawsze jest to padds, 0dzięki czemu nie marnujesz bajtów na argument.

Pyke, 8 bajtów

TFw0+b2t

Wypróbuj tutaj!

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

Również 8 bajtów:

TF 4@b2t

Wypróbuj tutaj!

   4@    - set_bit(4, i)

Pyth - 8 7 bajtów

<5^_`T4

Wypróbuj online tutaj .

ułożone w stos , 30 bajtów

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

Wypróbuj online!

11:>jest w zakresie od 0do 10. Reszta jest raczej oczywista.

Inne rozwiązania, które znalazłem:

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

Rubinowy, 38 bajtów

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

BF , 134 bajty

Jestem pewien, że można to skrócić - to właściwie mój pierwszy golf BF.

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

Wypróbuj online! Zakłada, że ​​taśma jest nieskończona w obu kierunkach, podobnie jak interpreter w TIO. Tłumacz, w którym <na lewym końcu taśmy nie ma operacji, oszczędziłby trzy bajty.

Wyjaśnienie

Ponad połowa kodu (dokładnie 77 pierwszych bajtów) jest wydawana na inicjalizację taśmy. Kroki są następujące:

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

Komórki zainicjowano na 1 przechowywania bitów naszej liczby plus 1: 1reprezentuje bit zerowy i2 reprezentuje jeden bit.

Faza inicjalizacji zakończyła się wskaźnikiem na 11. Teraz używamy tej komórki do uruchomienia 11 iteracji naszej pętli:

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