Una buona risoluzione per il 2015 è vivere in modo più sostenibile. Inizieremo riciclando. Codice di riciclaggio, cioè!

Il tuo compito è stampare il numero 2015su STDOUT, con o senza newline finale (e solo quello). Tuttavia, devi farlo riciclando del vecchio codice da PPCG. Ecco come funziona:

• Scegli qualsiasi risposta pubblicata su CodeGolf.SE prima del 16-12-2014 00: 00: 00Z (il giorno in cui l'ho pubblicato nella sandbox). Eccezione: non è possibile utilizzare le risposte della sfida di Capodanno dell'anno scorso .
• Scegli un blocco di codice da quella risposta (non uno snippet di codice in linea, deve essere un paragrafo a sé stante). Questo blocco deve essere pubblicizzato come codice effettivo, ad esempio non è possibile utilizzare casi di test o output di esempio che utilizzano la formattazione monospace.
• Riorganizza i personaggi in quel blocco di codice per formare la tua presentazione per questa sfida. Puoi solo cambiare l'ordine, non aggiungere o rimuovere caratteri. Questo include newline.
• Devi essere in grado di dimostrare che il blocco sorgente originale è sintatticamente valido nella tua lingua. Nel migliore dei casi puoi farlo dimostrando che funziona senza errori di compilazione o di runtime. Quindi, mentre il codice originale potrebbe essere stato Java, è possibile utilizzarlo per una risposta di Whitespace (poiché ogni file è valido in Whitespace), ma probabilmente non è possibile utilizzarlo per una risposta di Python (poiché l'originale non sarà valido sintassi di Python ).

Tieni presente che la tua risposta deve ignorare tutti gli input e lo stato esterno (inclusa la data corrente effettiva). Si può leggere da STDIN, diciamo, finché non si blocca se è vuota, e produce la stessa uscita per tutti i possibili contenuto del flusso.

Il codice risultante deve essere un programma completo (non una funzione, né uno snippet che presuppone un ambiente REPL).

Questo è il golf del codice, quindi vince la risposta più breve (in byte ).

Classifiche

Sono sicuro che questo funzionerà in modo molto diverso in diverse lingue. Quindi il seguente frammento di stack genera sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);i=i.replace("{{PLACE}}",t++ +".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=43048;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

GolfScript, 9 byte

La risposta originale (dibs!) È anche in GolfScript, ed è così che so che è sintatticamente valida. Ho provato su http://golfscript.apphb.com/ .

2015}{.**

Disprezzo l'uso delle lingue progettate per il golf, ma ho dovuto vincere questa sfida, quindi ho tradito i miei valori pubblicando questa risposta. Non so cosa faccia la maggior parte dei personaggi in questa lingua, ma una volta ho inavvertitamente appreso, scremando una risposta GolfScript, che un }commento senza eguali sul resto del programma. Questo mi ha permesso di ignorare il resto dei personaggi.

Befunge-93, 2085 byte

Ho pensato che mi sarei divertito e sarei diventato meta riciclando il meglio del riciclo . Non andare per alcun premio per brevità qui.

+2012+1+1e1 or b+bbv+b+NN
"a"""""
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

aa
AaAAaAAaAAaAAaA
eEe ddd OoOOoOOoOOoOOoOOoOOoOOoOOoOOoO ddD Ccc eEE
ccc LLl
SssSss LLl
SsS LLl
SsSSsSSsSSsS LLl
cccccc
mMm



+   +     a     pppp  pppp  y   y     n   n eeeee +     +    y   y eeeee     a     rrr    "
+   +    a a    p   p p   p  y y      nn  n e      + + +      y y  e        a a    r  r   "
+++++   aaaaa   pppp  pppp    y       n n n eee    + + +       y   eee     aaaaa   rrr    "
+   +  a     a  p     p       y       n  nn e       + +        y   e      a     a  r  r
+   + a       a p     p       y       n   n eeeee   + +        y   eeeee a       a r  r   "



Hope to see another round of awesome programming puzzles and code golf challenges

===============================
"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " ' ' ' ' '

Big char dump below (will clean up if there's more languages to squeeze in):

  $$$$$$$()++++++++++++++++++++++++++++--------------------------/////:::;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<>>>>>??AAACCDDEEEFHHLLMMMMM
NOOOOOOOOOOORRRRRRRRRSSSUUUUV[\]___aaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
bbbbbbbbbbbbbbbbbbbbbbbcccccccccccccddddddddddddddddddddddddddddddddddddddd
ddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeee
eeeeeeeeeeeeeeeeeeffffffffffghhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiilll
llllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnn
nnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooppppppppppppp
ppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssss
ssssssssssssssssssssssssstttttttttttttttttttttttttttttttttttttttttttttttttt
ttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
uuuuuuuuuuuuvvvvvvvvwwxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy
yyyyyyyyyyzz{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id
"mOO"

Questo è in realtà anche un poliglotta per 5 lingue: Befunge-93 , oOo Code , Pyth , Python 3 e Ruby. Tuttavia, poiché il codice originale è sintatticamente valido solo per Befunge-93, lo conto solo.

Sfortunatamente il codice originale aveva solo una coppia di []e troppe .s, quindi non sono stato in grado di adattare Brainfuck (da qui il codice oOo).

Gli appunti

Ciò si è rivelato sorprendentemente restrittivo, perché:

• Il set completo di cifre disponibile è 001111111222, che richiede l'uso di ordper Ruby e Python. In particolare no 5, il che si è rivelato un dolore per Pyth.
• La mancanza di @significato pdoveva essere usata per piazzare un @Befunge.
• La mancanza di *significava che dovevamo moltiplicarci dividendo per l'inverso di un numero. Divertimento.

Befunge-93

Il programma Befunge è

                   v
                   1
                   !
                   _"  fabaaaca"-.-.-.-.+"O"2::++p

dove abbiamo saltato le istruzioni inutili. Codifichiamo ogni cifra, come la differenza di valori ASCII tra i caratteri, in particolare cabfcontro a.

oOo Code

Il BF corrispondente è

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

, di cui l'unica parte pertinente è

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

Pyth

Pyth esegue solo la prima riga, quindi

+2012+1+1e1 or b+bbv+b+NN

Nota che Pyth usa una notazione con prefisso, quindi la prima parte della riga è in realtà

2012 + (1 + (1 + (1 % 10)))

( Nota: esignifica%10 )

A causa della natura di Pyth, questo viene stampato automaticamente. Il resto della linea è Pyth valido, ma lo spazio precedente alla osoppressione della stampa automatica.

Python 3

La maggior parte del codice Python è commentata usando stringhe, in particolare una grande stringa a tre virgolette nel mezzo. Ignorando alcune stringhe vaganti, abbiamo:

+2012+1+1e1 or b+bbv+b+NN
"""
...
"""
one=1
print(int(ord('A')/(one/(ord(' ')-one))))
id

La prima e l'ultima riga sono sintatticamente valide, ma non fanno nulla. Le due righe centrali stampano ciò di cui abbiamo bisogno.

Rubino

Il codice Ruby è simile, ma stiamo usando un heredoc invece di una stringa tra virgolette triple per commentare la maggior parte del programma. Ignorando alcune stringhe vaganti, abbiamo:

+2012+1+1e1 or b+bbv+b+NN
p((('?'.ord-' '.ord )/(1.0/'A'.ord)).to_i)
<<id
...
id

Ancora una volta, la prima riga è sintatticamente valida, ma non fa nulla. La seconda riga stampa ciò di cui abbiamo bisogno.

CJam, 12 byte

T~mp[]!_1+oE^

L' argomento Decodifica il codice è un'ottima fonte per la stampa di numeri casuali. Questo è stato abbastanza divertente da mettere insieme :)

T~     bitwise not of 0 is -1                     [-1]
mp     replace with 0 as -1 is not prime          [0]
[]!    not of an empty array (falsy) is 1         [0, 1]
_      copy that 1                                [0, 1, 1]
1+     add 1                                      [0, 1, 2]
o      output top of stack                        [0, 1]           2
E      push 14                                    [0, 1, 14]       2
^      bitwise xor                                [0, 15]          2
       (CJam implicitly prints stack afterwards)  []               2015

Risposte bonus

14 byte:

36.e8 .79e2%15

19 byte:

0_*1_)@@{_%\_)*\};5

Struzzo, 198

Sono entusiasta di ricevere una risposta dallo struzzo; Non mi importa quanto sia lungo. : P (questa è la versione 0.5.0 , a proposito)

{: rotate ( circ n -- )
    neg swap change-circular-start

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
 7 8 9   3 4  6 };2 n15

Originale :

: rotate ( circ n -- )
    neg swap change-circular-start ;

IN: 1 9 [a,b] <circular> dup 6 rotate >array .
{ 4 5 6 7 8 9 1 2 3 }
IN: 1 9 [a,b] <circular> dup 3 rotate >array .
{ 7 8 9 1 2 3 4 5 6 }

Tutto quello che ho cambiato è stato il seguente:

• Avvolto tutto tranne che 2 n15in un blocco ( {}) che viene immediatamente visualizzato ( ;).

• Bloccato 2 n15alla fine. 2spinge a 2, nspinge a 0e 15spinge 15, che alla fine diventa 2015quando viene emesso.

Questo in realtà mi ha aiutato a trovare un bug: 2n15non funziona per qualche motivo (stampa 215), ma entrambi 2 n15e 2n 15funzionano. Dovrò capire perché questo è ...

Ecco la query di ricerca che ho usato per trovare questo esempio di codice perfetto:

creato: .. 16-12-2014 è: codice di risposta: "2" codice: "0" codice: "1" codice: "5" codice: "]" codice: ";"

Questa risposta funzionerebbe per 140, ma vedrò se posso andare più piccolo ....

JavaScript, 26 byte

Originale :

alert(998|(103>8>0&41>-0))

riciclata:

alert(4030>>(998>1|8&1-0))

Sposta semplicemente 4030 di un bit verso destra.

CJam, 14 byte

Questo è un po 'complicato, quindi ho dovuto pubblicarlo anche se è un po' lungo. Risposta originale è in CJam, quindi è valida.

Risposta originale:

92e8.17 5e6.3%

Riciclato 2015:

9.68e3 .7e2%15

Come funziona

9.68e3 is 9680
.7e2 is 70
9680 70% is 9680%70 = 20
15 is 15

Quindi la pila contiene 20e 15che vengono stampati uno dopo l'altro, stampando il 2015

Provalo online qui

Marbelous, 54 byte

Risposta noiosa (54 byte)

32303135
:R
:Q
++003333333567QQRR}0

(seguito da una tonnellata di newline finali per equivalere a 54 byte)

Risposta originale

La scheda principale rilascia semplicemente biglie che rappresentano ciascuno dei personaggi di 2015. Re le Qschede sono definite, ma mai utilizzate.

Risposta alternativa (92 byte)

3W!!?0]]>W/\&0&1@1@0@0
      ]]>W/\&0&1@1@0@0
                @1  @0
03  02
\\  //
32+A
  Dp

Risposta originale

Gli spazi come celle vuote devono essere controllati. Questo prima stampa 2(0x32), quindi stampa 0x03+0x02+0x0A=0x0F=15come un decimale di tre cifre (015 ). Le prime tre righe non fanno nulla.

Test risposte qui.

Pyth, 25

https://github.com/isaacg1/pyth

J6ifqT++2010/JJ4U*2^TJ^TT

Ecco la risposta originale (scritta anche in Pyth). So che questa non è una risposta molto competitiva (esiste una risposta in pitone della lunghezza 26), ma mi è davvero piaciuto inventarlo, e penso che esca in una risposta piuttosto umoristica.

Spiegazione:

J6                           : J=6
  i                   ^TT    : convert_to_base(..., 10 BILLION)
   fqT          U*2^TJ       : filter(lambda T: T==..., range(2*10^6)
      ++2010/JJ4             : 2010 + J/J + 4

Fondamentalmente questo sta filtrando un elenco dei primi due milioni di numeri per essere uguale al 2015. Quindi, tratta questo elenco di numeri come le cifre di un numero base di 10 MILIARDI. Per fortuna, c'è un solo numero uguale al 2015 nell'intervallo, quindi ottieni 2015 * 10000000000 ^ 0, che è solo il 2015. L'operazione richiede un paio di secondi.

Perl, 48 byte

\d>\fDg;print ord($:)*($_=$=+/~?/)+$_|//<<(\n>n)

Risposta originale

Python 2, 26 byte

iiiceex=";;+=*";print 2015

Tratto dallo script python più piccolo per stampare numeri pari da 0 a 100 thread. Questa è probabilmente la soluzione a cui allude @FryAmTheEggman.

Mathematica, 60 byte

⌊DF@IM~RS~ad~ee~ee~ggggiiimmnnoorrrstt~.22346⌋Print@2015

fonte

La parte tra Floorparentesi è solo una serie di applicazioni di funzioni di funzioni inesistenti (con cui Mathematica non ha problemi, a causa del suo modello di calcolo simbolico). Allo stesso modo, solo scrivere il pavimento ed Print@2015è una moltiplicazione, di cui Mathematica non si lamenta. Senza lo zucchero sintattico, sarebbe

Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]] * Print[2015]

Dal momento che non stiamo assumendo un ambiente REPL, il risultato valutato di questo non viene mai stampato (che sarebbe Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), ma solo l'effetto collaterale delPrint effettivamente va a STDOUT.

Grazie a Sp3000 per aver aumentato la fonte a questo.

> <>, 57 byte

Codice C ++ originale, dalla sfida RadioASCII :

#include <cstdio>
int main(){int x;printf("Lawrencium");}

Riciclato > <> (Pesce) codice:

eclne)nfn;
   ""#(();<>Laaccddiiiiiiimmnnnoprrsttttuuwx{}

Come Befunge,> <> è un linguaggio 2D basato su stack. L'esecuzione inizia in alto a sinistra ed è inizialmente verso destra. Viene eseguita solo la prima riga del programma, nel modo seguente:

e      Push 14                          [14]
c      Push 12                          [14, 12]
l      Push the length of the stack     [14, 12, 2]
n      Output as num                    [14, 12]          2
e      Push 14                          [14, 12, 14]      2
)      Push 1 if greater than else 0    [14, 0]           2
n      Output as num                    [14]              20
f      Push 15                          [14, 15]          20
n      Output as num                    [14]              2015
;      Terminate                        [14]              2015

Ora la grande domanda è: perché il codice C ++ è valido> <>? In> <> ci sono modi per cambiare la direzione del flusso del programma (dopo tutto è un linguaggio 2D):

^>v<     Arrows which direct program flow a certain direction
_/|\     Mirrors which reflect the direction of program flow
#        Four-way mirror, reflect from all directions

Quando viene eseguito il codice C ++, l'iniziale #riflette il flusso del programma verso sinistra. Ma> <> è toroidale, quindi il puntatore dell'istruzione si avvolge, apparendo dalla fine della linea, incontrando di nuovo il >flusso del programma che dirige verso destra. Il puntatore torna quindi a #, rimbalza su >... e quindi si verifica un ciclo infinito e non viene mai generato un errore.

Python 3, 1878 byte

Molto lungo, ma volevo condividere comunque:

import sys,re,zlib as z,base64
print(2015)#,PIL.Image as ire.search(str(z.adler3(i.open(sys.argv[1]).tobytes()[2::6])%203)+'(\\D+',z.decompress(base64.b8decode(b'c${Tc%XZ>86NyfdNqBH<%b?iLI_EpFkwO-GfQC$tcfjoB$+h*^;0s?o$g*?uzgjxs%~BKif!C3zALZEU!&?wJd#-mqgS@p<P&+)AsV|c*52*C>U&(_4w^urvvWJU8Bj;bvv4ia;eiJLu+bsXLru`DjH|W<`|;xLq++kv5k8VWZgQe*`_u+opEF8>A6qjM%k#skzbiuJ7dL_*><K@9l6!M*H(|w)PZJ2`RYy7K2VVrv+zc)&2Fc?wvh|^#ksyymE?D!Q$3!LbFX%h%vT%1#lr486Iybw?0!`H)ZlZ#XIao2uXTr}(IBl@wRWHa#})bgV);O3HoW7+T*!5M3=^mu6Ri$`7L;uUWj~gsqR6gQR9h7^nKdBIgy>ats36%|M|8p1x;32(ZfK9R5_xK5ts=Sz70c%SIK&g3N1E|sg{n3>JSbKwwhssGcb$8uMNw=Nv;f_;rj?}kz(3-&#FQw@O;q(8nGHjbrTC(NQv=ckXT|eHr|amahCq(7T6<LBTr5Gj>fHV~3DcYINN!Qr`6Dl?jT>!4u5~bb%Zi6VTax;%vg*m325J_$nEC%yqbbYeEp!K_K7k)W-XCP`6+}N7tktMVX+{@c2L&kLAc&IvspGrzZ$F`uOBg}fA3W2neAU}tg~<+iCN=<sR^Zke+9WNhnCyy6!8nfa>33&OWiPt2s=OMTrUgilSYQxrG!gziB!Aj83zX&6S|yjIQkA?iF0n%?<+B=%_D11aoCv?@Q&eei{sqNkr7RG`#*xyzSUE6BUNnZK)3|3Wls}K$qaKv;jOO#!{3Ms)4CQ?shafnAF^zVq(`K9o2xL5JoQoGea+W1$+xmw&8OMOtN1Pid6UAcd+*_bB6IY$KjrO=ac^tPv3(8O`&(agOBbT{Va6s}Rm9&`I#yivC;MhW8=n+^^&Reho;~!~W<xgH6bVq3^=H7)sUXV2nv~DP4`CY`f55i&qH)DvPMQy>)y*Z=|68w@v=#oo5^RSh5R2F%1-vt>h=|+1n0pE^Yq-72!)1+o{hD_3<Cyxpyr6r%cei-AFQ*h1seM$MP>ovLS2k#Ci$to#do$s3MXu2lZsw~9HkbjVWM@1!{w>}LWVj#j2qC(+*Okc>=<qcV}*}+U_QK+(ZZ(x>ZMdDDWtgHiBK+7p6aHHI`u-h6z7|Xm`>D1t4uEp271y7oCI^{1^H~O7QRxTA_U&92Q8z$J2O|5Lbeg_0umd^pSU<%-ki7LtDvo&AgIt0h~6(y@Hr+kyLJ$<B#07KdGob0EW$7@f{GszaUv#tkpSyk759Khmvq-aiyM-_&x_VCTx$Vy<;$<k{T$-@{Mhc<<%KD1AHK^MKkg%pYIW}SxhV?&a{o9=rs@*+hqyoioE=TF>9S<KxY+^69^OA0jkS#0!w@kw4}KTcP9#+PVW+qB|7B`Y?eRs+7}8RSAs?i?-Cz#Wp(Iihd`nI!Q_i%R^o_;fvDQ5|{Cr;yWeirL>_l#(wn)$QenJkK6Sgw)5NleBzvo&G#@>X`7Ib*aS4LHx9epI%BXXV&y7LJ&54g}D25-Q8>DZQ5hGKyIeJkQQu08%j|<x~)q(AOVw9P~Z*c0Z@VM6n#<}tBT6+T%4mZ9f*y76xlEFM~o$xr9*SZHd^6D-C!pkkp3m(-~W3&>KY@106L+;I><MJ^Dz`f{(I3i?u`2pWjUjlwZx`B1JB#h#u3xTH*b1K?TG40|4lxF1$_Pw+t?h2')).decode()).group(1))

Tratto dalla risposta di KennyTM .

Ho visto che 2, 0, 1 e 5 e # potevano essere trovati nel codice, quindi ho spostato alcuni caratteri per creare print(2015)e ho potuto commentare il resto. Ho anche inserito l'importazione PIL nel commento in modo che non richieda quella libreria.

PHP, 21 byte

<?=65*4*31*2/8;//7**9

Proviamo di nuovo. Tratto da un'altra risposta PHP di Decodifica il codice sorgente. È piuttosto semplice, ma finora è il programma più breve in una lingua non golf. Puoi verificarlo su http://codepad.org/15EjIYAU . Il codice originale è il seguente:

<?=9*8*7*6*5*4/3/2/1;