Good Old Suffix Vector

Question

Inspired by an old manual...

The challenge

I define the a^th suffix vector of b as the boolean list of length a with b trailing truthy values.

Write a program or function that, given a and b by any means, returns the a^th suffix vector of b by any means.

Now this may seem trivial, but here is the catch: Your score is the byte count plus the earliest year your solution would have worked.

Rules

All standard rules apply, except that languages and language versions that were released after this challenge, may also be used.

Output using whatever representation of boolean values that your language uses, e.g. 1/0, True/False, TRUE/FALSE, "True"/"False", etc.

Output using whatever representation of lists that your language uses, e.g. 0 0 1, [False,False,True], (FALSE;FALSE;TRUE), {"False","False","True"}, etc.

You may assume that a ≥ b is always true and that they are of an appropriate data type.

Test cases

Given a = 7 and b = 3, return 0 0 0 0 1 1 1

Given a = 4 and b = 4, return [True,True,True,True]

Given a = 2 and b = 0, return (FALSE;FALSE)

Given a = 0 and b = 0, return {}

Example solution and scoring

I might want to submit the solution {⌽⍺↑⍵⍴1} using Dyalog APL. That would be a bytecount of 8. This is a dynamic function, which works from version 8.1 of Dyalog APL, released in 1998, so my total score is 2006. My submitted answer should look something like:

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

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

Lowest score wins!

Answer 1

SAS, 1966 + 45 = 2011

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

Time for SAS to shine!

SAS wasn't first published until 1972, but this data step only uses very basic features that I'm fairly confident would have been available even in the earliest pre-release versions from 1966 onwards, so I believe it would have worked then. Input goes after a= and b=, and output is printed to the log.

I would be amazed if anyone still had an IBM System/360 with the right version of SAS to actually verify this!

Answer 2

Forth, 1970 + 38 = 2008

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

usage: 7 3 s prints "0 0 0 0 -1 -1 -1"

Answer 3

APL, 1968+5=1973

Down to 5 chars:

⌽⎕≥⍳⎕

---

Older version:

⌽⎕↑⎕⍴1

Well, you actually already gave the answer, i just removed the dynamic function definition and checked that this one worked in 1968. For reference here is the manual:

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

Answer 4

APL\360, 1968 + 3 bytes = 1971

⎕⍵⎕

A builtin from the tutorial @NBZ linked to. I don't know why @NBZ said it would score 1970, because APL\360 wasn't implemented until 1968, and earlier APLs like APL\1130 didn't have the suffix vector function (see page 208 of here).

Answer 5

Mouse-1979, 1979 + 19 = 1998

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

Translation of: Forth.

The spec is really cryptic to me but I think this does the right thing.

Answer 6

TI-Basic, 1990 + 21 = 2011

The first TI calculator that this program works on is the TI-81, introduced in 1990.

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

Edit: noticed that I must support an empty list... increased code by 4 bytes

Test Cases

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

Answer 7

Mathematica 1.0, 1988+22 bytes=2010

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

I'm not sure if this works, just went through the documentation on 10.3 and looked for things that said Introduced in 1988 (1.0)

Answer 8

68k TI-Basic, 1995 + 25 = 2020

The first TI calculator that this program works on is the TI-92, introduced in 1995.

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

Unlike the TI-83 series, 68k TI-Basic supports the empty list.

Answer 9

Python 1.0, 1994 + 26 = 2020

Saved 2 bytes thanks to DSM.

Lambda was introduced with the first major release, 1.0

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

Answer 10

MATL, 2015 + 1 + 4 = 2020

:P<~

This works since release 6.0.0 of the language (it uses implicit input, which was introduced in that release), dated December 31, 2015.

I've added 1 to the score in accordance with @drolex comment on possibly different locales.

Try it online!

Explanation

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

Answer 11

J, 1990 + 8 = 1998

|.a{.b#1

Argh. Was researching this answer and someone got to APL before I could hope to understand the language. Here's my J solution instead.

Answer 12

Prolog, 1972 + 57 = 2029

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

Usage: a(7,3,L). will unify L with [0,0,0,0,1,1,1].

I'm really not quite sure when is was implemented in the language, and I doubt you can actually find the exact date. It's a pretty basic built-in though so I assume it was already existing when the language first appeared in 1972.

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

Answer 13

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.

Answer 14

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'

Answer 15

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.

Answer 16

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

Answer 17

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

Answer 18

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.

Answer 19

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.

Answer 20

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.

Answer 21

PHP, 1995 + 56 bytes = 2051

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

Exploded view

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

Answer 22

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

Answer 23

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.

Answer 24

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.

Answer 25

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