Ispirato a un vecchio manuale ...

La sfida

Definisco l' un ^th suffisso vettore b come la lista booleana di lunghezza una con b trascinamento valori truthy.

Scrivere un programma o una funzione che, dato un e b con qualsiasi mezzo, restituisce l' una ^esimo suffisso di vettore di B con qualsiasi mezzo.

Ora questo può sembrare banale, ma ecco il problema: il tuo punteggio è il conteggio dei byte più l'anno in cui la tua soluzione avrebbe funzionato.

Regole

È possibile utilizzare tutte le regole standard, ad eccezione delle lingue e delle versioni linguistiche rilasciate dopo questa sfida.

Output utilizzando qualsiasi rappresentazione di valori booleani utilizzati dalla tua lingua, ad esempio 1/ 0, True/ False, TRUE/ FALSE, "True"/ "False", ecc.

Uscita utilizzando qualsiasi rappresentazione di liste che il vostro usi linguistici, per esempio 0 0 1, [False,False,True], (FALSE;FALSE;TRUE), {"False","False","True"}, etc.

Si può presumere che a ≥ b sia sempre vero e che siano di un tipo di dati appropriato.

Casi test

Dato a = 7 e b = 3, ritorno0 0 0 0 1 1 1

Dato a = 4 eb = 4, ritorno[True,True,True,True]

Dato a = 2 eb = 0, restituisce(FALSE;FALSE)

Dato a = 0 eb = 0, restituisce{}

Esempio di soluzione e punteggio

Potrei voler inviare la soluzione {⌽⍺↑⍵⍴1}utilizzando Dyalog APL. Sarebbe un totale di 8. Questa è una funzione dinamica, che funziona dalla versione 8.1 di Dyalog APL, rilasciata nel 1998, quindi il mio punteggio totale è 2006. La mia risposta inviata dovrebbe assomigliare a:

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

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

Il punteggio più basso vince!

APL \ 360, 1968 + 3 byte = 1971

⎕⍵⎕

Un builtin dal tutorial @NBZ collegato a. Non so perché @NBZ abbia detto che avrebbe ottenuto il 1970, perché APL \ 360 non è stato implementato fino al 1968, e APL precedenti come APL \ 1130 non avevano la funzione vettoriale suffisso (vedi pagina 208 di qui ).

Avanti, 1970 + 38 = 2008

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

utilizzo: 7 3 sstampa "0 0 0 0 -1 -1 -1"

APL, 1968 + 5 = 1973

Fino a 5 caratteri:

⌽⎕≥⍳⎕

Versione precedente:

⌽⎕↑⎕⍴1

Bene, in realtà hai già dato la risposta, ho appena rimosso la definizione della funzione dinamica e ho verificato che funzionasse nel 1968. Per riferimento ecco il manuale:

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; 

È tempo che splenda SAS!

SAS non è stato pubblicato per la prima volta fino al 1972, ma questo passaggio di dati utilizza solo funzionalità di base che sono abbastanza fiducioso che sarebbero state disponibili anche nelle prime versioni preliminari dal 1966 in poi, quindi credo che avrebbe funzionato allora. L'input segue a=e b=, e l'output viene stampato nel registro.

Sarei sorpreso se qualcuno avesse ancora un IBM System / 360 con la giusta versione di SAS per verificarlo davvero!

Mouse-1979 , 1979 + 19 = 1998

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

Traduzione di: Forth .

Le specifiche sono davvero enigmatiche per me, ma penso che questo faccia la cosa giusta.

TI-Basic, 1990 + 21 = 2011

Il primo calcolatore TI su cui funziona questo programma è il TI-81, introdotto nel 1990.

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

Modifica: notato che devo supportare un elenco vuoto ... codice aumentato di 4 byte

Casi test

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 byte = 2010

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

Non sono sicuro che funzioni, ho appena esaminato la documentazione sulla 10.3 e ho cercato cose che dicevano Introdotto nel 1988 (1.0)

68k TI-Basic, 1995 + 25 = 2020

Il primo calcolatore TI su cui funziona questo programma è il TI-92, introdotto nel 1995.

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

A differenza della serie TI-83, 68k TI-Basic supporta l'elenco vuoto.

Python 1.0, 1994 + 26 = 2020

Salvato 2 byte grazie a DSM.

Lambda è stato introdotto con la prima versione principale, 1.0

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

MATL , 2015 + 1 + 4 = 2020

:P<~

Funziona dalla versione 6.0.0 della lingua (utilizza input implicito, introdotto in quella versione), datato 31 dicembre 2015.

Ho aggiunto 1al punteggio in conformità con il commento di @drolex su possibili locali diversi.

Provalo online!

Spiegazione

:    % 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. Stavo cercando questa risposta e qualcuno arrivò all'APL prima che potessi sperare di capire la lingua. Ecco invece la mia soluzione J.

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

Utilizzo: a(7,3,L). si unificherà Lcon [0,0,0,0,1,1,1].

Non sono proprio sicuro di quando sia isstato implementato nella lingua e dubito che tu possa effettivamente trovare la data esatta. È un built-in piuttosto semplice anche se quindi presumo che fosse già esistente quando la lingua apparve per la prima volta nel 1972 .

Non importa che sia davvero importante, sono tutt'altro che vincente con questa risposta.

SMP , 1983 + 28 byte = 2011

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

Penso di aver capito bene ... S: 2.10, pagina 48 Ar: 7.1, pagina 102 Map : 7.2, pagina 106 $1: 7.1, pagina 104

E se si ha familiarità con Mathematica, no, Arnon funziona come quella . Più come Range+ Select.

Vim, 1991 + 21 = 2012

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

L'input è simile al seguente:

7
3

E l'output è simile al seguente:

0000111

Spiegazione:

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

Vedere " Il riferimento dell'utente a B " per il manuale di questo precursore C non tipizzato.

Pyth, 2015 + 9 4 = 2024 2019

Grazie a @FryAmTheEggman per il suo aiuto!

gRQE

Provalo qui!

Spiegazione

gRQE # Q = quantità di valori di verità finali finali
        # E = lunghezza del vettore
 RE # map over range (E)
g Q # d> = Q

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

be adovrebbe essere fornito direttamente in pila con -v, in ordine inverso.

L'output non è separato dallo spazio come negli esempi, ma ciò non sembra andare contro alcuna regola dichiarata. Usa 0 e 1 per rappresentare falso e vero, come usato dalla lingua.

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

Non funziona con la versione corrente poiché ?ora estrae il suo valore di test dallo stack.

Non sono sicuro che ogni funzionalità sia stata implementata dal primo giorno, -vad esempio potrebbe essere stata fornita in seguito come merce. Cercherò di assicurarmi che la mia risposta sia corretta questo fine settimana.

05AB1E , 2016 + 9 = 2025

Questo può sicuramente essere ulteriormente approfondito, ma ecco un inizio: p. Codice:

-0s×1¹×«S

Provalo online! L'input è dato come b, a .

Anche 9 byte: 0×1I×0ñRS.

PowerShell v1, 2006 + 28 = 2034

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

Utilizza l' operatore virgola per costruire l'array, che è stato in PowerShell dall'inizio.

Mathcad, 1998 + 42 = 2040

i "byte" sono interpretati come numero di caratteri della tastiera distinti (ad esempio, l'operatore "for" (inclusa una riga di programmazione) è un singolo carattere ctl-shft- # o un clic sulla barra degli strumenti di programmazione)).

Il conteggio dei byte sopra presuppone che le definizioni aeb non contino per il totale; aggiungere 4 byte per le definizioni se questo presupposto non è valido.

La versione della funzione mostrata di seguito aggiunge 5 byte per la definizione e altri 3 byte per ciascun utilizzo (presupponendo che i valori a e b siano digitati direttamente).

Dato che la mia soluzione Mathcad dovrebbe chiaramente giocare con le magliette rosse e non con quelle da competizione, ho aggiunto una tabella di soluzioni. Nota che poiché Mathcad non ha un array vuoto, ho usato invece una stringa vuota (""); Ho usato 0 per indicare dove non ho calcolato le coppie b> a.

PHP, 1995 + 56 byte = 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

Restituisce una matrice di 0 e 1

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

Javascript ES6, 2015 + 50 = 2065

Restituisce una stringa di 0e 1caratteri

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

Javascript, 1995 + 61 = 2056

Restituisce una stringa di 0e 1caratteri

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

Crea un elenco di b Valori reali e lo concatena in un elenco di (ab) Valori falsi.

R , 20 byte + 1993 = 2013

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

Provalo online!

Forse questo potrebbe funzionare in S, il che lascerebbe cadere il punteggio al 2008, ma non sono stato in grado di verificarlo.

SmileBASIC 3, 2014 + 25 = 2039

La prima versione pubblicamente disponibile di SmileBASIC 3 è stata lanciata in Giappone con l'app SmileBASIC per Nintendo 3DS nel novembre 2014.

Stampa una stringa in cui 0 è falso e 1 è vero (poiché sono nella lingua stessa).

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