Tantangan ini adalah menampilkan ke terminal Anda, jendela, kanvas atau menyaring angka-angka nol hingga 10 inklusif. Setiap angka yang dikeluarkan harus ditampilkan sebagai 4-bit lebar, jadi nol harus ditampilkan seperti 0000dan seterusnya.

Anda dapat memisahkan setiap angka yang dihasilkan dengan spasi, koma, atau carriage return. Solusi terkecil menang tetapi angka dapat ditampilkan dalam urutan yang Anda suka selama tidak ada angka berulang dalam urutan Anda.

Entri dalam bahasa biner tingkat rendah tidak perlu khawatir tentang koma atau pemisah ruang putih jika tidak mungkin untuk menghasilkan dengan koma atau spasi putih (yaitu, output standar terbatas hanya untuk biner, atau solusi Anda adalah untuk kit komputer awal seperti KIM-1 yang memiliki tampilan digital terbatas).

SmileBASIC, 26 byte

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

MATL , 6 byte

0:10YB

Cobalah di MATL Online

Penjelasan

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

Cobalah online!

JavaScript, 46 byte

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

Mengapa menggunakan fungsi padding ketika Anda bisa menambahkan 16 ke setiap nomor dan memotong digit biner pertama?

Japt , 7 byte

GôA,_¤Å

Dan di sini saya berpikir Japt ditakdirkan lebih lama dari setiap bahasa golf lainnya ...

Uji secara online!

Penjelasan

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

Biasanya koma dapat dihapus di Japt, tetapi yang ini ada karena bug: _biasanya berarti function(Z){Z, tetapi karena alasan tertentu kompiler berpikir A_berarti function(A,Z){Z.

Utilitas Bash + GNU, 26

• 4 byte disimpan berkat @Dennis

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

Cobalah online .

Utilitas Bash + Unix, 29 26 byte

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

Cobalah online!

Panjangnya sama dengan solusi @ DigitalTrauma / @ Dennis, tetapi menggunakan metode yang sama sekali berbeda.

Output adalah:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Pesanan apa pun diizinkan.)

Bash Murni , 34 byte

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

Coba versi Bash murni secara online!

Output adalah:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 byte

#:i.11

Terima kasih banyak untuk memotongnya menjadi 6 byte!

Jelly , 7 byte

2Bṗ4ṫ6Y

Cobalah online!

(5 byte jika mengikuti garis-garis dari nybbles diperbolehkan, 2Bṗ4Y)

Bagaimana?

Mencetak dalam urutan menurun.

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

Alternatif 7-byter adalah 2ṗ4Ịṫ6Y, [1,0]diganti dengan [1,2]dan Ịadalah "tidak signifikan" monad ( abs(z)<=1), mengubah 2s ke 0s.

Python 3.6, 36 35 byte

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

-1 byte terima kasih kepada @JonathanAllan

Python 3.5 dan sebelumnya:

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

Cobalah online!

PHP, 33 byte

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

CJam , 12 byte

B{G+2b1>}%N*

Cobalah online!

Penjelasan

Pendekatan kekuatan Cartesian akan menjadi pilihan saya, tetapi sudah diambil.

Jadi ini menghasilkan angka dari 0 hingga 10, dan untuk masing-masing itu menambah 16 dan mengubahnya menjadi biner. Menambahkan 16 memastikan bahwa nol terkemuka yang diperlukan diproduksi, bersama dengan yang memimpin tambahan yang dihapus.

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 / Oktaf, 13 byte

dec2bin(0:10)

Demo online

Jelly , 10, 9 , 8 byte

⁴r26BḊ€Y

Cobalah online!

Aku tidak terlalu jeli, jadi aku akan terbuka untuk tips apa pun!

Ini menggunakan algoritma pertama Emigna

Terima kasih kepada Dennis karena telah memotong dua byte membuat saya mengikat jawabannya sendiri. : P

Penjelasan:

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

Terima kasih kepada @DJMcMayhem untuk bermain golf 2 byte!

Cobalah online!

Jelly , 8 byte

2Ḷṗ4ḣ11Y

Cobalah online!

Bagaimana itu bekerja

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

Ini sudah sangat modifikasi yang baik untuk menambahkan padfungsi. Keseluruhan dari]L4\-'0'\m\. , lebih dari setengah kode, adalah untuk pad.

_Simpan 6 byte, terima kasih @ETHProductions , itulah fungsi pad yang terpotong dua.

Dijelaskan

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

Cobalah online!

Retina , 36 33 byte

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

Cobalah online!

Penjelasan

%%%%

Ganti input kosong (tidak ada) dengan %%%%.

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

Pada jalankan pertama tahap ini, itu akan cocok ^%dan pada dasarnya mengganti teks %%%%dengan dua baris 0%%%dan 1%%%. Tahap akan berulang sampai output berhenti berubah. Pada run kedua, itu akan cocok \b%(karena digit dihitung sebagai karakter kata dan %tidak), dan mengganti grup dengan menduplikasi mereka dan menambahkan 0ke satu salinan dan 1ke yang lain: 0%%%menjadi garis 00%%dan 01%%(dan hal yang sama untuk 1%%%). Melalui loop ini semua 16 bitstring akan diproduksi, dipisahkan oleh linefeed.

11!`\d+

11 pertandingan pertama dari \d+(jangka minimal 1 digit) diambil. Kecocokan adalah output dalam daftar yang dipisahkan dengan linefeed.

Ruby, 25 byte

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

BF, 121 101 byte

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

Membutuhkan baris baru. Manfaatkan !simbol (jadi, centang kotak yang mengatakan !) dengan juru bahasa ini (coba online!) .

Berpotensi 51 byte jika setiap operator dianggap 4 bit

C #, 96 byte

Golf

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

Tidak disatukan

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

Kode lengkap

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

Rilis

• v1.0 - 96 bytes- Solusi awal.

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

Versi tidak disatukan:

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

Pasti bisa dipersingkat !?

@Ahemone Ide luar biasa, Terima kasih!

Harus bekerja sekarang! Cobalah online!

R - 23

Kita dapat menggunakan intToBinfungsi dari R.utilspaket:

R.utils::intToBin(0:10)

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

C, 75 68 69 byte

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

Cobalah online!

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

Cobalah online!

Python 2, 44 byte

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

Ini menggunakan zfillfungsi yang berfungsi seperti rjustkecuali selalu padds 0sehingga Anda tidak membuang byte pada argumen.

Pyke, 8 byte

TFw0+b2t

Coba di sini!

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

Juga 8 byte:

TF 4@b2t

Coba di sini!

   4@    - set_bit(4, i)

Pyth - 8 7 byte

<5^_`T4

Cobalah online di sini .

ditumpuk , 30 byte

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

Cobalah online!

11:>berkisar dari 0hingga10 . Sisanya agak jelas.

Solusi lain yang saya temukan:

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

Saya yakin ini bisa dipersingkat - ini cukup banyak golf BF pertama saya.

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

Cobalah online!Mengasumsikan rekaman tak terbatas di kedua arah, seperti juru bahasa yang digunakan TIO. Seorang juru bahasa di mana< di di ujung kiri pita adalah no-op akan menghemat tiga byte.

Penjelasan

Lebih dari setengah kode (77 byte pertama, tepatnya) dihabiskan untuk menginisialisasi rekaman. Langkah-langkahnya seperti ini:

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

Sel yang diinisialisasi untuk 1menyimpan bit nomor kita ditambah 1: 1mewakili bit nol dan2 mewakili bit satu.

Fase inisialisasi berakhir dengan pointer pada 11. Sekarang kita menggunakan sel ini untuk menjalankan 11 iterasi dari loop kita:

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