Bu zorluk, terminalinize, pencerenize, tuvalinize veya ekranınıza sıfırdan 10'a kadar sayıları dahil etmektir. Çıkarılan her sayı 4 bit genişliğinde bir nybble olarak gösterilmelidir, bu nedenle sıfır olarak gösterilmelidir 0000.

Çıkarılan her sayıyı boşluk, virgül veya satır başı ile ayırabilirsiniz. En küçük çözüm kazanır, ancak sıralamanızda yinelenen sayılar olmadığı sürece sayılar istediğiniz sırada görüntülenebilir.

Düşük düzeyli ikili dillerdeki girişlerin virgül veya beyaz boşluklarla çıktı alınması mümkün değilse (virgül veya beyaz boşluk ayırıcıları hakkında endişelenmenize gerek yoktur (örneğin, standart çıktı yalnızca ikili ile sınırlıdır veya çözümünüz erken bir bilgisayar kiti içindir) sınırlı bir dijital ekrana sahip olan KIM-1 gibi ).

SmileBASIC, 26 bayt

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

MATL , 6 bayt

0:10YB

Şurada deneyin: MATL Online'da

açıklama

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 bayt

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

Çevrimiçi deneyin!

JavaScript, 46 bayt

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

Her bir sayıya 16 ekleyip ilk ikili rakamı dilimleyebileceğiniz zaman neden bir dolgu işlevi kullanıyorsunuz?

Japt , 7 bayt

GôA,_¤Å

Burada Japt'un diğer tüm golf dillerinden daha uzun olmaya mahkum olduğunu düşünüyordum ...

Çevrimiçi test edin!

açıklama

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

Normalde virgüller Japt'ta kaldırılabilir, ancak bu bir hata nedeniyle oradadır: _normalde anlamına gelir function(Z){Z, ancak bir nedenle derleyici A_anlamına gelir function(A,Z){Z.

Bash + GNU araçları, 26

• @Dennis sayesinde 4 byte tasarruf edildi

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

Çevrimiçi deneyin .

Bash + Unix yardımcı programları, 29 26 bayt

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

Çevrimiçi deneyin!

Bu, @ DigitalTrauma / @ Dennis'in çözümü ile aynı uzunluktadır, ancak tamamen farklı bir yöntem kullanır.

Çıktı:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Herhangi bir siparişe izin verilir.)

Saf Bash , 34 bayt

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

Saf Bash sürümünü çevrimiçi deneyin!

Çıktı:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 bayt

#:i.11

6 bayta indirdiği için mil sayesinde!

Jöle , 7 bayt

2Bṗ4ṫ6Y

Çevrimiçi deneyin!

(Sondaki nybble hatlarına izin verilirse 5 bayt, 2Bṗ4Y )

Nasıl?

Azalan sırada yazdırır.

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 bir 7-Byter olup 2ṗ4Ịṫ6Y, [1,0]ile değiştirilmiştir [1,2]ve Ị( "önemsizdir" tek hücreli olan abs(z)<=1dönüştürme) 2ile s 0s.

Python 3.6, 36 35 bayt

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

@JonathanAllan sayesinde -1 bayt

Python 3.5 ve öncesi:

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

Çevrimiçi deneyin!

PHP, 33 bayt

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

CJam , 12 bayt

B{G+2b1>}%N*

Çevrimiçi deneyin!

açıklama

Kartezyen iktidar yaklaşımı benim tercihim olurdu, ama zaten alındı.

Yani bu 0'dan 10'a kadar sayılar üretir ve her biri için 16 ekler ve ikiliye dönüştürür. 16 eklenmesi, gerekli önde gelen sıfırların, kaldırılan ekstra lider ile birlikte üretilmesini sağlar.

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 / Oktav, 13 bayt

dec2bin(0:10)

Çevrimiçi Demo

Jöle , 10, 9 , 8 bayt

⁴r26BḊ€Y

Çevrimiçi deneyin!

Ben jöle kadar iyi değilim, bu yüzden herhangi bir ipucuna açık olurum!

Bu Emigna'nın ilk algoritmasını kullanıyor

Dennis'e iki baytını tıraş ettiği için teşekkür ederim. : P

Açıklama:

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

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

@DJMcMayhem'e 2 bayt golf için teşekkürler!

Çevrimiçi deneyin!

Jöle , 8 bayt

2Ḷṗ4ḣ11Y

Çevrimiçi deneyin!

Nasıl çalışır

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 Bayt

~16.aL1{2B26q}:

Bu, bir işlev eklemek için çok iyi bir değişiklikti pad. Tamamı ]L4\-'0'\m\., yarısından fazlası kod, ped etmektir.

@ETHProductions sayesinde 6 bayt kaydedildi , bu pad işlevi yarı yarıya azaltıldı .

Açıklaması

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

Çevrimiçi deneyin!

Retina , 36 33 bayt

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

Çevrimiçi deneyin!

açıklama

%%%%

Boş (var olmayan) girişi ile değiştirin %%%%.

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

Bu aşamanın ilk çalıştırmada, bu maç olacak ^%ve esasen metni değiştirmek %%%%iki çizgi ile 0%%%ve 1%%%. Çıkış değişmeyi durdurana kadar sahne döngü yapacaktır. İkinci çalıştırmada, eşleşir \b%(rakamlar kelime karakterleri olarak sayıldığından %ve sayılmadığından) ve grupları çoğaltarak ve 0bir kopyaya ve 1diğerine ekleyerek değiştirir : 0%%%satırlar olur 00%%ve 01%%(ve1%%% ). Bu döngü aracılığıyla 16 bit dizginin tamamı üretilecek, hat besleme ayrılmış olacaktır.

11!`\d+

İlk 11 maç \d+(en az 1 basamaklı bir koşu) alınır. Eşleşmeler satır besleme ile ayrılmış bir listede çıkar.

Yakut, 25 bayt

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

BF, 121101 bayt

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

Sondaki bir yeni satır gerektirir. Bu yorumlayıcıyla! sembol kullanır (bu yüzden yazan kutuyu işaretleyin !) (çevrimiçi deneyin!) .

Her operatör 4 bit olarak kabul edilirse potansiyel olarak 51 bayt

C #, 96 bayt

golfed

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

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

Salıverme

• v1.0 - 96 bytes- İlk çözüm.

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

Can definitely be shortened!?

@Ahemone Awesome idea, Thanks!

Should work now! Try it online!

R - 23

We can use intToBin function from the R.utils package:

R.utils::intToBin(0:10)

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

C, 75 68 69 bytes

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

Try it online!

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

Try it online!

Python 2, 44 bytes

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

This uses the zfill function which works like rjust except it always padds with 0 so you don't waste bytes on an argument.

Pyke, 8 bytes

TFw0+b2t

Try it here!

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

Also 8 bytes:

TF 4@b2t

Try it here!

   4@    - set_bit(4, i)

Pyth - 8 7 bytes

<5^_`T4

Try it online here.

stacked, 30 bytes

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

Try it online!

11:> is a range from 0 to 10. The rest is rather self-explanatory.

Other solutions that I've found:

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

I'm sure this can be shortened--it's pretty much my first BF golf.

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

Try it online! Assumes a tape infinite in both directions, like the interpreter at TIO uses. An interpreter where < at the left end of the tape is a no-op would save three bytes.

Explanation

More than half of the code (the first 77 bytes, to be precise) is spent initializing the tape. The steps go like this:

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

The cells initialized to 1 store the bits of our number plus 1: 1 represents a zero bit and 2 represents a one bit.

The initialization phase ended with the pointer on the 11. Now we use this cell to run 11 iterations of our loop:

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