16
\$\begingroup\$

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.

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 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
    {⌽⍺↑⍵⍴1}

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

Lowest score wins!

\$\endgroup\$
  • 14
    \$\begingroup\$ I'm deeply concerned about the verifiability of the answers. \$\endgroup\$ – Dennis Mar 10 '16 at 15:33
  • 1
    \$\begingroup\$ @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. \$\endgroup\$ – Adám Mar 10 '16 at 15:36
  • 8
    \$\begingroup\$ 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... \$\endgroup\$ – Sp3000 Mar 10 '16 at 15:55
  • 1
    \$\begingroup\$ @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... \$\endgroup\$ – Adám Mar 10 '16 at 16:03
  • 1
    \$\begingroup\$ @CatsAreFluffy The idea was to show that any of those formats are valid. I think the cases are few and simple enough that ease of copy-paste'ing isn't an issue. \$\endgroup\$ – Adám Mar 10 '16 at 17:16

25 Answers 25

7
\$\begingroup\$

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

\$\endgroup\$
8
\$\begingroup\$

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"

\$\endgroup\$
  • \$\begingroup\$ Now we're talking! \$\endgroup\$ – Adám Mar 10 '16 at 20:20
  • \$\begingroup\$ Why -1? filler+ \$\endgroup\$ – CalculatorFeline Mar 10 '16 at 21:18
  • 2
    \$\begingroup\$ That's one of the more interesting 'truthy' values I've seen lately. \$\endgroup\$ – user3490 Mar 10 '16 at 23:45
  • 4
    \$\begingroup\$ stackoverflow.com/q/23832703/10396 \$\endgroup\$ – AShelly Mar 11 '16 at 0:46
  • \$\begingroup\$ Is there a good reason this is named sv and not s, or something else one byte? \$\endgroup\$ – cat Mar 11 '16 at 15:11
8
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ Kids, this is called a winner. Please write that down in your notes. \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 16:14
  • \$\begingroup\$ @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. \$\endgroup\$ – Adám Mar 11 '16 at 16:21
7
\$\begingroup\$

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!

\$\endgroup\$
5
\$\begingroup\$

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.

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

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
\$\endgroup\$
  • \$\begingroup\$ 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 \$\endgroup\$ – Sparr Mar 10 '16 at 18:02
  • \$\begingroup\$ We don't consider returning through Ans an acceptable output method, unless it's printed. \$\endgroup\$ – lirtosiast Mar 10 '16 at 18:04
  • \$\begingroup\$ @Sparr Sure, Prompt and seq( are one byte tokens and the other characters are one byte each. \$\endgroup\$ – Timtech Mar 10 '16 at 19:13
  • \$\begingroup\$ @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. \$\endgroup\$ – Timtech Mar 10 '16 at 19:22
  • 2
    \$\begingroup\$ Is it the Analytical Engine? Somebody should do that... \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 14:47
4
\$\begingroup\$

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)

\$\endgroup\$
  • \$\begingroup\$ Just about the current winner. If only the SMP code could get shorter... \$\endgroup\$ – CalculatorFeline Mar 10 '16 at 16:15
  • \$\begingroup\$ On another note though, some docs: pure functions, /. and ->, Array \$\endgroup\$ – Sp3000 Mar 10 '16 at 16:35
4
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ How is the size counted? Tokenization is very different on the 68k series. \$\endgroup\$ – lirtosiast Mar 10 '16 at 20:33
  • \$\begingroup\$ Prompt and seq are both two bytes plus a one byte flag for multiple arguments. (21 bytes) \$\endgroup\$ – Timtech Mar 11 '16 at 15:31
  • \$\begingroup\$ 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) \$\endgroup\$ – Fox Mar 18 '16 at 8:13
  • \$\begingroup\$ 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. \$\endgroup\$ – Fox Mar 18 '16 at 22:39
3
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – Sp3000 Mar 10 '16 at 15:14
  • \$\begingroup\$ @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. \$\endgroup\$ – Morgan Thrapp Mar 10 '16 at 15:18
3
\$\begingroup\$

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
\$\endgroup\$
  • 4
    \$\begingroup\$ One day later, and... \$\endgroup\$ – Adám Mar 10 '16 at 14:55
  • 2
    \$\begingroup\$ 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. \$\endgroup\$ – drolex Mar 10 '16 at 16:50
  • \$\begingroup\$ @drolex The OP should define what he means by "year", exactly. Meantime, I'm adding 1 to my score \$\endgroup\$ – Luis Mendo Mar 10 '16 at 16:57
  • \$\begingroup\$ @DonMuesli I didn't mean it, just showing the potential limitations of this type of scoring \$\endgroup\$ – drolex Mar 10 '16 at 17:00
  • \$\begingroup\$ @drolex Oh, I thought you were serious. I've asked the OP, anyway. Github date should probably count as official \$\endgroup\$ – Luis Mendo Mar 10 '16 at 17:02
3
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ This may not be the winner, but it clearly illustrates the advantage of exploring - ehm - mature languages... \$\endgroup\$ – Adám Mar 10 '16 at 15:30
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ (#>x&/.x->#)/@Range[#+#2]& in Mathematica \$\endgroup\$ – CalculatorFeline Mar 10 '16 at 21:20
  • \$\begingroup\$ I mean (#>x&/.x->#-#2)/@Range[#]& \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 14:50
2
\$\begingroup\$

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'
\$\endgroup\$
  • \$\begingroup\$ Too bad vi doesn't support registers, because it was released in 1976! \$\endgroup\$ – DJMcMayhem Mar 10 '16 at 18:37
  • \$\begingroup\$ Explanation please? \$\endgroup\$ – CalculatorFeline Mar 10 '16 at 21:22
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
  • 1
    \$\begingroup\$ ? didn't pop (a long time ago) as stated in the quine challenge \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 14:48
  • \$\begingroup\$ 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 esolang.org, some date back to at least 2011. \$\endgroup\$ – Aaron Mar 11 '16 at 14:53
  • \$\begingroup\$ Quine challenge and esolang \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 15:05
  • \$\begingroup\$ 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. \$\endgroup\$ – Aaron Mar 11 '16 at 15:40
  • \$\begingroup\$ Score=2026 now. \$\endgroup\$ – CalculatorFeline Mar 11 '16 at 16:12
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ Very interesting! \$\endgroup\$ – Timtech Mar 11 '16 at 15:34
1
\$\begingroup\$

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

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)}
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

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
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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