Inspiré d'un vieux manuel ...

Le défi

Je définis le a ^ème suffixe vecteur de b comme la liste booléenne de longueur a avec b des valeurs vraies de fin.

Écrivez un programme ou une fonction qui, étant donné a et b par n'importe quel moyen, retourne le a ^ème vecteur suffixe de b par n'importe quel moyen.

Cela peut sembler trivial, mais voici le problème: votre score est le nombre d'octets plus la première année de fonctionnement de votre solution.

Règles

Toutes les règles standard s'appliquent, sauf que les langues et les versions linguistiques publiées après ce défi peuvent également être utilisées.

Sortie utilisant n'importe quelle représentation des valeurs booléennes que votre langue utilise, par exemple 1/ 0, True/ False, TRUE/ FALSE, "True"/ "False", etc.

Sortie en utilisant un minimum de représentation des listes que votre utilisation de la langue, par exemple 0 0 1, [False,False,True], (FALSE;FALSE;TRUE), {"False","False","True"}, etc.

Vous pouvez supposer que a ≥ b est toujours vrai et qu'ils sont d'un type de données approprié.

Cas de test

Étant donné a = 7 et b = 3, retournez0 0 0 0 1 1 1

Étant donné a = 4 et b = 4, retournez[True,True,True,True]

Étant donné a = 2 et b = 0, retournez(FALSE;FALSE)

Étant donné a = 0 et b = 0, retournez{}

Exemple de solution et de notation

Je voudrais peut-être soumettre la solution à l' {⌽⍺↑⍵⍴1}aide de Dyalog APL. Ce serait un bytecount de 8. Il s'agit d'une fonction dynamique, qui fonctionne à partir de la version 8.1 de Dyalog APL, sortie en 1998, donc mon score total est 2006. Ma réponse soumise devrait ressembler à ceci:

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

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

Le score le plus bas gagne!

APL \ 360, 1968 + 3 octets = 1971

⎕⍵⎕

Un intégré du tutoriel @NBZ lié à. Je ne sais pas pourquoi @NBZ a dit qu'il marquerait 1970, car APL \ 360 n'a été implémenté qu'en 1968, et les APL antérieures comme APL \ 1130 n'avaient pas la fonction de vecteur de suffixe (voir page 208 d' ici ).

Quatrième, 1970 + 38 = 2008

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

utilisation: 7 3 simprime "0 0 0 0 -1 -1 -1"

APL, 1968 + 5 = 1973

Jusqu'à 5 caractères:

⌽⎕≥⍳⎕

Ancienne version:

⌽⎕↑⎕⍴1

Eh bien, vous avez déjà donné la réponse, je viens de supprimer la définition de la fonction dynamique et de vérifier que celle-ci fonctionnait en 1968. Pour référence, voici le manuel:

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; 

Il est temps que SAS brille!

SAS n'a été publié pour la première fois qu'en 1972, mais cette étape de données n'utilise que des fonctionnalités très basiques qui, je suis assez confiant, auraient été disponibles même dans les premières versions préliminaires à partir de 1966, donc je pense que cela aurait fonctionné à ce moment-là. L'entrée va après a=et b=, et la sortie est imprimée dans le journal.

Je serais étonné si quelqu'un avait encore un IBM System / 360 avec la bonne version de SAS pour vérifier cela!

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.

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

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)

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.

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

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

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.

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.

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