이 과제는 0에서 10까지의 숫자를 터미널, 창, 캔버스 또는 화면에 출력하는 것입니다. 출력 된 각 숫자는 4 비트 폭의 니블로 표시되어야하므로 0은 계속 표시되어야합니다 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

온라인으로 사용해보십시오!

자바 스크립트, 46 바이트

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

각 숫자에 16을 더하고 첫 번째 이진수를 분리 할 수 ​​있는데 왜 패딩 기능을 사용합니까?

Japt , 7 바이트

GôA,_¤Å

그리고 여기서 나는 Japt가 다른 모든 골프 언어보다 길어질 운명이라고 생각했습니다 ...

온라인으로 테스트하십시오!

설명

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에서 제거 할 수 있지만 버그로 인해 발생합니다. _일반적으로 means function(Z){Z이지만 어떤 이유로 컴파일러 A_는 means를 생각 합니다 function(A,Z){Z.

배쉬 + GNU 유틸리티, 26

• @Dennis 덕분에 4 바이트 절약

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

(모든 주문이 허용됩니다.)

퓨어 배쉬 , 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 바이트 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]하고 Ị((가) "미미한"모나드 인 abs(z)<=1변환) 2에 S를 0S.

파이썬 3.6, 36 35 바이트

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

@JonathanAllan 덕분에 -1 바이트

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을 추가하면 필요한 선행 0이 제거되고 추가 선행 0이 생성됩니다.

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 / 옥타브, 13 바이트

dec2bin(0:10)

온라인 데모

젤리 , 10, 9 , 8 바이트

⁴r26BḊ€Y

온라인으로 사용해보십시오!

나는 젤리에 그다지 좋지 않기 때문에 나는 어떤 팁에도 개방적입니다!

이것은 Emigna의 첫 번째 알고리즘을 사용 합니다

2 바이트를 줄여 주신 Dennis에게 감사의 말을 전 합니다. :피

설명:

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

파이썬 2 , 38 36 바이트

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

2 바이트를 깎아 낸 @DJMcMayhem에게 감사합니다!

온라인으로 사용해보십시오!

젤리 , 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\.코드 전체의 절반 이상이 패딩됩니다.

_ @ ETHProductions 덕분에 6 바이트가 절약 되었습니다. 패드 기능이 반으로 줄었습니다.

설명

~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 33 바이트

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

온라인으로 사용해보십시오!

설명

%%%%

비어있는 (존재하지 않는) 입력을로 바꿉니다 %%%%.

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

이 단계의 첫 번째 실행 ^%에서는 텍스트 %%%%가 두 줄 0%%%및과 일치 하고 본질적으로 바뀝니다 1%%%. 출력 변경이 멈출 때까지 스테이지가 반복됩니다. 두 번째 실행에, 그것은 일치 \b%(숫자는 단어 문자로 간주하고 있기 때문에 %하지 않습니다), 그리고 그들을 복제 및 추가하여 그룹을 대체 0사본과 1다른 : 0%%%선이된다 00%%과 01%%(와 물건의 동일한 종류에 대한 1%%%). 이 루프를 통해 16 비트 문자열이 모두 생성되고 줄 바꿈이 구분됩니다.

11!`\d+

\d+(최소 1 자리의 런)의 처음 11 개의 일치 항목 이 검색됩니다. 일치 항목은 줄 바꿈으로 구분 된 목록으로 출력됩니다.

루비, 25 바이트

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

BF, 121101 바이트

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

후행 줄 바꿈이 필요합니다. 이 인터프리터 와 함께 !기호를 사용 하십시오 (따라서 확인란을 선택하십시오 !) (온라인으로 시도하십시오!) .

각 연산자가 4 비트로 간주 될 경우 잠재적으로 51 바이트

C #, 96 바이트

골프

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

언 골프

() => {
    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 170120 바이트

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 버전 :

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 멋진 아이디어, 감사합니다!

지금 작동해야합니다! 온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

파이썬 2, 44 바이트

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

이것은 항상 패딩되는 것을 제외하고 zfill는 작동 하는 함수를 사용 하므로 인수에서 바이트를 낭비하지 않습니다.rjust0

파이크, 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

루비, 38 바이트

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

BF , 134 바이트

나는 이것이 단축 될 수 있다고 확신합니다-그것은 나의 첫 BF 골프와 거의 같습니다.

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

온라인으로 사용해보십시오! TIO의 인터프리터처럼 테이프를 양방향으로 무한대로 가정합니다. <테이프의 왼쪽 끝에 no-op 인 인터프리터 는 3 바이트를 절약합니다.

설명

코드의 절반 이상 (정확히 말하면 첫 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은 0 비트를 2나타내고 1 비트를 나타냅니다.

초기화 단계가에 포인터로 종료되었습니다 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
]