Thách thức này là xuất ra thiết bị đầu cuối, cửa sổ, khung vẽ hoặc sàng lọc các số từ 0 đến 10. Mỗi số xuất ra phải được hiển thị dưới dạng một nybble rộng 4 bit, do đó, số 0 phải hiển thị như 0000vậy.

Bạn có thể tách từng số được xuất ra bằng dấu cách, dấu phẩy hoặc giá đỡ. Giải pháp nhỏ nhất sẽ thắng nhưng các số có thể được hiển thị theo bất kỳ thứ tự nào bạn muốn miễn là không có số lặp lại trong chuỗi của bạn.

Các mục nhập trong ngôn ngữ nhị phân cấp thấp không cần phải lo lắng về dấu phân cách dấu phẩy hoặc khoảng trắng nếu không thể xuất bằng dấu phẩy hoặc khoảng trắng (nghĩa là đầu ra tiêu chuẩn chỉ giới hạn ở dạng nhị phân hoặc giải pháp của bạn dành cho bộ máy tính sớm chẳng hạn như KIM-1 có màn hình kỹ thuật số hạn chế).

SmileBASIC, 26 byte

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

MATL , 6 byte

0:10YB

Dùng thử tại MATL Online

Giải trình

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

Hãy thử trực tuyến!

JavaScript, 46 byte

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

Tại sao nên sử dụng chức năng đệm khi bạn chỉ cần thêm 16 vào mỗi số và cắt đi chữ số nhị phân đầu tiên?

Japt , 7 byte

GôA,_¤Å

Và ở đây, tôi đã nghĩ rằng Japt đã bị tiêu diệt lâu hơn mọi ngôn ngữ chơi gôn khác ...

Kiểm tra nó trực tuyến!

Giải trình

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

Thông thường dấu phẩy có thể được loại bỏ trong Japt, nhưng cái này tồn tại vì một lỗi: _thông thường có nghĩa là function(Z){Z, nhưng vì một số lý do mà trình biên dịch nghĩ A_là có nghĩa function(A,Z){Z.

Đồ dùng Bash + GNU, 26

• 4 byte được lưu nhờ @Dennis

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

Hãy thử trực tuyến .

Tiện ích Bash + Unix, 29 26 byte

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

Hãy thử trực tuyến!

Đây là cùng độ dài với giải pháp của @ DigitalTrauma / @ Dennis, nhưng sử dụng một phương pháp hoàn toàn khác.

Đầu ra là:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Mọi đơn hàng đều được cho phép.)

Bash thuần túy , 34 byte

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

Hãy thử phiên bản Bash thuần trực tuyến!

Đầu ra là:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 byte

#:i.11

Nhờ dặm để cắt nó xuống đến 6 byte!

Thạch , 7 byte

2Bṗ4ṫ6Y

Hãy thử trực tuyến!

(5 byte nếu cho phép các dòng nybble trailing, 2Bṗ4Y)

Làm sao?

In theo thứ tự giảm dần.

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

Một 7 -terter thay thế là 2ṗ4Ịṫ6Y, [1,0]được thay thế bằng [1,2]và Ịlà đơn vị "không đáng kể" abs(z)<=1, chuyển đổi 2s thành 0s.

Python 3.6, 36 35 byte

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

-1 byte nhờ @Jonathan ALLan

Python 3.5 trở về trước:

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

Hãy thử trực tuyến!

PHP, 33 byte

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

CJam , 12 byte

B{G+2b1>}%N*

Hãy thử trực tuyến!

Giải trình

Cách tiếp cận quyền lực của Cartesian sẽ là lựa chọn của tôi, nhưng đã được thực hiện.

Vì vậy, điều này tạo ra các số từ 0 đến 10, và với mỗi số đó thêm 16 và chuyển đổi thành nhị phân. Thêm 16 đảm bảo rằng các số 0 đứng đầu được yêu cầu được tạo ra, cùng với một số 0 đứng đầu được loại bỏ.

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 trực tuyến

Jelly , 10, 9 , 8 byte

⁴r26BḊ€Y

Hãy thử trực tuyến!

Tôi không giỏi về thạch, vì vậy tôi sẽ cởi mở với bất kỳ lời khuyên nào!

Điều này sử dụng thuật toán đầu tiên của Emigna

Cảm ơn Dennis vì đã cạo sạch hai byte khiến tôi buộc lại câu trả lời của mình. : P

Giải trình:

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

Cảm ơn @DJMcMayhem vì đã chơi golf 2 byte!

Hãy thử trực tuyến!

Thạch , 8 byte

2Ḷṗ4ḣ11Y

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đây là một sửa đổi rất tốt để thêm một padchức năng. Toàn bộ]L4\-'0'\m\. , hơn một nửa mã, là để đệm.

_Save 6 byte nhờ @ETH Productstions , đó là chức năng pad giảm một nửa.

Giải thích

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

Hãy thử trực tuyến!

Võng mạc , 36 33 byte

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

Hãy thử trực tuyến!

Giải trình

%%%%

Thay thế đầu vào trống (không tồn tại) bằng %%%%.

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

Trong lần chạy đầu tiên của giai đoạn này, nó sẽ khớp ^%và về cơ bản thay thế văn bản %%%%bằng hai dòng 0%%%và 1%%%. Giai đoạn sẽ lặp cho đến khi đầu ra ngừng thay đổi. Trong lần chạy thứ hai, nó sẽ khớp \b%(vì các chữ số được tính là ký tự từ và %không) và thay thế các nhóm bằng cách sao chép chúng và thêm 0vào một bản sao và một bản sao 1khác: 0%%%trở thành các dòng 00%%và01%% (và cùng một loại cho 1%%%). Thông qua vòng lặp này, tất cả 16 bitstrings sẽ được tạo ra, tách dòng.

11!`\d+

11 trận đấu đầu tiên của \d+(một lần chạy ít nhất 1 chữ số) được lấy ra. Các kết quả khớp được xuất ra trong một danh sách được phân tách theo dòng.

Ruby, 25 byte

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

BF, 121 101 byte

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

Yêu cầu một dòng mới. Làm cho việc sử dụng !ký hiệu (vì vậy, hãy chọn hộp có ghi !) với trình thông dịch này (thử trực tuyến!) .

Có khả năng 51 byte nếu mỗi toán tử được coi là 4 bit

C #, 96 byte

Chơi gôn

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

Bị đánh cắp

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

Mã đầy đủ

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

Phát hành

• v1.0 - 96 bytes- Giải pháp ban đầu.

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

Phiên bản bị đánh cắp:

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

Chắc chắn có thể rút ngắn!?

@Ahemone Ý tưởng tuyệt vời, Cảm ơn!

Nên làm việc ngay! Hãy thử trực tuyến!

R - 23

Chúng ta có thể sử dụng intToBinchức năng từ R.utilsgói:

R.utils::intToBin(0:10)

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

C, 75 68 69 byte

Cách tiếp cận 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);}

Hãy thử trực tuyến!

Cách tiếp cận 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);}

Hãy thử trực tuyến!

Python 2, 44 byte

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

Điều này sử dụng zfillchức năng hoạt động như rjustngoại trừ nó luôn luôn đệm 0để bạn không lãng phí byte cho một đối số.

Pyke, 8 byte

TFw0+b2t

Hãy thử nó ở đây!

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

Ngoài ra 8 byte:

TF 4@b2t

Hãy thử nó ở đây!

   4@    - set_bit(4, i)

Pyth - 8 7 byte

<5^_`T4

Hãy thử trực tuyến tại đây .

xếp chồng lên nhau , 30 byte

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

Hãy thử trực tuyến!

11:> là một phạm vi từ 0 đến 10. Phần còn lại là khá tự giải thích.

Các giải pháp khác mà tôi đã tìm thấy:

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 byte

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

BF , 134 byte

Tôi chắc chắn điều này có thể rút ngắn - nó khá nhiều golf BF đầu tiên của tôi.

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

Hãy thử trực tuyến! Giả sử một băng vô hạn theo cả hai hướng, giống như trình thông dịch tại TIO sử dụng. Một thông dịch viên< ở đầu bên trái của băng là một no-op sẽ lưu ba byte.

Giải trình

Hơn một nửa mã (chính xác là 77 byte đầu tiên) được dành để khởi tạo băng. Các bước đi như thế này:

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

Các ô được khởi tạo để 1lưu trữ các bit của số của chúng tôi cộng với 1: 1đại diện cho một bit 0 và2 đại diện cho một bit.

Giai đoạn khởi tạo kết thúc với con trỏ trên 11. Bây giờ chúng tôi sử dụng ô này để chạy 11 lần lặp của vòng lặp:

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