ความท้าทายนี้คือการส่งออกไปยังอาคาร, หน้าต่าง, ผ้าใบหรือหน้าจอตัวเลขรวมถึง 10 แต่ละตัวเลขที่ส่งออกจะต้องแสดงเป็น nybble ที่มีความกว้าง 4 บิตดังนั้นศูนย์จะต้องแสดงเป็น0000เป็นต้น

คุณสามารถแยกแต่ละหมายเลขที่ส่งออกด้วยช่องว่างเครื่องหมายจุลภาคหรือการขึ้นบรรทัดใหม่ ทางออกที่เล็กที่สุดชนะ แต่ตัวเลขสามารถแสดงในลำดับใดก็ได้ที่คุณต้องการตราบใดที่ไม่มีหมายเลขซ้ำในลำดับของคุณ

รายการในภาษาไบนารีระดับต่ำไม่จำเป็นต้องกังวลเกี่ยวกับตัวคั่นช่องว่างหรือเครื่องหมายจุลภาคถ้ามันเป็นไปไม่ได้ที่จะส่งออกด้วยเครื่องหมายจุลภาคหรือช่องว่างสีขาว (เช่นเอาท์พุทมาตรฐานถูก จำกัด ไว้ที่ไบนารีเท่านั้นหรือโซลูชั่นของคุณ เช่นKIM-1ซึ่งมีจอแสดงผลดิจิตอล จำกัด )

SmileBASIC ขนาด 26 ไบต์

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

MATL , 6 ไบต์

0:10YB

ลองใช้ที่MATL Online

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

JavaScript ขนาด 46 ไบต์

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

ทำไมต้องใช้ฟังก์ชั่นการเติมเมื่อคุณสามารถเพิ่ม 16 ลงในแต่ละหมายเลขแล้วตัดเลขฐานสองแรก

Japtap , 7 ไบต์

GôA,_¤Å

และที่นี่ฉันคิดว่า Japtive จะต้องนานกว่าภาษากอล์ฟอื่น ๆ ...

ทดสอบออนไลน์!

คำอธิบาย

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

จุลภาคปกติสามารถลบออกได้ใน Japt แต่คนนี้เป็นเพราะมีข้อผิดพลาด: _ปกติหมายถึงfunction(Z){Zแต่ด้วยเหตุผลบางคอมไพเลอร์คิดว่าหมายถึงA_function(A,Z){Z

Bash + GNU utils, 26

• บันทึกได้ 4 ไบต์ด้วย @Dennis

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

ลองมันออนไลน์

ยูทิลิตีBash + Unix ขนาด29 26 ไบต์

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

ลองออนไลน์!

นี่คือความยาวเท่ากันกับโซลูชันของ @ DigitalTrauma / @ Dennis แต่ใช้วิธีการที่แตกต่างอย่างสิ้นเชิง

ผลลัพธ์คือ:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(คำสั่งใดก็ได้ที่ได้รับอนุญาต)

Pure Bashขนาด 34 ไบต์

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

ลองใช้เวอร์ชั่นทุบตีออนไลน์!

ผลลัพธ์คือ:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 ไบต์

#:i.11

ขอบคุณไมล์ที่ลดลงเหลือ 6 ไบต์!

เยลลี่ขนาด 7 ไบต์

2Bṗ4ṫ6Y

ลองออนไลน์!

(5 ไบต์ถ้าอนุญาตให้ลากเส้น nybbles ได้2Bṗ4Y)

อย่างไร?

พิมพ์ตามลำดับจากมากไปน้อย

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

ทางเลือก 7-byter คือ2ṗ4Ịṫ6Y, [1,0]จะถูกแทนที่ด้วย[1,2]และỊคือ "ไม่สำคัญ" monad ( abs(z)<=1), การแปลง2s เป็น0s

Python 3.6, 36 35 bytes

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

-1 ไบต์ขอบคุณ @JonathanAllan

Python 3.5 และรุ่นก่อนหน้า:

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

ลองออนไลน์!

PHP, 33 ไบต์

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

CJam , 12 ไบต์

B{G+2b1>}%N*

ลองออนไลน์!

คำอธิบาย

วิธีการใช้พลังงานแบบคาร์ทีเซียนจะเป็นทางเลือกของฉัน แต่ถูกใช้ไปแล้ว

นี่จะสร้างตัวเลขจาก 0 ถึง 10 และสำหรับแต่ละอันจะเพิ่ม 16 และแปลงเป็นเลขฐานสอง การเพิ่ม 16 ทำให้แน่ใจว่าเลขศูนย์นำที่ต้องการถูกสร้างขึ้นพร้อมกับส่วนนำพิเศษที่ถูกลบออก

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 ไบต์

dec2bin(0:10)

การสาธิตออนไลน์

เยลลี่ , 10, 9 , 8 ไบต์

⁴r26BḊ€Y

ลองออนไลน์!

ฉันไม่ค่อยเก่งเท่าเยลลี่ดังนั้นฉันจะเปิดรับเคล็ดลับใด ๆ !

สิ่งนี้ใช้อัลกอริทึมแรกของ Emigna

ขอบคุณเดนนิสที่โกนหนวดสองไบต์ทำให้ฉันผูกคำตอบของเขาเอง : P

คำอธิบาย:

      Ḋ€    # 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 ไบต์

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

ขอบคุณ @DJMcMayhem สำหรับการเล่นกอล์ฟ 2 ไบท์!

ลองออนไลน์!

เยลลี่ขนาด 8 ไบต์

2Ḷṗ4ḣ11Y

ลองออนไลน์!

มันทำงานอย่างไร

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 ไบต์

~16.aL1{2B26q}:

นี่เป็นการปรับปรุงที่ดีมากในการเพิ่มpadฟังก์ชั่น ความสมบูรณ์ของ]L4\-'0'\m\.โค้ดมากกว่าครึ่งหนึ่งคือการแพด

_Saved 6 ไบต์ขอบคุณ@ETHProductionsนั่นคือฟังก์ชั่นแผ่นรองครึ่งหนึ่ง

อธิบาย

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

ลองออนไลน์!

เรติน่า36 36ไบต์

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

ลองออนไลน์!

คำอธิบาย

%%%%

แทนที่ว่างเปล่า (ไม่มีอยู่จริง) %%%%การป้อนข้อมูลด้วย

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

ในระยะแรกของขั้นตอนนี้มันจะจับคู่^%และแทนที่ข้อความ%%%%ด้วยสองบรรทัด0%%%และเป็น1%%%หลัก สเตจจะวนซ้ำจนกว่าเอาต์พุตจะหยุดการเปลี่ยนแปลง ในการรันครั้งที่สองมันจะจับคู่\b%(เนื่องจากตัวเลขนับเป็นตัวอักษรของคำและ%ไม่ได้) และแทนที่กลุ่มด้วยการทำซ้ำและเพิ่ม0ลงในหนึ่งสำเนาและ1อีกอัน: 0%%%กลายเป็นเส้น00%%และ01%%(และเรียงลำดับเดียวกันสำหรับ1%%%) ผ่านห่วงนี้ 16 บิตจะถูกสร้างขึ้นบรรทัดแยกออกจากกัน

11!`\d+

11 การแข่งขันครั้งแรกของ\d+(เรียกใช้อย่างน้อย 1 หลัก) จะถูกดึง การจับคู่จะถูกส่งออกในรายการที่แยกบรรทัด

Ruby, 25 ไบต์

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

BF, 121 101 ไบต์

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

ต้องขึ้นบรรทัดใหม่ต่อท้าย ทำให้การใช้!สัญลักษณ์ (เพื่อตรวจสอบกล่องที่ระบุว่า!) มีล่ามนี้ (ลองออนไลน์!)

อาจเป็น 51 ไบต์หากตัวดำเนินการแต่ละตัวถูกพิจารณาเป็น 4 บิต

C #, 96 ไบต์

แข็งแรงเล่นกอล์ฟ

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

รหัสเต็ม

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

ข่าว

• v1.0 - 96 bytes- โซลูชั่นเริ่มต้น

C 170 120 ไบต์

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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

จะสั้นลงอย่างแน่นอน!

@Ahemone ความคิดที่น่ากลัวขอบคุณ!

ควรทำงานตอนนี้! ลองออนไลน์!

R - 23

เราสามารถใช้intToBinฟังก์ชั่นจากR.utilsแพ็คเกจ:

R.utils::intToBin(0:10)

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

C, 75 68 69 ไบต์

วิธีที่ 1: 75 73 74ไบต์

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

ลองออนไลน์!

วิธีที่ 2: 68 69 ไบต์

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

ลองออนไลน์!

Python 2, 44 ไบต์

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

zfillฟังก์ชั่นนี้ใช้ฟังก์ชั่นที่ใช้งานได้ดีrjustยกเว้นว่ามันจะเต็มไปด้วย0ดังนั้นคุณจึงไม่ต้องเสียไบต์ในการโต้แย้ง

Pyke 8 ไบต์

TFw0+b2t

ลองที่นี่!

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

8 ไบต์ด้วย:

TF 4@b2t

ลองที่นี่!

   4@    - set_bit(4, i)

Pyth - 8 7 ไบต์

<5^_`T4

ลองมันออนไลน์ได้ที่นี่

ซ้อนกัน 30 ไบต์

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

ลองออนไลน์!

11:>เป็นช่วงที่จากไป0 10ที่เหลือค่อนข้างอธิบายตนเอง

โซลูชันอื่น ๆ ที่ฉันได้พบ:

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 ไบต์

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

BF , 134 ไบต์

ฉันแน่ใจว่านี่จะสั้นลงได้ - มันเป็นสนามกอล์ฟ BF แรกของฉัน

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

ลองออนไลน์! ถือว่าไม่มีที่สิ้นสุดเทปในทั้งสองทิศทางเช่นล่ามที่ TIO ใช้ ล่ามโดย<ที่ปลายด้านซ้ายของเทปไม่มีตัวเลือกจะบันทึกสามไบต์

คำอธิบาย

มากกว่าครึ่งหนึ่งของรหัส (77 ไบต์แรกเพื่อความแม่นยำ) ใช้ในการเริ่มต้นเทป ขั้นตอนเป็นดังนี้:

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

เซลล์เริ่มต้นเพื่อ1จัดเก็บบิตของจำนวนของเราบวก 1: 1หมายถึงศูนย์บิตและ2หมายถึงหนึ่งบิต

11ขั้นตอนการเริ่มต้นจบลงด้วยการชี้บนที่ ตอนนี้เราใช้เซลล์นี้เพื่อเรียกใช้การวนซ้ำ 11 ครั้งของเรา:

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