Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Inspired by an old manual...

The challenge

I define the ath 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 ath 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.


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

Optional explanation...
Recommended: Link to documentation showing when the features you used were released.
share|improve this question
I'm deeply concerned about the verifiability of the answers. – Dennis Mar 10 at 15:33
@Dennis Same. For example I am fairly confident that my answer would have worked on the first Prolog interpreters but I actually can't easily check it. – Fatalize Mar 10 at 15:35
@Dennis I understand you concern. However, 1) the answers will mostly be very simple, and thus could be verified by hand – not requiring an actual running system, and 2) some users have taken to linking to documentation of their claim. – Adám Mar 10 at 15:36
I'm not so sure "verified by hand" is necessarily going to work for some answers - the past is a foreign place, and sometimes initial versions of things can lack things that feels commonplace today... – Sp3000 Mar 10 at 15:55
@Sp3000 Maybe, but this is all for fun anyway, and with 8 answers and 9 upvotes in 1.5h, I think this challenge is fun enough accept that someone might cheat. Maybe some extra research on the eventual winner... – Adám Mar 10 at 16:03

23 Answers 23

up vote 2 down vote accepted

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

share|improve this answer

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"

share|improve this answer
Now we're talking! – Adám Mar 10 at 20:20
Why -1? filler+ – CalculatorFeline Mar 10 at 21:18
That's one of the more interesting 'truthy' values I've seen lately. – user3490 Mar 10 at 23:45
Is there a good reason this is named sv and not s, or something else one byte? – cat Mar 11 at 15:11

APL, 1968+5=1973

Down to 5 chars:


Older version:


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:

share|improve this answer
Kids, this is called a winner. Please write that down in your notes. – CalculatorFeline Mar 11 at 16:14
@CatsAreFluffy Not yet. @​Moris Zucca: Finally, but you can actually golf half of those bytes away. Can you figure out how? Also, here is a much more modern and readable version of the manual. – Adám Mar 11 at 16:21

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!

share|improve this answer
The machine is available.‌​... – Adám Mar 11 at 15:40
Now, if only I had the cash for a mainframe SAS licence... – user3490 Mar 11 at 16:48

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.

share|improve this answer
Broken link.... – CalculatorFeline Mar 11 at 16:31
@CatsAreFluffy Fixed; I typed it from memory. – cat Mar 11 at 16:44
Interesting. But I don't think the &Tuck was available until the 2002 version. And the loops appear to be infinite. – AShelly Mar 12 at 0:05

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.

share|improve this answer
How is the size counted? Tokenization is very different on the 68k series. – lirtosiast Mar 10 at 20:33
Prompt and seq are both two bytes plus a one byte flag for multiple arguments. (21 bytes) – Timtech Mar 11 at 15:31
Note that this is neither a program nor a function in the context of the 68k calculators: Prompt is invalid in a function, and a program can't return a value. So this has to be entered on the home screen. On the other hand, define f(a,b)=seq(x>a-b,x,1,a) does define a valid function that can be given a and b as arguments. (Verified on my TI-92 from 1995-09-13) – Fox Mar 18 at 8:13
Thanks @Fox, I have only used the TI-8X series. – Timtech Mar 18 at 14:38
I own several TI calculators (the only z80-version being the 81), but usually use a TI-92 Plus. After running this define and calling f(2,1) or similar to tokenize it, the size reported by the OS is 25 bytes. – Fox Mar 18 at 22:39

Mathematica 1.0, 1988+22 bytes=2010


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)

share|improve this answer
Just about the current winner. If only the SMP code could get shorter... – CalculatorFeline Mar 10 at 16:15
On another note though, some docs: pure functions, /. and ->, Array – Sp3000 Mar 10 at 16:35

MATL, 2015 + 1 + 4 = 2020


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!


:    % 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
share|improve this answer
One day later, and... – Adám Mar 10 at 14:55
Objection! We'll need to have the locales for the github server and the release submitter. If one is in Tonga and the other in Hawaii, this count might need to be incremented. – drolex Mar 10 at 16:50
@drolex The OP should define what he means by "year", exactly. Meantime, I'm adding 1 to my score – Luis Mendo Mar 10 at 16:57
@DonMuesli I didn't mean it, just showing the potential limitations of this type of scoring – drolex Mar 10 at 17:00
@drolex Oh, I thought you were serious. I've asked the OP, anyway. Github date should probably count as official – Luis Mendo Mar 10 at 17:02

Prolog, 1972 + 57 = 2029

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.

share|improve this answer
This may not be the winner, but it clearly illustrates the advantage of exploring - ehm - mature languages... – Adám Mar 10 at 15:30

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
share|improve this answer
Confirmed lambda introduced in 1.0, list (sequence) repetition in 0.9.2. The oldest version I could test this on (apart from 0.9.1) was 1.5.2, and it works fine there. – Sp3000 Mar 10 at 15:14
@Sp3000 Oh wow, that's awesome. I've been trying to find some change logs to confirm that the sequence repetition was in the language that early. – Morgan Thrapp Mar 10 at 15:18

TI-Basic, 1990 + 21 = 2011

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

Prompt A,B:"{}

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

Test Cases

{0 0 0 0 1 1 1}

{1 1 1 1}

{0 0}

{}   * throws an error but still returns successfully
share|improve this answer
Could you add commentary on which parts of the source are single bytes in TI-Basic? I think that includes Prompt and seq( but I'm not sure about the rest – Sparr Mar 10 at 18:02
We don't consider returning through Ans an acceptable output method, unless it's printed. – lirtosiast Mar 10 at 18:04
@Sparr Sure, Prompt and seq( are one byte tokens and the other characters are one byte each. – Timtech Mar 10 at 19:13
@lirtosiast Ans is the default way to return a value in the TI-83 series Basic. Additionally, when a program is run, the last line is printed automatically. So you have the best of both worlds. – Timtech Mar 10 at 19:22
Is it the Analytical Engine? Somebody should do that... – CalculatorFeline Mar 11 at 14:47

SMP, 1983+28 bytes=2011


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.

share|improve this answer
(#>x&/.x->#)/@Range[#+#2]& in Mathematica – CalculatorFeline Mar 10 at 21:20
I mean (#>x&/.x->#-#2)/@Range[#]& – CalculatorFeline Mar 11 at 14:50

Vim, 1991 + 21 = 2012


Input looks like this:


And output looks like this:



"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'
share|improve this answer
Too bad vi doesn't support registers, because it was released in 1976! – Dr Green Eggs and Iron Man Mar 10 at 18:37
Explanation please? – CalculatorFeline Mar 10 at 21:22

B, 1971 + 54 = 2025


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

share|improve this answer

Pyth, 2015 + 9 4 = 2024 2019

Thanks to @FryAmTheEggman for his help!


Try it here!


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

05AB1E, 2016 + 9 = 2025

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


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

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

share|improve this answer

PowerShell v1, 2006 + 28 = 2034


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

share|improve this answer

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.

enter image description here

share|improve this answer
Very interesting! – Timtech Mar 11 at 15:34

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


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.

share|improve this answer
? didn't pop (a long time ago) as stated in the quine challenge – CalculatorFeline Mar 11 at 14:48
Thanks, that's great news, I'll save 1 byte :) I'll edit that now, but I'll have to check the resources linked on, some date back to at least 2011. – Aaron Mar 11 at 14:53
Quine challenge and esolang – CalculatorFeline Mar 11 at 15:05
Thanks for your help, I wouldn't have thought to check the wiki's revisions ! I'm currently at work and won't probably be able to check everything yet, but I'll make sure to do it this evening or tomorrow. – Aaron Mar 11 at 15:40
Score=2026 now. – CalculatorFeline Mar 11 at 16:12

J, 1990 + 8 = 1998


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

share|improve this answer

K, 1993 + 15 = 2008


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

share|improve this answer

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;
share|improve this answer
Uh..there's custom scoring. It's first year language woks in+byte count. – CalculatorFeline Mar 11 at 22:31
Whoops, right you are! Fixing... – ricdesi Mar 11 at 22:33
Making the probably-incorrect assumption of this working in PHP 1. Will verify version soon. – ricdesi Mar 11 at 22:43

Javascript ES6, 2015 + 46 = 2061

Returns array of 0 and 1


Javascript ES6, 2015 + 50 = 2065

Returns a string of 0 and 1 chars


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)}
share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.