오래된 매뉴얼에서 영감을 얻은 ...

도전

I는 정의 ^번째 의 접 벡터 B 의 길이의 부울 목록으로 와 B 후단 truthy 값.

주어진하는 프로그램이나 함수를 작성 및 B를 임의의 수단에 의해 상기 반환 ^번째 접 벡터 (B)를 임의의 수단에 의해.

이제 이것은 사소한 것처럼 보이지만 여기에 캐치가 있습니다. 점수는 바이트 수에 솔루션이 작동 한 가장 빠른 해입니다.

규칙

이 문제 이후에 릴리스 된 언어 및 언어 버전도 사용할 수 있다는 점을 제외하고 모든 표준 규칙이 적용됩니다.

언어가 사용하는 부울 값 (예 : 1/ 0, True/ False, TRUE/ FALSE, "True"/ "False"등)을 사용하여 출력

나와있는 언어 사용, 예를 들면의 어떤 표현을 사용하여 출력 0 0 1, [False,False,True], (FALSE;FALSE;TRUE), {"False","False","True"}, 등

a ≥ b 가 항상 true이고 적절한 데이터 유형 이라고 가정 할 수 있습니다 .

테스트 사례

주어 = 7, B = 3, 리턴0 0 0 0 1 1 1

주어 = 4, B = 4, 리턴[True,True,True,True]

주어 = 2, B = 0을 반환(FALSE;FALSE)

주어 = 0, B = 0, 반환{}

솔루션 및 점수 예

{⌽⍺↑⍵⍴1}Dyalog APL을 사용 하여 솔루션을 제출하고 싶을 수도 있습니다 . 이것은 8의 바이트 수입니다. 이것은 1998 년에 릴리스 된 Dyalog APL 버전 8.1에서 작동하는 동적 함수이므로 총 점수는 2006입니다. 제출 된 답변은 다음과 같아야합니다.

# Dyalog APL 8.1, 1998 + 8 = 2006
    {⌽⍺↑⍵⍴1}

Optional explanation...
Recommended: Link to documentation showing when the features you used were released.

최저 점수가 이깁니다!

APL \ 360, 1968 + 3 바이트 = 1971

⎕⍵⎕

튜토리얼 @NBZ에 내장 되어 있습니다. APL \ 360이 1968 년까지 구현되지 않았고 APL \ 1130과 같은 이전 APL에는 접미사 벡터 기능이 없었기 때문에 @NBZ가 1970 년에 득점 한 이유를 모르겠습니다 ( 여기의 208 페이지 참조 ).

1970 년 + 38 = 2008

:s tuck +do 0 . loop 0 +do -1 . loop ;

사용법 : 7 3 s"0 0 -1 -1 -1"을 인쇄 합니다.

APL, 1968 + 5 = 1973

최대 5 자 :

⌽⎕≥⍳⎕

이전 버전 :

⌽⎕↑⎕⍴1

글쎄, 당신은 실제로 대답을했습니다. 나는 방금 동적 함수 정의를 제거하고 이것이 1968 년에 작동했는지 확인했습니다. 참조를 위해 여기 매뉴얼이 있습니다 :

http://www.softwarepreservation.org/projects/apl/Books/APL360ReferenceManual

SAS, 1966 + 45 = 2011

data;a=;b=;do i=1to a;c=a-i<b;put c@;end;run; 

SAS가 빛을 발할 시간입니다!

SAS는 1972 년까지 처음 출판되지 않았지만이 데이터 단계는 1966 년 이후의 초기 시험판 버전에서도 사용 가능했을 것이라고 확신하는 매우 기본적인 기능 만 사용하므로 당시에는 효과가 있었을 것으로 생각됩니다. 입력 후 이동 a=및b= , 그리고 출력은 로그에 인쇄된다.

SAS가 올바른 버전의 SAS를 사용하여 IBM System / 360 을 보유하고 있다는 사실을 알고 있다면 놀라 울 것입니다 !

마우스 -1979 , 1979 + 19 = 1998

??&TUCK (0.a)0(1-.)

Forth의 번역 .

사양은 실제로 나에게 비밀 스럽지만 이것이 옳은 일이라고 생각합니다.

TI- 기본, 1990 + 21 = 2011

이 프로그램이 작동하는 첫 번째 TI 계산기는 1990 년에 소개 된 TI-81입니다.

Prompt A,B:"{}
seq(I>A-B,I,1,A

편집 : 빈 목록을 지원해야한다는 것을 알았습니다 ... 코드 4 바이트 증가

테스트 사례

A=?7
B=?3
{0 0 0 0 1 1 1}

A=?4
B=?4
{1 1 1 1}

A=?2
B=?0
{0 0}

A=?0
B=?0
{}   * throws an error but still returns successfully

Mathematica 1.0, 1988 + 22 바이트 = 2010

Array[#>m&/.m->#-#2,#]&

이것이 효과가 있는지 확신 할 수 없으며 10.3의 문서를 살펴보고 1988 년에 소개 된 것을 찾았습니다 (1.0)

68k TI 기본, 1995 + 25 = 2020

이 프로그램이 작동하는 첫 번째 TI 계산기는 1995 년에 소개 된 TI-92입니다.

define f(a,b)=seq(x>a-b,x,1,a)

TI-83 시리즈와 달리 68k TI-Basic은 빈 목록을 지원합니다.

파이썬 1.0, 1994 + 26 = 2020

DSM 덕분에 2 바이트를 절약했습니다.

Lambda는 첫 번째 주요 릴리스 인 1.0으로 도입되었습니다.

lambda a,b:[0]*(a-b)+[1]*b

MATL , 2015 + 1 + 4 = 2020

:P<~

이것은 2015 년 12 월 31 일자 언어 6.0.0 이후 (이 릴리스 에서 소개 된 암시 적 입력을 사용함) 부터 작동합니다 .

1다른 로케일에 대한 @drolex 의견에 따라 점수를 추가 했습니다.

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

설명

:    % take first input implicitly. Generate inclusive range from 1 to that
P    % flip that array
<~   % take second input implicitly. True for elements of flipped array that
     % exceed second number. Display implicitly

J, 1990 + 8 = 1998

|.a{.b#1

아아 이 답변을 연구하고 있었고 언어를 이해하기 전에 누군가 APL에 도달했습니다. 여기 내 J 솔루션이 있습니다.

프롤로그, 1972 + 57 = 2029

a(0,_,[]).
a(A,B,[H|L]):-Z is A-1,a(Z,B,L),(Z<B,H=1;H=0).

사용법 : a(7,3,L). 로 통합 L합니다 [0,0,0,0,1,1,1].

is언어로 언제 구현 되었는지 확실하지 않으며 실제로 정확한 날짜를 찾을 수 있을지 의심됩니다. 꽤 기본 내장되어 있으므로 1972 년에 언어가 처음 등장했을 때 이미 존재한다고 가정합니다 .

Not that it really matters though, I'm far from winning with this answer.

SMP, 1983+28 bytes=2011

Map[S[$1>x,x->$1-$2],Ar[$1]]

I think I got this right... S:2.10, page 48 Ar:7.1, page 102 Map:7.2, page 106 $1:7.1, page 104

And if you're familiar with Mathematica, no, Ar doesn't work like that. More like Range+Select.

Vim, 1991 + 21 = 2012

"adwj<c-x>"bdw@ai0<esc>v@bhr1

Input looks like this:

7
3

And output looks like this:

0000111

Explanation:

"adw                            'Delete a word into register a
    j<c-x>                      'Go down a line, and decrement the next number to occur
          "bdw                  'Delete a word into register b
              @ai0<esc>         'Insert a '0' "a" times
                       v        'Enter visual mode
                        @bh     'Move "b" characters left
                           r1   'Replace the whole selection with the character '1'

B, 1971 + 54 = 2025

s(l,t){while(t<l--)printn(0,8);while(t--)printn(1,8);}

See "The User's Reference to B" for the manual for this typeless C precursor.

Pyth, 2015 + 9 4 = 2024 2019

Thanks to @FryAmTheEggman for his help!

gRQE

Try it here!

Explanation

gRQE    # Q = amount of trailing truthy values
        # E = length of the vector
 R E    # map over range(E)
g Q     # d >= Q

><>, 2009 + 14 + 3 for -v = 2026

b and a should be provided directly on the stack with -v, in reverse order.

The output isn't space separated as in the examples, but that does not seem to go against any stated rule. It uses 0 and 1 to represent false and true, as used by the language.

:?!;{:0(n1-}1-

It doesn't work with the current version since ? now pops its test value from the stack.

I'm not confident every feature was implemented from day 1, -v for example could have been provided later as a commodity. I'll try to make sure my answer is correct this weekend.

05AB1E, 2016 + 9 = 2025

This can definitely be golfed further, but here's a start :p. Code:

-0s×1¹×«S

Try it online! The input is given as b, a.

Also 9 bytes: 0×1I×0ñRS.

PowerShell v1, 2006 + 28 = 2034

param($a,$b),0*($a-$b)+,1*$b

Uses the comma operator to construct the array(s), which has been in PowerShell since the beginning.

Mathcad, 1998 + 42 = 2040

"bytes" are interpreted as number of distinct keyboard characters (eg, 'for' operator (including one programming line) is a single character ctl-shft-#, or a click on the Programming toolbar)).

The above byte count assumes that the a and b definitions don't count towards the total; add 4 bytes for definitions if this assumption is invalid.

The function version shown below adds 5 bytes for the definition and a further 3 bytes for each use (assuming the a and b values are directly typed in).

As my Mathcad solution should clearly be playing off the red tees and not the competition ones, I've added a table of solutions. Note that as Mathcad has no empty array, I've used an empty string ("") instead; I've used 0 to indicate where I haven't calculated the b>a pairs.

PHP, 1995 + 56 bytes = 2051

function s($a,$b){while($i++<$a)$v[]=$i>$a-$b;return$v;}

function s($a,$b) {
  while ($i++ < $a) $v[] = $i > $a - $b;
  return $v;
}

Javascript ES6, 2015 + 46 = 2061

Returns array of 0 and 1

(a,b)=>Array(a-b).fill(0).concat(Array(b).fill(1))

Javascript ES6, 2015 + 50 = 2065

Returns a string of 0 and 1 chars

(a,b)=>Array(a-b+1).join(0)+Array(b+1).join(1)

Javascript, 1995 + 61 = 2056

Returns a string of 0 and 1 chars

function(a,b){return Array(a-b+1).join(0)+Array(b+1).join(1)}

k (kona), 1993 + 15 = 2008

((a-b)#0b),b#1b

Creates list of b True values, and concatenates it to a list of (a-b) False values.

R, 20 bytes + 1993 = 2013

function(a,b)1:a>a-b

Try it online!

Possibly this might work in S, which would drop the score to 2008, but I haven't been able to verify it.

SmileBASIC 3, 2014 + 25 = 2039

The first publicly available version of SmileBASIC 3 launched in Japan with the SmileBASIC app for Nintendo 3DS in November 2014.

Prints a string where 0 is false and 1 is true (as they are in the language itself.)

INPUT A,B?"0"*(A-B)+"1"*B