La tua sfida è semplice. È necessario scrivere un programma che stampa su STDOUT o su un file l'anno in cui è stata rilasciata la lingua in cui è scritto. Poiché questo è un compito così semplice, il colpo di scena è che deve essere scritto in quante più lingue possibili.

Il tuo punteggio è il numero totale di diversi anni che sono stampati correttamente.

Per ogni lingua che usi, devi

• Specifica quale versione della lingua che stai utilizzando. (Se ci sono più versioni)

• Specificare in quale anno è stata rilasciata la versione per la prima volta e

• Fornisci un link a una pagina che dimostri la data della tua versione / lingua.

Ognuno di questi conta come prova della data di rilascio, purché specifichi il numero di versione (se applicabile) e una data di rilascio.

• Una pagina di Wikipedia.

• Una pagina di esolang .

• Il sito web ufficiale della lingua. Una pagina github o conteggi simili, purché abbia una data di rilascio. (L'ultimo commit non conta, a meno che non ci sia un numero di versione da qualche parte nel codice)

Se non ci sono più versioni o versioni di una lingua, basta usare la data di rilascio iniziale della lingua.

Le versioni minori della stessa lingua non contano lingue diverse, a patto che essi provengono da diversi anni e continuano a produrre l'output corretto. Si può non utilizzare i comandi incorporati che forniscono informazioni (compresa la data di rilascio) sulla versione corrente della lingua che si sta utilizzando. Ad esempio, si tratta di un invio python non valido:

import platform
i = platform.python_version()
if i == '3.5':
    print(2015)
if i == '3.4':
    print(2014)
if i == '3.3':
    print(2012)
...

Qualunque invio stampa correttamente gli anni più distinti vince!

Regole

• Ogni programma deve stampare l'anno della lingua e niente di più . È consentita una nuova riga finale (stile Windows o * nix).

• Nessun programma può accettare alcun input.

• In caso di pareggio, vince il codice più corto segnato in byte. Puoi usare qualunque codifica ti piaccia, ma tutti i programmi devono usare la stessa codifica.

• Qualsiasi programma può stampare su STDERR o generare errori e avvisi in fase di runtime / compilazione purché l'output corretto sia ancora stampato su STDOUT o su un file.

• Lingue diverse possono utilizzare metodi IO diversi, ma sono quasi tutti programmi completi (funzioni non consentite per questa sfida) e seguire uno dei nostri metodi IO predefiniti consentiti .

Buon golf poliglotta!

Una breve storia dei linguaggi di programmazione 2D: 16 (+2) anni

v19977/2{@{{4{\_______>/02&&&#????        *    P+++++1P1P-1P+1E     *                         *
\'\02'oo100@n590@n;                       *                         *                         *
>"8991",,,;5-;,@                          *                         *                         *
   *                                      *                         *                         *
  \ *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX*******      *
     *   #2018O@       *                  *      *                  *      *                  *      *
      *                *                  *      *                  *      *                  *      *
       *               *                  *      *                  *      *                  *      *
        *           ****    ****          *   ****    ****          *   ****    ****          *   ****    *****
         *         *   *   *    *         *  *   *   *    *         *  *   *   *    *         *  *   *   *
          *        *   *  *      *        *  *   *  *      *        *  *   *  *      *        *  *   *  *
           *      *    * ****     *       * *    * ****     *       * *    * ****     *       * *    * ****
            *     *    *     *            * *    *     *            * *    *     *            * *    *     *
R"2014";     *****      *******       ******      *******       ******      *******       ******      *******

 x
x%"2010"x
 x

$'main'        \/\/\/\
 \-[2005]o-#   \++++++\
               /++++++/
               \++++++\
               /++++++/
               \/\/\/\++.--..+++.#

S1^2^2^6^8MAOUOAOOF

      /K:0:1:@

  >      "7102"4&o@

|        }+++++[>++++++++++<-]>.--..++++++.@

Ho già detto che mi piacciono i linguaggi di programmazione 2D?

1993: Befunge

La lingua che (presumibilmente, vedi l'ultima sezione) ha iniziato tutto. In Befunge, puoi reindirizzare il flusso di controllo con <v>^, ma gli specchi ora onnipresenti \e /non erano ancora una cosa. L'interprete Befunge utilizzato su Anarchy Golf ignora i comandi sconosciuti. Possiamo usarlo per distinguere la famiglia Befunge dalla famiglia> <>. Quindi, il codice eseguito da Befunge è questo:

v
\
>"8991",,,;5-;,@

La "8991"spinge i singoli caratteri nello stack. ,,,stampa i primi tre. Quindi ;è sconosciuto (che useremo per distinguerlo da Befunge 98), 5-trasforma il carattere 8in 3e lo ,stampa anche prima di @terminare il programma.

1997: Wierd

Scrivere questa parte della soluzione mi ha richiesto probabilmente tanto quanto scrivere tutte le altre e metterle insieme ...

Wierd conosce solo due simboli: lo spazio e tutto il resto. Il puntatore dell'istruzione cerca di seguire il percorso formato dai caratteri non spaziali, partendo in diagonale dall'angolo in alto a sinistra e cercando sempre di andare il più dritto possibile. Le curve nel percorso formano le istruzioni effettive (con i gradi del giro che determinano quale istruzione eseguire). Quindi il codice visto da Wierd è questo:

v1997                                     *                         *                         *
 '                                        *                         *                         *
  8                                       *                         *                         *
   *                                      *                         *                         *
    *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX*******      *
     *                 *                  *      *                  *      *                  *      *
      *                *                  *      *                  *      *                  *      *
       *               *                  *      *                  *      *                  *      *
        *           ****    ****          *   ****    ****          *   ****    ****          *   ****    *****
         *         *   *   *    *         *  *   *   *    *         *  *   *   *    *         *  *   *   *
          *        *   *  *      *        *  *   *  *      *        *  *   *  *      *        *  *   *  *
           *      *    * ****     *       * *    * ****     *       * *    * ****     *       * *    * ****
            *     *    *     *            * *    *     *            * *    *     *            * *    *     *
             *****      *******       ******      *******       ******      *******       ******      *******

Il 1997top in realtà non viene eseguito, ma Wierd ci permette di leggerlo dal codice sorgente, che è molto più breve del tentativo di costruire i codici dei caratteri per le quattro cifre stesse (anche se non sembra .. .). Non ho voglia di scomporre l'intera faccenda, ma puoi vedere chiaramente le quattro sezioni ripetute. Ciò che fa è che prima memorizziamo 1nello stack e poi ognuna di quelle quattro sezioni incrementa questo 1e quindi i rami. Il ramo inferiore ne spinge un altro1, recupera il carattere di origine su queste coordinate e lo stampa, mentre il ramo superiore viene reindirizzato alla sezione successiva. Potresti chiederti perché le estremità dei percorsi sono così inutilmente lunghe, ma è perché quando Wierd colpisce la fine di un percorso tenta di saltare a un percorso vicino prima di decidere che dovrebbe terminare il ramo corrente. Per evitare ciò, dobbiamo spostare queste estremità sufficientemente lontano da qualsiasi altro codice.

1998: Befunge 98

Befunge ha ottenuto un aggiornamento abbastanza noto nel 1998 con una specifica molto rigorosa che può essere generalizzata a dimensioni arbitrarie (e penso anche a topologie arbitrarie). È in gran parte compatibile all'indietro con Befunge, il che rende abbastanza facile poliglottare i due. Questo Befunge non aveva ancora mirror, quindi il percorso eseguito è lo stesso di Befunge 93:

v
\
>"8991",,,;5-;,@

La differenza è che Befunge 98 non ignora il ;. Invece si comporta un po 'come un commento in quanto tutti i comandi fino al successivo ;vengono ignorati. In questo modo, noi non diminuire quella 8per 3e stampare il 1998come è.

2001: A Space Od ... PingPong

Il 2001 è l'anno di Piet, ma non avevo davvero voglia di poliglottare un file di immagine con tutti gli altri programmi, quindi ecco un linguaggio 2D meno conosciuto. Sembra avere molte funzionalità (che non useremo). Grazie a Sp3000 per aver trovato l'interprete originale (che è l'unico link non funzionante nella versione archiviata del sito ufficiale).

PingPong è in qualche modo insolito in quanto ha solo mirror e nessun <v>^redirector. Quindi questo si sposta attraverso v19977all'inizio e quindi colpisce lo specchio che lo avvolge verso il basso. Il codice rilevante è quindi:

v19977/

...

      /K:0:1:@

...

Il codice attuale è abbastanza semplice: Kspinge 20, le cifre si spingono da sole, :stampa un numero intero e @termina il programma.

2003: SNUSP

Questa è la prima lingua in cui le cose diventano un po 'più facili, perché SNUSP supporta un punto di ingresso esplicito. Quel punto di ingresso è contrassegnato da $. A giudicare da alcuni articoli sugli esolang, questa lingua ha ispirato molti altri, ma sfortunatamente, alla fine della giornata è solo un derivato di Brainfuck. Detto questo, penso che il modo in cui imposta l'attuale cella su 48 sia abbastanza pulito (ed è stato rubato dall'articolo di Esolangs). Ecco la parte rilevante del codice:

$'main'        \/\/\/\
               \++++++\
               /++++++/
               \++++++\
               /++++++/
               \/\/\/\++.--..+++.#

Sono 24 +secondi e i mirror inviano l'IP attraverso ognuno esattamente due volte.

2004: Axo

Per qualsiasi motivo, questo linguaggio ha avere le <^>redirector, ma invece del solito vusa %. Quindi questo si sposta sulla prima riga. Il codice rilevante è:

v19977/2{@{{4{\

Spingiamo alcune cifre per cominciare, eseguiamo una divisione. Quindi 2{stampa il 2, @cancella la pila. {{stampa due (implicite) 0s. 4{stampa 4e \termina il programma.

2005: Rail

Il 2005 è stata una scelta difficile. Per nessun altro anno ho trovato altrettanti linguaggi 2D, e ci sono ADJUST e Archway, entrambi i quali iniziano nell'angolo in basso a sinistra (il che avrebbe reso loro facili aggiunte). Mi piace però Rail e dato che ha un punto di ingresso esplicito non è stato difficile aggiungere neanche. Rail cerca una linea che inizia con $'main'e inizia a muoversi a sud-est da $. Ciò significa che il codice pertinente è:

$'main'
 \-[2005]o-#

Le \e -sono solo tracce (no-ops). Il [2005]è una stringa letterale che ostampa prima che #termina il programma.

2006: BestFriends.js

Un Brainfuck bidimensionale. C'è un altro linguaggio interessante per quest'anno chiamato Black, che inizia alle coordinate (3,3)(basato su 1) e che avrebbe reso interessante l'utilizzo di questo in un poliglotta. Non sono riuscito a trovare un interprete però. Quindi dovremo lavorare con un altro derivato BF invece ...

La cosa interessante di questo è che non formatta la griglia in linee con avanzamenti di riga come la maggior parte degli altri linguaggi 2D. Invece |è usato come separatore di linea. Dal momento che non ho usato |per nessun'altra lingua, potrei semplicemente mettere un |sull'ultima riga che rende l'intero resto del programma una sola riga per quanto riguarda BF.js. Il codice rilevante è quindi questo (trasformando |in un vero avanzamento riga):

v19977/2{...
        }+++++[>++++++++++<-]>.--..++++++.@

BF.js non utilizza <v>^né i mirror. L'unico modo per reindirizzare il flusso di controllo è con {}cui ruotare la direzione IP di 90 °. Quindi quelle parentesi graffe spostano l'IP sulla seconda riga. Il resto è una semplice soluzione Brainfuck (non particolarmente ben equipaggiata) che imposta una cella su 50(punto di codice di 2) e quindi stampa 2006spostando il valore di un po '. @termina il programma.

2008: BrainSpace 1.0

Per quest'anno volevo davvero usare DOBELA che utilizza più punti di ingresso e sembra il figlio d'amore di Fission e Ziim . Sfortunatamente, non sono stato in grado di far funzionare l'interprete. Quindi ecco un altro derivato BF (l'ultimo, lo prometto).

A differenza dell'ultimo, questo conosce sia i <v>^ mirror che i mirror, quindi il codice rilevante è:

v
\'\
  8

  \ *              ++++++++++++++++++++++++  ++++++++++++++++++++++++  ++O--OO++++++++OX

Questo non ha il solito []loop in stile BF (invece avresti bisogno di formare un vero loop 2D), quindi ho appena deciso di codificare il codice 50dato che avevo comunque una tonnellata di caratteri di fila da Wierd. Si noti che 'e 8sono ignorati, *è un trampolino condizionale che possiamo ignorare e quello di OBrainfuck .. Il Xtermina il programma.

2009: > <>

Probabilmente il Fungeoid più popolare (diverso dallo stesso Befunge) almeno da queste parti. > <> ha entrambi <v>^e mirror ma anche string letterali, quindi il codice eseguito è questo:

v
\'\02'oo100@n590@n;

Il valore letterale della stringa serve principalmente a saltare quello che \abbiamo usato per BrainSpace 1.0 ma mentre ci siamo, potremmo anche spingere i primi due caratteri. ooli stampa. Quindi 100spinge tre cifre, @spinge quella superiore in fondo e nstampa la parte 0inferiore. Facciamo di nuovo la stessa cosa con 590cui stampa il file 9. Se ti stai chiedendo perché non sto solo stampando così 2009com'è, attendi il 2015. ;termina il programma.

2010: cardinale

Questo era semplice, perché ha un punto di ingresso esplicito su %. Tuttavia, questo crea 4 IP in tutte le direzioni (quindi il nome della lingua, suppongo), e dobbiamo eliminarne 3. Ecco il codice pertinente:

 x
x%"2010"x
 x

Bene sì. (In Cardinale, la modalità stringa viene stampata direttamente invece di spingere i personaggi in una pila.)

2011: RunR

Un'altra lingua con un punto di ingresso esplicito (di David Catt che ha creato alcuni altri esolang molto carini), questa volta a S. Questo rende il codice rilevante questa parte:

S1^2^2^6^8MAOUOAOOF

RunR è un po 'interessante perché la maggior parte delle operazioni funziona con una sorta di registro e i valori devono essere spostati nello stack esplicitamente per le operazioni binarie. Le cifre impostano i valori del registro su se stessi e ^inseriscono il registro corrente nello stack. Quindi Mè la moltiplicazione (valore dei tempi di registro spuntato dallo stack), Uè la sottrazione, Aè l'addizione, Oviene emessa. Ftermina il programma.

2012: Ropy

Come Wierd, Ropy cerca di seguire sezioni di caratteri non spaziali, ma qui le curve non determinano i comandi. In effetti, si scopre che Ropy è più simile al mio labirinto in quanto la direzione scelta dipende dalla parte superiore della pila. Tuttavia, non abbiamo davvero bisogno di preoccuparci di questo qui, perché Ropy si muove solo lungo la prima linea:

v19977/2{@{{4{\_______>/02&&&#????

Ci sono molte cose che possiamo ignorare fino a >. Tutto quello che dobbiamo sapere è che la parte superiore della pila sarà a quel punto a 4e ci sarà 2sotto.

>duplica la divisione is 4, /trasformandola in a 1. Quindi spingiamo 02. &&&unisce i primi quattro numeri dello stack in ordine inverso, dando 2012. #lo emette. ????cancella semplicemente lo stack perché altrimenti viene emessa anche la parte superiore dello stack.

Un punto di interesse è che il secondo 7in 19977fu aggiunta per le ropy. La /divisione in Ropy fa top / second(al contrario del solito ordine in molte lingue basate sullo stack), dove 7 / 9darebbe 0. Se avessimo uno zero in cima allo stack, Ropy farebbe alcune cose selvagge con la sua direzione di movimento, quindi dobbiamo spingere l'altro 7per garantire che la parte superiore dello stack rimanga positiva e Ropy continui a spostarsi verso est.

2014: Fissione

Con i suoi punti di accesso espliciti, questo è facile. RDLUcreare atomi (puntatori di istruzioni) nella direzione corrispondente, quindi il bit rilevante è proprio questo:

R"2014";

Nota che c'è anche un Ucodice sorgente, ma quell'atomo alla fine colpisce uno dei *da Wierd, che termina il programma (e questo atomo impiega molto più tempo del Rnecessario per stampare 2014).

2015: Gol> <>

Derivato più potente> <> di Sp3000. È ampiamente retrocompatibile con> <> quindi il codice eseguito è ancora:

v
\'\02'oo100@n590@n;

Tuttavia, la direzione di rotazione di è @stata cambiata, che è il trucco standard per distinguere> <> e Gol> <> nei poliglotti, quindi questo stampa 15invece di 09. Da qui la stranezza nella seconda metà del programma.

2016: CSL

CSL è piuttosto interessante in quanto i comandi non vengono eseguiti immediatamente. Invece, ogni comando viene inserito in uno stack di comandi ee Epuò essere utilizzato per eseguire comandi da esso. Il codice rilevante diventa:

v19977/2{@{{4{\_______>/02&&&#????        *    P+++++1P1P-1P+1E

Quindi Eesegue l'intero stack di comandi, il che significa che le cose di fronte vengono eseguite al contrario. Dobbiamo solo cercare di *:

1+P1-P1P1+++++P*

Le 1s si spingono nello stack di dati. +e -sono decremento / incremento. Pstampa la parte superiore della pila. Quindi *tenta di moltiplicare i primi due valori dello stack. Tuttavia, lo stack è vuoto, quindi questo termina il programma.

A questo punto arriviamo alle lingue che sono state rilasciate dopo che questa sfida è stata pubblicata, quindi non le conto davvero per il punteggio, specialmente da quando le ho create io stesso (non tenendo presente questa sfida). Tuttavia, hanno alcune nuove semantiche sui movimenti IP, che hanno reso più semplice inserirle nel poliglotta, aggiungendo allo stesso tempo qualcosa di interessante a questa vetrina di linguaggi 2D.

2017: Alice

Alice è stata progettata per essere un Fungeoid ricco di funzionalità. Una differenza interessante rispetto alla maggior parte degli altri (ma non tutti) altri linguaggi 2D è che l'IP può spostarsi in modo ortogonale o diagonale. Il passaggio da una all'altra cambia anche la semantica di quasi tutti i comandi nella lingua. Inoltre, Alice supporta sia i <^>vsetter di direzione tradizionali che i \/mirror, ma i mirror hanno un comportamento davvero unico in Alice (il che rende semplice condurre l'IP di Alice a una parte del codice finora inutilizzata).

Mentre la maggior parte delle lingue tratta \e /come se fossero specchi con un angolo di 45 ° e l'IP come un raggio di luce che rimbalza su di esso, Alice li considera come aventi un angolo di 67,5 ° (che è più vicino all'angolo dei veri e propri glifi) e anche l'IP si sposta attraverso il mirror (da cui il nome della lingua). A causa di questo angolo, gli specchi passano dal movimento lungo le direzioni ortogonali o diagonali. Inoltre, mentre è in modalità Ordinale (cioè mentre l'IP si sposta lungo le diagonali), la griglia non si avvolge e invece l'IP rimbalza sui bordi (mentre in modalità Cardinale si avvolge).

Tutto sommato, il codice eseguito da Alice è il seguente:

v19
\ \

...

  >      "7102"4&o@

...

L'IP inizia come sempre nell'angolo in alto a sinistra, lo vinvia a sud. Ora \riflette l'IP per spostarsi a nord-ovest, dove rimbalza immediatamente sul bordo sinistro della griglia (e si sposta invece a nord-est). 1può essere ignorato, l'IP rimbalza sul bordo superiore per spostarsi a sud-est successivo. Ne colpiamo un altro \che riflette l'IP a nord. 9può anche essere ignorato e quindi l'IP si sposta in fondo alla griglia. Dopo un paio di righe lo reindirizziamo verso est >per comodità. Quindi "7102"invia i punti di codice di 2017, 4&ostampa quei quattro caratteri e @termina il programma.

2018: Wumpus

Wumpus è il primo linguaggio 2D su una griglia triangolare, che rende il movimento attraverso il codice abbastanza diverso (e di nuovo ci permette di raggiungere facilmente una parte inutilizzata del codice). Quindi, invece di pensare a ciascun personaggio della griglia come a un quadratino, dovresti pensarli come triangoli verso l'alto e verso il basso. L'angolo in alto a sinistra è sempre un triangolo verso l'alto.

Wumpus non ha settatori di direzione simili <^>v, ma ha specchi \/. Tuttavia, a causa della griglia triangolare, funzionano diversamente dalla maggior parte delle altre lingue. L'IP li rimbalza come un raggio di luce (come al solito) ma dovresti pensare che abbiano un angolo di 60 ° gradi. Quindi un IP che si sposta verso est finirà per spostarsi lungo l'asse nord-ovest della griglia.

Come altra differenza rispetto alla maggior parte delle altre lingue, i bordi della griglia non si avvolgono, ma l'IP rimbalza invece dai bordi (come se quelle celle del bordo contenessero i mirror appropriati). Un altro piccolo dettaglio divertente è che le diagonali attraverso la griglia triangolare sembrano effettivamente scale nel codice sorgente.

Con questo in mente, il codice eseguito da Wumpus è il seguente (dove ho sostituito gli spazi .per chiarezza:

v19977/
   02
  89
 ..
..
.....*...#2018O@

L' v19977sono solo spazzatura che possiamo ignorare. /invia l'IP a nord-ovest, dove si sposta di nuovo attraverso 977(da destra) mentre rimbalza sul bordo superiore. Quindi l'IP si sposta a sud-ovest attraverso 2089e un gruppo di spazi, prima di colpire il bordo sinistro per essere nuovamente riflesso ad est. *è anche spazzatura. Quindi #2018spinge 2018, Ostampa e @termina il programma.

Anni mancanti

Infine, alcune note sugli anni che non ho trattato.

Durante la ricerca di linguaggi 2D per trovare quelli adatti negli anni che potrebbero essere utilizzati in un poliglotta, ho scoperto che contrariamente alla credenza popolare, Befunge non era il primo linguaggio 2D. Questo titolo sembra essere detenuto da Biota, che era già stato creato nel 1991. Sfortunatamente, la lingua non ha alcun output, quindi non sono stato in grado di usarlo per questa sfida.

Per quanto ne so, non sono stati creati linguaggi 2D nel 1992 e 1995. Ciò lascia alcuni anni che non ho trattato:

• 1994: viene creata Orthagonal , indipendentemente da Befunge. Le lingue sono semanticamente abbastanza simili in realtà, ma Orthagonal in realtà non stabilisce il codice sorgente in 2D. Invece ogni riga è una (x, y, instruction)tupla. Ho anche ottenuto le specifiche del linguaggio e l'interprete originale dal creatore Jeff Epler, ma alla fine, il fatto che la sintassi non sia 2D ha reso il linguaggio inadatto per questo poliglotta.
• 1996: viene creato Orthogonal , un successore di Orthagonal (creato da qualcun altro), ma ai fini di questo poliglotta soffre gli stessi problemi di Orthagonal.
• 1999: L'unica lingua che sono riuscito a trovare è l'automa cellulare REDGREEN di Chris Pressey . Sfortunatamente, a differenza del suo predecessore RUBE, non sembra avere alcuna semantica I / O.
• 2000: C'è un altro automa cellulare di Chris Pressey chiamato noit o 'mnain worb, ma non ha alcun I / O. C'è anche Numberix che non ho provato a far funzionare e non sono sicuro che ignorerebbe i caratteri non esadecimali nel codice sorgente.
• 2002: C'è Clunk senza I / O e ZT le cui specifiche linguistiche mi terrorizzano.
• 2007: ho trovato tre lingue qui. Zetaplex è basato sull'immagine (quindi no ) e RubE On Conveyor Belts sembra richiedere un'intestazione con un formato piuttosto rigoroso che avrebbe incasinato la prima riga del programma. C'è anche Cellbrain di Quintopia, ma sembra richiedere anche un'intestazione specifica.
• 2013: Ancora una volta, ho trovato tre lingue. La pesca potrebbe essere possibile con una buona ristrutturazione ma richiederebbe che il programma inizi con un bacino valido. Quipu , dalla memoria, è troppo severo per la sua sintassi per consentire molto poliglottaggio. E Swordfish è un altro membro della famiglia> <>, ma sfortunatamente non sono stato in grado di trovare un interprete. Altrimenti, questo sarebbe probabilmente abbastanza facile da aggiungere.

Se qualcuno è interessato, ecco l'elenco completo dei linguaggi 2D implementati ordinati per anni per quanto li ho trovati (al momento in cui questa risposta è stata pubblicata). Se qualcuno manca da questo elenco, per favore fatemelo sapere in chat poiché sarei davvero interessato a un elenco completo.

15 anni, Python

Versioni: 0.9.1 , 2.0.0 , 2.2.0, 2.2.2, 2.5.0, 2.5.1, 3.0.0, 3.1.0, 3.1.3, 3.2.1, 3.3.0, 3.3.3, 3.4.0, 3.5.0 e 3.6.0a4 . Le versioni non collegate sono disponibili nella pagina dei download .

La data di rilascio di 0.9.1 è disponibile qui . Sfortunatamente ho dovuto saltare un sacco di anni a causa della mancanza di vecchie versioni e problemi di compilazione sul mio computer. Gli anni rappresentati sono 1991, 2000-2002 e 2006-2016.

Testato su Arch Linux, usando le versioni gzip.

# Note: This file needs a trailing newline due to 0.9.1

# 0.9.1: No bitwise operators
# This one errors out by division by zero.
try:
    eval('1&2')
except:
    print(1991)
    1/0

import sys

# 2.0.0: repr('\n') gives "'\012'" instead of "'\n'"
# == doesn't exist until Python 0.9.3 and <> doesn't exist in Python 3, hence we
# use <. Also, 0.9.1 doesn't have double quoted strings.
if repr('\n') < '\'\\n\'':
    print(2000)
    sys.exit()

# 2.2.0: email module still has a _Parser class - module revamped in 2.2.2
# I would use whether or not True exists as a name here, but weirdly "True"
# worked in 2.2.2 even though the docs say it was introduced in 2.3...
try:
    import email
    email._Parser
    print(2001)
    sys.exit()
except AttributeError:
    pass

# 2.2.2: a in b only works for strings a of length 1.
try:
    eval('"art" in "Martin"')
except TypeError:
    print(2002)
    sys.exit()

# 2.5.0: int() allows null bytes in integer to convert when given an explicit
# base.
try:
    print(int('2006\x00Hello, World!', 10))
    exit()
except ValueError:
    pass

# 2.5.1: pow overflows
# Note that we can't use ** here since that doesn't exist in 0.9.1.
if pow(2, 100) < 1:
    print(2007)
    exit()

# 3.0.0: round returns a float rather than an int.
if str(round(1, 0)) > '1':
    print(2008)
    exit()

# 3.1.0: bug caused complex formatting to sometimes drop the real part.
if format(complex(-0.0, 2.0), '-') < '(-':
    print(2009)
    exit()

# 3.1.3: str of a float is shorter than the repr of the same float.
if str(1.0/7) < repr(1.0/7):
    print(2010)
    exit()

# 3.2.1: For some weird reason, u'...' Unicode strings were disabled then
# re-enabled later.
try:
    eval('u"abc"')
except:
    print(2011)
    exit()

# 3.3.0: int still works without a first argument.
try:
    int(base=10)
    print(2012)
    exit()
except TypeError:
    pass

# 3.3.3: no enum module :(
try:
    import enum
except ImportError:
    print(2013)
    exit()

# 3.4.0: PEP 448 (additional unpacking generalisations) not implemented yet
try:
    eval('[*[1], *[2], *[3]]')
except SyntaxError:
    print(2014)
    exit()

# 3.5.0: No f-strings
try:
    eval('f"abc"')
except SyntaxError:
    print(2015)
    exit()

print(2016)

Corto e dolce; i tre APL ( K , J201 , Dyalog 7.1 ) in 8 byte

1993+1^2

1993 plus ...

K: il primo 1 intero {0} tranne {2}, ovvero {0}; 1993 - Provalo online!

J: 1 ² = 1; 1994 - Provalo online!

APL: LCM (1,2) = 2; 1995 - Provalo online!

10 anni, 12 lingue, 2430 byte

Questa risposta è una collaborazione tra me e l'utente 1000000000 .

Un breve elenco di lingue:

Brainfuck    1993
Befunge      1993
Piet         2001
Whitespace   2003
Braincopter  2005
Grass        2007
Starry       2008
Paintfuck    2008
Brainbool    2010 (11111011010)
Python 2.7.2 2011
Fission      2014
Brainflak    2016 

Ecco il codice:

P3v="";print(sum([ord(x)for x in"~~~~~~~~~~~~~~~y"]));"""{}{}     + + +---[.     + +..  '.. +. +.. +. +. +.] + + + + + + +(((((()()()()){}){}){}){})({({} +-[<() + + + + + + +>-()])}{}<[. + + + + + + + +..-------  `             +.[-]]>)[< '
 17 12 
# > 7*::,8 +:,,2 +,@<>R"2014";]*ne*e*es*s*swWWW*swWWWW*sw*e*e*e*eeev*wn*n*n*n*ne*e*se*s*s*s*sWWwWWWw**e*eeee*vwn*n*n*n*ne*e*se*s*s*s*sWWWw*eeee*e*ne*n*nWWWWWw*ne*nWWWWWWw*w*sw*se*sWWWWWWWw*s*WWWWWWwwwWWWWWWWWWWwWWWWWWWWWWwvwWWWwWWWWwvwWWwWWWwvwWWwWWWwvwWWwWWWwvwWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwv `
255 0 255 255   0   192 192 0   192 192 0 192 192   192 255
255 192
255 255 192
255
255
0 255 255 0 255 255 0 255 255 0 255 255 0 192 192 192 255 255 255 255 255 0 192 192 0 0 255 255 255
255 0 0 255 0 192 192 0 192 192 0 192 192 192 255 255 192 255 255 192 255 255 192 255 255 0 255 255 0 255 255 0 255 255 0 192 192 255 255 255 255 255 255 255 255 255 255 255 255 0 192
192 0 0 255 0 192 192 0 192 192 0 192 192 0 192 192 192 255 255 192 255 255 192 255 255 0 255 255 0 255 255 0 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 255 255
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 192
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 0 255 255 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 255 255
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 192
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0
192 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0 0 0 0 0 255 255
255 0 192 192 0 0 255 0 0 255 255 255 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 255 255 255 255 255 255 0 0 255 0 0 255 0 255 255 0 0 0 0 192 192 0 0
255 0 192 192 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 0 255 0 255 255 0 0 0 0 192 192 0 192 192
#   """

Per adattarlo a una risposta, rinuncerò a interi collegamenti TIO e invierò semplicemente un collegamento a un interprete valido in cui il codice può essere inserito dall'utente. Ecco un link Pastebin a tale scopo.

Piet

Il formato di file PPM , uno dei formati di immagine che l'interprete Piet che abbiamo usato può leggere, ha una versione ASCII in chiaro. Usando questo siamo stati in grado di incorporare il codice di altre lingue come spazzatura nel file di immagine letto da Piet e Braincopter.

L'immagine si presenta così:

Non tutta l'immagine è importante per Piet. Ecco una versione con una linea che evidenzia il percorso che Piet segue attraverso il codice:

Nonostante i metodi un po 'contorti per creare il programma, il programma stesso è abbastanza semplice. Lungo la parte superiore dell'immagine spinge 1 10 10 10 2verso la pila; lungo il lato si moltiplica tre volte e aggiunge una volta. Nell'angolo in basso produce il risultato (2001) e poi si ferma.

Braincopter

Braincopter è l'altro linguaggio visivo. Si basa anche sullo stesso ppmfile di immagine per l'esecuzione. A causa delle severe restrizioni in npiet, il nostro codice Braincopter può utilizzare solo un sottoinsieme delle operazioni originali di Braincopter. Siamo limitati all'uso di colori che sono operazioni valide in Piet. Ciò rimuove l' -operatore da Braincopter.

Ecco il percorso tracciato dal codice Braincopter:

Il programma Braincopter è un po 'strano a causa della mancanza di un -operatore. Le pareti di ciano e ciano scuro servono per reindirizzare il puntatore ma a parte questo è identico al seguente brainfuck:

++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++..+++++.

Questo stampa 2005.

Paintfuck

Paintfuck è il terzo linguaggio di programmazione visiva nella nostra lista, tuttavia invece di acquisire un'immagine e produrre testo, Paintfuck accetta il testo e produce un'immagine.

Poiché Paintfuck ignora i caratteri non pertinenti poiché la maggior parte del codice non è importante. La sezione pertinente del codice è:

nsn**ne*e*es*s*sw*sw*sw*e*e*e*eee*wn*n*n*n*ne*e*se*s*s*s*sww**e*eeee*wn*n*n*n*ne*e*se*s*s*s*sw*eeee*e*ne*n*nw*ne*nw*w*sw*se*sw*s*wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwnsn**ne*e*es*s*sw*sw*sw*e*e*e*eee*wn*n*n*n*ne*e*se*s*s*s*sww**e*eeee*wn*n*n*n*ne*e*se*s*s*s*sw*eeee*e*ne*n*nw*ne*nw*w*sw*se*sw*s*wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

Sebbene non siano vietati, la ws alla fine del codice non fa nulla. Sono lì per la porzione di erba della soluzione. n, e, s, E wsono utilizzati per spostarsi intorno all'immagine e *viene utilizzato per tracciare un punto in certa posizione. Il programma genera:

Una versione più grande:

Brainfuck

Come Paintfuck Brainfuck ignora la maggior parte dei personaggi. Ancora una volta ecco quelli importanti:

 []+++---[.++....+.+..+.+.+.]++++++++-[<+++++++>-]<[.++++++++..-------+.[-]]>[<>,+,,+,<>]

La maggior parte di questo è ulteriormente irrilevante dalle circostanze e capita solo di essere caratteri di cui aveva bisogno qualche altra lingua. La versione più sottile di questo codice è:

+++++++[<+++++++>-]<[.++++++++..------.[-]]

Questo stampa semplicemente 1993.

Brainbool

Brainbool è molto simile a Brainfuck nella sua selezione di personaggi. La grande differenza che consente di intrecciare i due è la mancanza di un -Brainbool. I personaggi importanti per Brainbool sono:

[]+++[.++....+.+..+.+.+.]++++++++[<+++++++>]<[.++++++++..+.[]]>[<>,+,,+,<>]

Le uscite di Brainbool e Brainfuck si escludono a vicenda. Brainbool nasconde il suo output nel secondo set di []. Brainfuck si incontra +++---prima che raggiunga il [settaggio a zero e lo fa saltare l'output, mentre Brainbool vede solo +++impostarlo su 1 facendolo passare attraverso il loop. Allo stesso modo Brainbool è impostato a zero al 4 ° loop causando il salto mentre Brainfuck entra nel loop con un valore di 49.

Poiché Brainbool non ha un output decimale, genera il 2010 in binario:

11111011010

scissione

L'unica parte del codice che è importante per la fissione è:

R"2014";

L' Revocazione in un atomo si sposta verso destra, le "2014"stampe 2014e l' ;esecuzione viene interrotta.

Befunge

Befunge passa solo attraverso i seguenti personaggi:

P3v
  7
  > 7*::,8 +:,,2 +,@

La P3sono necessarie per creare un'immagine .ppm valido per piet, e cumulativamente spingere 3 alla pila. la vè disposto per reindirizzare il puntatore verso il basso. Quindi passa attraverso il 7in 17usato per indicare la larghezza dell'immagine .ppm. Il >reindirizza il puntatore verso destra. 7*moltiplica la parte superiore dello stack per 7 lasciando 49 (valore ASCII di 1) nella parte superiore dello stack. ::duplica due volte la parte superiore della pila. L' 1è uscita da ,. 8 +aggiunge 8 all'incremento superiore in ASCII 9. :,,uscite 9due volte. 2 +incrementa l'ASCII 1in un ASCII 3e ,stampa. Finalmente @termina il programma.

Tutto sommato stampa 1993.

Lo spazio bianco

Lo spazio bianco, come potrebbe suggerire il nome, utilizza solo lo spazio bianco nei suoi programmi. Ecco cosa vede l'interprete di Whitespace:

[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][LF]
[Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Tab][Tab][Tab][Tab][Tab][Space][Tab][Space][Space][Tab][Tab][LF]
[Tab][LF]
[Space][Tab][LF]
[LF]
[LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][Space][LF]
[Space][Space][Space][LF]

La maggior parte di ciò che fa questo codice è irrilevante per l'esecuzione del programma (tutte le righe che contengono solo spazi spingono semplicemente zero nello stack). La parte importante:

[Space][Space][Space][Tab][Tab][Tab][Tab][Tab][Space][Tab][Space][Space][Tab][Tab][LF]
[Tab][LF]
[Space][Tab][LF]
[LF]
[LF]

La prima riga spinge il 2003 nello stack. Dopodiché [Tab][LF][Space][Tab]stampa la parte superiore della pila (2003) come numero. Infine, gli ultimi tre avanzamenti di riga terminano l'esecuzione del programma.

Erba

Erba ignora tutti i caratteri fino alla prima wnel file e dopo che tutti i caratteri che non sono w, Wo v. L'interprete Grass recita:

wWWWwWWWWwv
wWWwWWWwv
wWWWwWWWWWwWWWWWWwwwWWWWWWWwWWWWWWwwwWWWWWWWWWWwWWWWWWWWWWwv
wWWWwWWWWwv
wWWwWWWwv
wWWwWWWwv
wWWwWWWwv
wWWwwwwwwwwwwwWWWwWWWWWwWWWWWWWwWWWWWWWWWwWWWWWWWWWWWWWWWwWWWWWWWWWWWWwv

La prima riga definisce una funzione che aggiunge due a tutto ciò che viene passato. La seconda riga definisce una funzione che aggiunge quattro a tutto ciò che viene passato. Il terzo definisce una funzione che stampa due più l'argomento, poi stampa l'argomento due volte, quindi infine stampa sette più l'argomento (Grass stampa i caratteri in base al valore ASCII). La quarta, quinta e sesta riga definiscono funzioni che aggiungono otto, aggiungono 16, aggiungono 32 e aggiungono 64 al loro argomento, rispettivamente. L'ultima riga definisce la funzione principale che accetta il carattere w(l'unico numero predefinito in Grass, valore ASCII 119) e ne aggiunge 185 usando le funzioni di aggiunta definite nel programma e la funzione di aggiunta incorporata. L'erba avvolge i numeri a 256 e quindi il risultato è 48 (corrispondente al personaggio0). La funzione quindi passa questo alla funzione della terza riga che stampa 2007.

Stellato

Starry ignora tutto tranne che per lo spazio, +, *, ., ,, `, e '. Quindi l'interprete stellato vede solo:

       + + +.     + +..  '.. +. +.. +. +. +. + + + + + + + + + + + + + + +. + + + + + + + +..  `             +. '
     *, +,, +,************************************************* `

Tuttavia, l'etichetta e le istruzioni di salto vengono utilizzate per saltare sezioni del codice che potrebbero causare problemi se eseguite, quindi il codice è effettivamente questo:

       + + +.     + +..  '  `             +. ' `

Questo codice ne spinge due nello stack, lo duplica due volte, quindi si apre e ne stampa uno come numero. Quindi spinge zero, lo duplica e stampa entrambi gli zeri come numeri. Successivamente si apre uno dei due e salti e quindi spinge sette nello stack e si apre e stampa è come un numero. Alla fine fa scoppiare gli ultimi due nello stack e passa alla fine del programma.

Python 2.7.2

Il codice Python segue il formato:

P3v="";print(sum([ord(x)for x in"~~~~~~~~~~~~~~~y"]));"""..."""

dove ...sostituisce tutta l'altra spazzatura.

La prima riga P3v=""è lì perché, per essere un .ppmfile valido, il nostro codice deve iniziare con P3questo, normalmente si verificherà un errore, ma se diciamo a Python è una dichiarazione variabile che lo ignorerà.

Quindi dobbiamo stampare 2011. Tuttavia, a causa del modo in cui a .ppmè formattato, non possiamo includere alcun numero in questa riga. Per ovviare a questo, riassumiamo tutti i valori ASCII della stringa "~~~~~~~~~~~~~~~y"e stampiamo il risultato. Infine usiamo le triple virgolette di un commento multilinea in modo che Python ignori tutto il resto.

Brainflak

Abbiamo risparmiato il meglio per ultimo.

Brainflak, come altri, ignora la maggior parte dei personaggi. I personaggi rilevanti sono:

(([()])){}{}[](((((()()()()){}){}){}){})({({}[<()>()])}{}<[[]]>)[<><>]

Il codice Python (([()])), spinge due volte -1 nello stack, quindi deve essere rimosso prima che il programma inizi l'elaborazione.

Dopo di che []Brainbool usa un nilad che non fa nulla e il programma inizia.

(((((()()()()){}){}){}){})({({}[<()>()])}{}<[[]]>)spinge il 2016. L'ultimo [<><>]è ciò che resta di Befunge e Brainfuck ma per fortuna non fa nulla.

Quando il programma termina, stampa il contenuto dello stack, ovvero stampa 2016.

5 anni

#define q/*-[>+<-----]>--.++++++++..------.[-][
print('2010'if len(bin.__doc__)==86else'2015')
"""*/
main(c){c=-4.5//**/
-4.5;printf("19%d",90-c);}
#define w/*]
*/"""

1989: C89 ^[1] e 1999: C99

Il commento a riga singola è //stato aggiunto in C99, quindi un compilatore C89 avrebbe letto quel codice come c=-4.5 / /*comment*/ -4.5, che è lo stesso di c=-4.5 / -4.5, mentre un compilatore C99 avrebbe letto come c=-4.5 //comment/**/
- 4.5, che è lo stesso di c=-4.5 - 4.5.
La parte Python è un commento nel programma C.

2010: Python 2.7 e 2015: Python 3.5

I documenti variano tra Python 3 e 2, questo programma utilizza la lunghezza dei documenti per rilevare la versione di Python.
La parte C è in una stringa nel programma Python.

1993 ^[2] : Brainfuck

In pratica ignora tutto ciò che non lo è .,[]+-<>. Dal momento che il programma C ha un ,in esso, ho dovuto costringere Brainfuck a chiudere quella parte impostando il byte corrente su 0.

1. La specifica C89 è stata rilasciata nel 1990. Ulteriori informazioni .
2. Non sono riuscito a trovare una data di uscita ufficiale, quindi crederò a Esolangs e Wikipedia .

15 anni, JavaScript

Poiché il ciclo di rilascio di JavaScript è molto insolito e incoerente, userò l'implementazione di Firefox. Per favore fatemi sapere se questo non è permesso.

Versioni: Phoenix 0.1 , Firebird 0.6 , Firefox 1.0.0 , 1.5.0 , 2.0.0 , 3.0 Beta 1 , 3.0.0 , 3.5.0 , 3.6.0 , 4.0.0 , 10.0.0 , 18.0.0 , 27.0 .0 , 35.0.0 , 44.0.0 (tutti testati su Windows 7)

Nota importante: l' installazione e l'apertura di Firefox 1.0.0 o versioni successive potrebbero cancellare tutti i dati di Firefox salvati , inclusi cronologia e segnalibri.

Inoltre, a partire dalla 1.0.0, è possibile avere una sola versione aperta alla volta; il tentativo di aprire un'altra versione si traduce in una nuova finestra della versione già aperta.

Istruzioni

• Opzione 1: salva il codice qui sotto sul tuo computer come documento HTML e aprilo in ciascun browser.
• Opzione 2: aprire https://ethproductions.github.io/js-year-test.html in ciascun browser.

Codice

<script onbeforeunload="123">
// This uses document.write because alert does nothing in Phoenix (Firefox) 0.1.
document.write((function () {
    function assert (code) {
        try {
            eval(code);
            return true;
        } catch (e) {
            return false;
        }
    }

    // Firefox 44 supports octal and binary literals in Number(); Firefox 35 does not.
    if (Number("0o1") === 1)
        return 2016;

    // Firefox 35 supports template strings; Firefox 27 does not.
    if (assert("`abc`"))
        return 2015;

    // Firefox 27 supports argument spreading; Firefox 18 does not.
    if (assert("Math.max(...[1, 2, 3])"))
        return 2014;

    // Firefox 18 supports default arguments; Firefox 10 does not.
    if (assert("function q(a = 1) { }"))
        return 2013;

    // Firefox 10 has basic WeakMap support; Firefox 4 does not.
    if (assert("WeakMap.a"))
        return 2012;

    // Firefox 4 has basic typed array support; Firefox 3.6 does not.
    if (assert("Int8Array.a"))
        return 2011;

    // Firefox 3.6 added the async attribute to script elements.
    if (assert("document.getElementsByTagName('script')[0].async.a"))
        return 2010;

    // Firefox 3.5 added the String.prototype.trim() method.
    if (assert("'abc'.trim()"))
        return 2009;

    // Firefox 3.0 added partial support for object destructuring.
    if (assert("var {c} = {c: 7}"))
        return 2008;

    // Firefox 3.0 beta 1 added the Array.prototype.reduce() and Array.prototype.reduceRight() methods.
    if (assert("[].reduce.a"))
        return 2007;

    // Firefox 2.0 added support for restricted words as properties.
    if (assert("({if:1}).if"))
        return 2006;

    // Firefox 1.5 added the Array.prototype.indexOf() methods, along with a couple other Array methods.
    if (assert("[1].indexOf(1)"))
        return 2005;

    // Practically the only JS difference between v0.6 and v1.0 is the addition of the onbeforeunload event.
    if (assert("document.getElementsByTagName('script')[0].onbeforeunload.a"))
        return 2004;

    // The Object.prototype.eval() method was removed in Firebird 0.6.
    if (!assert("'abc'.eval()"))
        return 2003;

    // We're all the way back to the good old Phoenix 0.1 browser...
    return 2002;
})());
</script>

6 lingue, Turtlèd e brainfuck , Python 3.5, Python 2.7, > <> , Fissione

Turtlèd non esisteva prima di quest'anno, e così facilmente obiettivo, anche se i commit di github non contano, e BF ha le prove della pagina esolang, rilasciate nel 1993. Python 3.5 è il 2015, la 2.7 è il 2010.> <> ha anche la pagina esolang , dichiarando 2009, così come Fission, 2014

#-[>+<-----]>--.++++++++..------#"2016"/
print(2015 if len(len.__doc__)==42 else 2010)
#;                           oooo"2009"/
#;"4102"L

Probabilmente dovrei dare credito alla pagina delle costanti di bf sugli esolang ... ¯ \ _ (ツ) _ / ¯

Come funziona, tipo di:

Turtlèd:

Turtlèd non fa davvero nulla per le linee diverse dalla prima:

#-[>+<-----]>--.++++++++..------#"2016"/
  ^sets string variable to this   ^ prints 2016

/ è un nop

Brainfuck

Brainfuck ignora i caratteri non nei suoi comandi

vede -[>+<-----]>--.++++++++..------.(l'ultimo. proviene dalla parte di Python)

che fa solo cose Brainfuck, usa il wrapping per dividere 255 per 5, quindi sottrarre 2 dal risultato, stampare, incrementare 8 volte, stampare due volte, diminuire 6 volte, stampare

Python 2 e 3

print(2015 if len(len.__doc__)==42 else 2010)

la lunghezza dei documenti per len varia tra le versioni, quindi stampa l'anno per la versione 3 se è la lunghezza giusta, altrimenti per la versione 2.

> <>

# riflette il puntatore all'indietro, quindi colpisce / sull'altro lato di quella linea, passa attraverso lo spazio tra elsee 2010, quindi riflette di nuovo per colpire "2009", spingendo 9,0,0,2 nello stack, quindi stampando al contrario .

scissione

Fission ha spawner, quindi possiamo avere una linea in fondo che esegue da sola:

#;"4102"L
        L spawn left moving atom
  "4102"  print this right to left
 ;        halt
# python comment

3 anni, 3 lingue: C, TeX, MIXAL

*main(){puts("1990");}/*\newwrite\O\openout\O=O\write\O{1982}\bye                                                                                                                              
START   ENTA    1997
        CHAR
        STX     6
        OUT     6(19)
        HLT
        END     START   */ 

Assegna un nome al file date.mixal.

1. C (1990) - Compila con avvisi e stampe 1990per stdout.
2. TeX (1982) - Compila con tex date.mixal; stampa 1982sul file O.tex(ignora l'uscita DVI).
3. MIXAL (1997) - Compilare usando GNU Mix Development Kit, mixasm date.mixaled eseguire con mixvm -r date.mix; stampa 1997sul dispositivo teletype (= stdout).

I programmi TeX e MIXAL sono in un commento nel programma C; il programma MIXAL viene dopo \byequindi TeX lo ignora. I programmi C e TeX sono un commento nel programma MIXAL. Per qualche motivo gccè disposto ad accettare *main.

3 anni (GolfScript, CJam, MATL), 24 23 byte

[A11]Wd%;200 1e2/0 8_+(

Questo produce

• 2007 in GolfScript.

• 2015 in CJam (versione 0.6.5).

• 2016 in MATL (versione 19.2.0).

Spiegazione

Golfscript

I token non definiti sono noops in GolfScript . Le uniche parti del codice che effettivamente fanno qualcosa sono:

200      Push 200
           STACK: 200
1        Push 1
            STACK: 200, 1
/        Divide
           STACK: 200
0        Push 0
           STACK: 200, 0
8        Push 8
           STACK: 200, 0, 8
+        Add
           STACK: 200, 8
(        Subtract 1
           STACK: 200, 7
         Implicitly display 200, 7 as "2007"

CJam

[A11]    Push array [10 11]
           STACK: [10 11]
W        Push -1
           STACK: [10 11], -1
d        Convert to double
           STACK: [10 11], -1.0
%        Select elements from array
           STACK: [11 10]
;        Pop
           STACK is empty
200      Push 200
           STACK: 200
1e2      Push 100
           STACK: 100
/        Divide
           STACK: 2
0        Push 0
           STACK: 2, 0 
8_       Push 8 and duplicate
           STACK: 2, 0, 8, 8
+        Add
           STACK: 2, 0, 16
(        Subtract 1
           STACK: 2, 0, 15
         Implicitly display 2, 0, 15 as "2015" 

MATL

Tutto da allora in %poi è un commento.

[A11]    Push array [5 11]
           STACK: [5 11]
W        2 raised to that
           STACK: [32 2048]
d        Compute increment
           STACK: 2016
         Implicitly display as "2016"

2 lingue, Python 2.7 e Python 3.5

Python 2.7 è stato rilasciato nel 2010 .

Python 3.5 è stato rilasciato nel 2015 .

print('2010'if 3/2==1else'2015')

Questo si basa su PEP 238 in cui l'operatore è /stato cambiato dalla divisione intera in Python 2 alla divisione in virgola mobile in Python 3.

8 anni, TI-Basic

Disp 1996           <-- TI-83
Text(-1,1,1,1
ClrHome
Disp 1999           <-- TI-83+ OS 1.03 (initial OS)
sub(1
ClrHome
Disp 2002           <-- TI-83+ OS 1.15
isClockOn
ClrHome
Disp 2004           <-- TI-84+ OS 2.21
invT(e,1
ClrHome
Disp 2005           <-- TI-84+ OS 2.40
CLASSIC
ClrHome
Disp 2009           <-- TI-84+ OS 2.53
BackgroundOn
ClrHome
Disp 2013           <-- TI-84+ Color Silver Edition
Send({1
ClrHome
2015                <-- TI-84+ Color Edition OS 5.1

"Qualsiasi programma può stampare su STDERR o generare errori e avvisi in fase di runtime / compilazione purché l'output corretto sia ancora stampato su STDOUT o su un file." Attualmente, l'unica visualizzazione senza errori è l'anno, quindi stiamo rispettando questa regola. Tuttavia, se desideri invece scrivere nella memoria, sostituiscilo Disp (date)con (date)->I.

Riferimenti:

1. Date di rilascio della calcolatrice - https://epsstore.ti.com/OA_HTML/csksxvm.jsp?nSetId=74258
2. Data di rilascio di TI-83 + OS 1.15 - http://wikiti.brandonw.net/index.php?title=83Plus:OS:VersionDifferences#TIOS_1.15
3. Compatibilità con la calcolatrice - http://tibasicdev.wikidot.com/compatibility
4. TI-84 + Data di rilascio CSE - https://www.amazon.com/Texas-Instruments-Silver-Graphing-Calculator/dp/B00AWRQKDC
5. TI-84 + Data di rilascio CE - http://www.prnewswire.com/news-releases/texas-instruments-unveils-the-new-ti-84-plus-ce-300026266.html e https: // www. cemetech.net/forum/viewtopic.php?t=8870

5 anni, Go 1.0, 1.1, 1.4, 1.5, 1.6: 285 257 byte

(1.2 è stato rilasciato nel 2013 come 1.1, 1.3 nel 2014 come 1.4 e 1.7 nel 2016 come 1.6.)

Non l'ho provato su tutte le versioni perché posso accedere solo alla 1.6, ma dovrebbe funzionare in teoria! Le modifiche alla lingua avrebbero probabilmente impedito la compilazione del programma, quindi ho fatto affidamento sulle modifiche alla libreria standard.

package main
import(."fmt"
."reflect"
."time")
func main(){s:="6"
if _,e:=Parse("2016-Sep-30","2016-Sep-31");e==nil{s="5"}
if Sprint(ValueOf(0))!="0"{s="4"}
if Sprint(&map[int]int{1:1})[0]!='&'{s="3"}
if string(0xd800)==string(0xfffd){s="2"}
Print("201"+s)}

Ungolf e commentato:

package main

import (
    "fmt"
    "reflect"
    "time"
)   package main

import (
    . "fmt"
    . "reflect"
    . "time"
)

func main() {
    s := "6"
    // 1.6: time.Parse rejects invalid days
    if _, e := Parse("2016-Sep-30", "2016-Sep-31"); e == nil {
        s = "5"
    }
    // 1.5: A reflect.Value now prints what it holds, rather than use
    // its String() method
    if Sprint(ValueOf(0)) != "0" {
        s = "4"
    }
    // 1.4: Printing pointers to maps gives the map instead of the address
    if Sprint(&map[int]int{1: 1})[0] != '&' {
        s = "3"
    }
    // 1.1: Unicode surrogate halves are no longer allowed
    if string(0xd800) == string(0xfffd) {
        s = "2"
    }
    Print("201" + s)
}

4 anni, 99 byte / 77 caratteri

v=1//1;"""
 1991/*"""
for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨
"""
"
>9002nnnn;
"""#*/

Nota: non sono sicuro che gli anni siano corretti

• Python 2.7, 2010
• Javascript, 1991
• Emotinomicon, 2015
• ><>, 2009

Mi ci è voluto un po 'di tempo per capire come far lavorare insieme Python e JS.

Spiegazione

v=1//1;"""imposta la variabile vsu 1divisa per 1in Python e su 1in Javascript ( //avvia un commento in Javascript) e ;"""avvia una stringa multilinea in Python. Il ;non può essere sostituito con una nuova riga perché ciò farebbe smettere di funzionare Javascript.

1991/*"""è il resto della stringa multilinea. Lo spazio è necessario in modo che> <> non spinga 1nello stack. Poiché l'inizio della stringa multilinea faceva parte di un commento in Javascript, stampa 1991e avvia un commento multilinea.

for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨in Python, è un ciclo for che [0]scorre la lista ed esegue print 2010. Il commento è solo il codice Emotinomicon (ignora tutto ciò che non è un'emoji o una stringa). In> <>, esso ( f) spinge 15 nello stack.

Il ciclo for non può essere rimosso perché poiché l'IP di <<> sta scendendo nella colonna 1 e pnon è un comando valido in> <>. Inoltre, non è possibile sostituirlo con ifun'istruzione, poiché iè il comando per accettare input in> <>.

""" è l'inizio di una stringa multilinea.

" fa parte della stringa multilinea, necessaria per chiudere la stringa che abbiamo aperto in> <> (le prime virgolette della riga precedente hanno iniziato una stringa in> <>).

>9002nnnn;in> <>, cambia direzione IP a destra, spinge 9, 0, 0e 2, in uscita questi come i numeri e termina il programma.

"""#*/in Python, termina la stringa multilinea e inizia un commento. In Javascript, */termina il commento su più righe.

Versione bonus con Gol> <>:

5 lingue, 4 anni, 118 114 byte / 96 92 caratteri

v=1//1;"""
 1991/*"""
for i in[0]:print 2010#🔟😃😇🔟😗➕➕😨
"""
`
"
>9002nnnn;
"
>5102nnnn;
"""#*/

• Golfish v0.4.2, 2015

Explanation²

IP inizia nell'angolo in alto a sinistra, andando a destra. Lo vfa scendere.

fspinge 15.

" inizia la stringa.

` è usato per sfuggire ai personaggi, qualcosa che> <> non ha.

"dovrebbe chiudere la stringa, ma abbiamo usato `, quindi non lo farà.

> parte della stringa.

" termina la stringa.

>5102nnnn;è il codice attuale. >rende l'IP andare a destra, 5102spinge 5, 1, 0e 2, e nnnn;stampa i numeri e si conclude il programma.

7 anni, 8 browser

Non esattamente le date di rilascio della lingua perché css in realtà non ha versioni, ma le versioni del browser (potrebbe essere pensato come versioni del compilatore forse?)

Per i seguenti browser, stampa il nome del browser, la versione e la data di rilascio e nient'altro. Stampa la stessa cosa per alcune versioni successive, (vedrai che il cromo è una versione in ritardo negli screenshot perché è difficile scaricare le vecchie versioni di Chrome per numero di versione)

Potrei stampare il numero di versione che ho usato ma ho preferito mostrare la prima versione in cui è stata introdotta la funzione utilizzata.

• IE6
• IE7
• IE8
• IE9 (non testato, non ho un IE9 in giro)
• Firefox 4
• Firefox 3.6
• Chrome 18
• Chrome 21
• Browser moderni

index.html

<!DOCTYPE html>
 <html>
  <head>
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <link rel=stylesheet href=style.css>
  </head>
  <body>
    <div class=borderbox>
      <div class="inlineblock">
        &nbsp;IE6-2001
      </div>

      <div class="white">
        <div class="outofbox">
          <a href="#">IE8-2009</a>
        </div>
        <div class="inherit">
          <a href="#">IE7-2006</a>
        </div>
      </div>
    </div>
    <div class="white">
      <header class="filter-quirk filter-blur filter-blur-url">
        IE9
      </header>
    </div>
    <div class="flex white">
      Modern Browsers - 2017
    </div>
    <div class="webkit-flex">
      <div class="">
        Chrome 21-2012
      </div>
    </div>
    <div class="webkit-invert white flexdisable">
      <div class="">
        Chrome 18-2012
      </div>
    </div>

    <svg style="position: absolute; top: -99999px" xmlns="http://www.w3.org/2000/svg">

    </svg>

    <div class="filter">
      <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
        <g
           transform="scale(8)"
           aria-label="FF4"
           id="text8419">
           <rect
              style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.79374999;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
              id="rect21965"
              width="17.005648"
              height="3.9855044"
              x="-0.16825682"
              y="-0.025296567" />
          <path
             d="m 1.0052634,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 H 0.69107072 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 0.1785938 V 0.72431329 h -0.1785938 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.1793519 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 1.0052634 V 1.4155373 H 1.4848207 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8421" />
          <path
             d="m 2.9883464,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 h -0.770599 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.8527475 V 0.72431329 H 2.6741537 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 4.1624349 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 2.9883464 V 1.4155373 H 3.4679037 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8423" />
          <path
             d="M 5.6692683,1.8917872 H 4.7729923 V 1.7363445 l 0.754062,-1.28322911 h 0.277813 V 1.7561883 h 0.112448 q 0.0893,0 0.0893,0.069453 0,0.066146 -0.0893,0.066146 h -0.112448 v 0.4233333 h 0.112448 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -0.499402 q -0.0893,0 -0.0893,-0.069453 0,-0.066146 0.0893,-0.066146 h 0.251355 z m 0,-0.1355989 V 0.58871439 h -0.07938 L 4.9019713,1.7561883 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8425" />
          <path
             d="M 8.2881171,1.6077068 H 6.9585859 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 1.3295312 q 0.089297,0 0.089297,0.066146 0,0.069453 -0.089297,0.069453 z"
             style="stroke-width:0.79374999"
             id="path8422" />
          <path
             d="m 8.9582054,0.90656104 q 0,-0.14882812 0.1785937,-0.31749999 0.1819011,-0.17197916 0.4365625,-0.17197916 0.2414323,0 0.4233333,0.17197916 0.1852081,0.17197916 0.1852081,0.39687498 0,0.14882817 -0.0893,0.28111977 Q 10.006617,1.3960402 9.7056533,1.67716 L 9.0210439,2.3154672 v 0.00992 H 10.059533 V 2.2063266 q 0,-0.089297 0.06945,-0.089297 0.06614,0 0.06614,0.089297 V 2.460988 H 8.8920596 V 2.2625506 L 9.6725804,1.5283318 q 0.2315104,-0.2282031 0.3009635,-0.3307291 0.07276,-0.102526 0.07276,-0.21497396 0,-0.17197916 -0.1422132,-0.30096353 -0.1422136,-0.12898437 -0.3307292,-0.12898437 -0.1686718,0 -0.3075781,0.0992188 -0.1355989,0.0992188 -0.1752864,0.24804686 -0.019844,0.0661458 -0.069453,0.0661458 -0.023151,0 -0.042995,-0.0165365 -0.019844,-0.0198437 -0.019844,-0.0429948 z"
             style="stroke-width:0.79374999"
             id="path8424" />
          <path
             d="m 12.207981,1.3001287 v 0.3307292 q 0,0.3902604 -0.171979,0.6349999 -0.171979,0.2447396 -0.446484,0.2447396 -0.274506,0 -0.446485,-0.2447396 Q 10.971054,2.0211183 10.971054,1.6308579 V 1.3001287 q 0,-0.39356766 0.171979,-0.63830724 0.171979,-0.24473957 0.446485,-0.24473957 0.274505,0 0.446484,0.24473957 0.171979,0.24473958 0.171979,0.63830724 z M 11.589518,0.55268084 q -0.224896,0 -0.353881,0.22820312 -0.128984,0.22489584 -0.128984,0.53578124 v 0.2943489 q 0,0.3241146 0.132292,0.5457031 0.135599,0.2182813 0.350573,0.2182813 0.224895,0 0.35388,-0.2248959 0.128984,-0.2282031 0.128984,-0.5390885 V 1.3166652 q 0,-0.32411458 -0.135599,-0.54239582 -0.132292,-0.22158854 -0.347265,-0.22158854 z"
             style="stroke-width:0.79374999"
             id="path8426" />
          <path
             d="M 13.642054,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436562,-0.43656248 z"
             style="stroke-width:0.79374999"
             id="path8428" />
          <path
             d="M 15.625137,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436563,-0.43656248 z"
             style="stroke-width:0.79374999"
               id="path8430" />
          </g>
      </svg>
    </div>
    <div class="white gradient msfilter" style=color:white>
      FF3.6-2010
    </div>
  </body>
 </html>

style.css

.borderbox {
    height: 40px;
    overflow: hidden;
    padding-bottom: 100px;
}
.outofbox {
    background: blue none repeat scroll 0 0;
    margin-top: 20px;
    opacity: 0;
}
.white {
    color: white;
}
.outofbox a, .inherit a, .inherit a:visited, .outofbox a:visited {
    color: inherit;
}
.inlineblock {
    display: inline;
    width: 100%;
    zoom: 1;
    display: inline-block;
    margin-left: 100px;
    text-align: right;
}
.white header{
  color: black;
}
.absolute{
  position: absolute;
}
.flex{
  display: none;
  display: flex;
}
.flex.white{
  filter: invert(100%)
}
.webkit-flex{
  display: none;
  display: -webkit-flex;
  overflow: hidden;
  flex-flow: column;
  height: 3em;
  justify-content: flex-end;
}
.webkit-flex div{
  margin-bottom: -1.1em;
}
.flexdisable{
  display: -webkit-flex;
  overflow: hidden;
  -webkit-flex-flow: column;
  -webkit-justify-content: flex-end;
  height: 60px;
}
.flexdisable div{
  margin-bottom: -30px;
}
.filter-quirk{
  filter: url(#quirk);
}
.filter-blur{
  filter: blur(100px);
  -webkit-filter: blur(100px);
}
.webkit-blur{
  -webkit-filter: blur(100px);
}
.webkit-invert{
  -webkit-filter: invert(100%);
  filter: none;
}
.filter-url-dark{
  -webkit-filter: url(filter.svg#Invert);
  filter: url(filter.svg#Invert) invert(100%);
}
.filter-blur-url{
  filter: url(filter.svg#blur) url(filter.svg#brightness);
}
.filter{
  filter: invert(100%) brightness(100%);
  -webkit-filter: invert(100%) brightness(100%) blur(100px);
}
.filter svg{
  position: absolute;
}
.filter svg rect{
  filter: invert(100%);
  -webkit-filter: invert(100%);
}
.msfilter{
    /* IE 8 */
  -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";
  /* IE 5-7 */
  filter: alpha(opacity=0);
}
.opacity{

}
.black{
  background: black;
}
.gradient{
  width: 100px;
  background: -moz-linear-gradient( 45deg, #000, #000 );
  font-weight: bold;
}

filter.svg

    <!DOCTYPE html>
 <html>
  <head>
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <link rel=stylesheet href=style.css>
  </head>
  <body>
    <div class=borderbox>
      <div class="inlineblock">
        &nbsp;IE6-2001
      </div>

      <div class="white">
        <div class="outofbox">
          <a href="#">IE8-2009</a>
        </div>
        <div class="inherit">
          <a href="#">IE7-2006</a>
        </div>
      </div>
    </div>
    <div class="white">
      <header class="filter-quirk filter-blur filter-blur-url">
        IE9
      </header>
    </div>
    <div class="flex white">
      Modern Browsers - 2017
    </div>
    <div class="webkit-flex">
      <div class="">
        Chrome 21-2012
      </div>
    </div>
    <div class="webkit-invert white flexdisable">
      <div class="">
        Chrome 18-2012
      </div>
    </div>

    <svg style="position: absolute; top: -99999px" xmlns="http://www.w3.org/2000/svg">

    </svg>

    <div class="filter">
      <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
        <g
           transform="scale(8)"
           aria-label="FF4"
           id="text8419">
           <rect
              style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.79374999;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
              id="rect21965"
              width="17.005648"
              height="3.9855044"
              x="-0.16825682"
              y="-0.025296567" />
          <path
             d="m 1.0052634,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 H 0.69107072 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 0.1785938 V 0.72431329 h -0.1785938 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.1793519 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 1.0052634 V 1.4155373 H 1.4848207 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8421" />
          <path
             d="m 2.9883464,1.5511362 v 0.7639843 h 0.4564063 q 0.092604,0 0.092604,0.066146 0,0.069453 -0.092604,0.069453 h -0.770599 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 2.8527475 V 0.72431329 H 2.6741537 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 H 4.1624349 V 1.0484278 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 0.72431329 H 2.9883464 V 1.4155373 H 3.4679037 V 1.2667091 q 0,-0.089297 0.066146,-0.089297 0.069453,0 0.069453,0.089297 v 0.4332552 q 0,0.089297 -0.069453,0.089297 -0.066146,0 -0.066146,-0.089297 V 1.5511362 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8423" />
          <path
             d="M 5.6692683,1.8917872 H 4.7729923 V 1.7363445 l 0.754062,-1.28322911 h 0.277813 V 1.7561883 h 0.112448 q 0.0893,0 0.0893,0.069453 0,0.066146 -0.0893,0.066146 h -0.112448 v 0.4233333 h 0.112448 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -0.499402 q -0.0893,0 -0.0893,-0.069453 0,-0.066146 0.0893,-0.066146 h 0.251355 z m 0,-0.1355989 V 0.58871439 h -0.07938 L 4.9019713,1.7561883 Z"
             style="fill:#000000;stroke-width:0.79374999"
             id="path8425" />
          <path
             d="M 8.2881171,1.6077068 H 6.9585859 q -0.089297,0 -0.089297,-0.069453 0,-0.066146 0.089297,-0.066146 h 1.3295312 q 0.089297,0 0.089297,0.066146 0,0.069453 -0.089297,0.069453 z"
             style="stroke-width:0.79374999"
             id="path8422" />
          <path
             d="m 8.9582054,0.90656104 q 0,-0.14882812 0.1785937,-0.31749999 0.1819011,-0.17197916 0.4365625,-0.17197916 0.2414323,0 0.4233333,0.17197916 0.1852081,0.17197916 0.1852081,0.39687498 0,0.14882817 -0.0893,0.28111977 Q 10.006617,1.3960402 9.7056533,1.67716 L 9.0210439,2.3154672 v 0.00992 H 10.059533 V 2.2063266 q 0,-0.089297 0.06945,-0.089297 0.06614,0 0.06614,0.089297 V 2.460988 H 8.8920596 V 2.2625506 L 9.6725804,1.5283318 q 0.2315104,-0.2282031 0.3009635,-0.3307291 0.07276,-0.102526 0.07276,-0.21497396 0,-0.17197916 -0.1422132,-0.30096353 -0.1422136,-0.12898437 -0.3307292,-0.12898437 -0.1686718,0 -0.3075781,0.0992188 -0.1355989,0.0992188 -0.1752864,0.24804686 -0.019844,0.0661458 -0.069453,0.0661458 -0.023151,0 -0.042995,-0.0165365 -0.019844,-0.0198437 -0.019844,-0.0429948 z"
             style="stroke-width:0.79374999"
             id="path8424" />
          <path
             d="m 12.207981,1.3001287 v 0.3307292 q 0,0.3902604 -0.171979,0.6349999 -0.171979,0.2447396 -0.446484,0.2447396 -0.274506,0 -0.446485,-0.2447396 Q 10.971054,2.0211183 10.971054,1.6308579 V 1.3001287 q 0,-0.39356766 0.171979,-0.63830724 0.171979,-0.24473957 0.446485,-0.24473957 0.274505,0 0.446484,0.24473957 0.171979,0.24473958 0.171979,0.63830724 z M 11.589518,0.55268084 q -0.224896,0 -0.353881,0.22820312 -0.128984,0.22489584 -0.128984,0.53578124 v 0.2943489 q 0,0.3241146 0.132292,0.5457031 0.135599,0.2182813 0.350573,0.2182813 0.224895,0 0.35388,-0.2248959 0.128984,-0.2282031 0.128984,-0.5390885 V 1.3166652 q 0,-0.32411458 -0.135599,-0.54239582 -0.132292,-0.22158854 -0.347265,-0.22158854 z"
             style="stroke-width:0.79374999"
             id="path8426" />
          <path
             d="M 13.642054,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436562,-0.43656248 z"
             style="stroke-width:0.79374999"
             id="path8428" />
          <path
             d="M 15.625137,0.43692564 V 2.3253891 h 0.459713 q 0.0893,0 0.0893,0.066146 0,0.069453 -0.0893,0.069453 h -1.055026 q -0.0926,0 -0.0926,-0.069453 0,-0.066146 0.0926,-0.066146 h 0.459714 V 0.61551938 l -0.373724,0.37372394 q -0.02646,0.0264584 -0.06945,0.0264584 -0.02646,0 -0.0463,-0.0198438 -0.01654,-0.023151 -0.01654,-0.056224 0,-0.0297656 0.03638,-0.0661458 l 0.436563,-0.43656248 z"
             style="stroke-width:0.79374999"
               id="path8430" />
          </g>
      </svg>
    </div>
    <div class="white gradient msfilter" style=color:white>
      FF3.6-2010
    </div>
  </body>
 </html>

3 anni, 89 byte

Python 2, JavaScript (ES6) e Perl

eval((["1","print=_=>console.log(1995)"])[+(2/3>0)]);print(eval(("1991",1987)["$$">"0"]))

Il primo evalverrà eseguito 1su Python 2 e print=_=>console.log(1995)su JavaScript e Perl utilizzando la funzione di divisione dei numeri interi di Python 2. Questo crea una printfunzione in JavaScript e Perl si preoccupa solo silenziosamente degli errori di sintassi e continua indipendentemente.

Il secondo evalsi basa sul fatto che Perl interpola la variabile $$(PID corrente) nella stringa, il che sarà vero se confrontato (usando l' >operatore) con "0"(Python richiede una stringa in quel confronto mentre Perl si converte implicitamente in numero intero).

Avrei potuto avere il clacson in più lingue, ma volevo avere una soluzione che non abusasse dei commenti e funzionasse solo in lingue "normali".

Ho usato questa pagina di Wikipedia per recuperare gli anni da usare.

3 lingue, 3 anni

Una risposta ad hoc per divertimento.

2002!~+++++++[<+++++++>-]<[.++++++++..------.[-]] 2016 !.

• Mouse-2002 : tutto ciò che segue~è un commento e la prima parte, che potrebbe anche essere scrittaC0U!!!, viene stampata2002.

• questo commit pre-challenge di Calc : che è un interprete di calcolatrice basato su stack che ho appena progettato in C11 per la programmazione II, la parte del programma prima del primo spazio stampa un errore (consentito dalle specifiche della sfida) e2016 !.stampa2016.

• Brainfuck : stampa 1993 come visto in altre risposte. L'estraneo finale .viene ignorato da beef.

Si noti che la visualizzazione di Calc dello stack corrente < stackcon ogni riga di input non vuota fa parte del prompt >, non parte dell'output.

Microsoft Excel / Fogli Google, 22 byte

Funzione del foglio di lavoro anonimo che non accetta input e output 1987in Microsoft Excel e 2006in Fogli Google

=IfError(M(2006),1987)

Perl 5 e Perl 6 (2 anni)

my $a=2015;my @a=1994;print $a[0],"\n"

La prima versione di Perl 5 è stata nel 1994

La prima versione ufficiale di Perl 6 è stata nel 2015