Una buena resolución para 2015 es vivir de manera más sostenible. Comenzaremos reciclando. Código de reciclaje, eso es!

Su tarea es imprimir el número 2015en STDOUT, con o sin línea nueva (y solo eso). Sin embargo, debe hacerlo reciclando algún código antiguo de PPCG. Así es como funciona eso:

• Elija cualquier respuesta publicada en CodeGolf.SE antes del 2014-12-16 00: 00: 00Z (el día que publiqué esto en el sandbox). Excepción: no puede utilizar ninguna respuesta del desafío de Año Nuevo del año pasado .
• Elija un bloque de código de esa respuesta (no un fragmento de código en línea, tiene que ser un en su propio párrafo). Este bloque debe anunciarse como código real, por ejemplo, no puede usar casos de prueba o resultados de ejemplo que usen el formato monoespacio.
• Reorganice los caracteres en ese bloque de código para formar su presentación para este desafío. Solo puede cambiar el orden, no agregar ni eliminar ningún carácter. Esto incluye nuevas líneas.
• Debe poder mostrar que el bloque fuente original es sintácticamente válido en su idioma. En el mejor de los casos, puede hacerlo mostrando que se ejecuta sin errores de tiempo de compilación o tiempo de ejecución. Entonces, aunque el código original puede haber sido Java, podría usarlo para una respuesta de espacio en blanco (ya que cada archivo es válido en espacio en blanco), pero probablemente no pueda usarlo para una respuesta de Python (ya que el original no será una sintaxis de Python válida) )

Tenga en cuenta que su respuesta debe ignorar todas las entradas y el estado externo (incluida la fecha actual real). Se puede leer de STDIN, por ejemplo, con tal de que no se bloquea si está vacío, y produce la misma salida para todos los posibles contenidos de la corriente.

El código resultante debe ser un programa completo (no una función ni un fragmento que suponga un entorno REPL).

Este es el código de golf, por lo que gana la respuesta más corta (en bytes ).

Tablas de clasificación

Estoy seguro de que esto se desarrollará de manera muy diferente en diferentes idiomas. Por lo tanto, el siguiente fragmento de pila genera una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# 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 bytes

La respuesta original (¡dibs!) También está en GolfScript, que es como sé que es sintácticamente válida. Probé en http://golfscript.apphb.com/ .

2015}{.**

Desprecio el uso de idiomas diseñados para jugar al golf, pero tuve que ganar este desafío, así que traicioné mis valores publicando esta respuesta. No sé qué hacen la mayoría de los personajes en este lenguaje, pero una vez aprendí inadvertidamente, mientras pasaba por alto una respuesta de GolfScript, que un }comentario inigualable del resto del programa. Esto me permitió ignorar al resto de los personajes.

Befunge-93, 2085 bytes

Pensé que me divertiría y me volvería meta reciclando lo mejor de lo reciclado . No voy por ningún premio por brevedad aquí.

+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"

En realidad, también es un políglota para 5 idiomas: Befunge-93 , oOo Code , Pyth , Python 3 y Ruby. Sin embargo, dado que el código original solo es sintácticamente válido para Befunge-93, solo cuento eso.

Desafortunadamente, el código original tenía solo un par []y demasiados .s, por lo que no pude adaptar Brainfuck (de ahí el código oOo).

Notas

Esto resultó ser sorprendentemente restrictivo, porque:

• El conjunto completo de dígitos disponible 001111111222requiere el uso de ordRuby y Python. En particular no hay 5, lo que resultó ser un dolor para Pyth.
• La falta de @significado significaba que pdebía usarse para colocar un @Befunge.
• La falta de *significaba que teníamos que multiplicar dividiendo por el inverso de un número. Divertido.

Befunge-93

El programa Befunge es

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

donde nos hemos saltado las instrucciones inútiles. Codificamos cada dígito como la diferencia en los valores ASCII entre caracteres, específicamente cabffrente a.

oOo Code

El BF correspondiente es

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

, de los cuales la única parte relevante es

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

Pyth

Pyth solo ejecuta la primera línea, entonces

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

Tenga en cuenta que Pyth usa una notación de prefijo, por lo que la primera parte de la línea es en realidad

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

( Nota: esignifica%10 )

Debido a la naturaleza de Pyth, esto se imprime automáticamente. El resto de la línea es Pyth válida, pero el espacio anterior al anterior osuprime la impresión automática.

Python 3

La mayoría del código de Python se comenta usando cadenas, especialmente una cadena grande con comillas triples en el medio. Ignorando algunas cadenas perdidas, tenemos:

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

La primera y la última línea son sintácticamente válidas, pero no hacen nada. Las dos líneas del medio imprimen lo que necesitamos.

Rubí

El código Ruby es similar, pero estamos usando un heredoc en lugar de una cadena de tres comillas para comentar la mayor parte del programa. Ignorando algunas cadenas perdidas, tenemos:

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

Una vez más, la primera línea es sintácticamente válida, pero no hace nada. La segunda línea imprime lo que necesitamos.

CJam, 12 bytes

T~mp[]!_1+oE^

El tema Descifrar el código es una muy buena fuente para la impresión de números aleatorios. Este fue bastante divertido de armar :)

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

Bonus respuestas

14 bytes:

36.e8 .79e2%15

19 bytes:

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

Avestruz, 198

Estoy emocionado de obtener una respuesta de avestruz; No me importa cuánto tiempo sea. : P (esta es la versión 0.5.0 , por cierto)

{: 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

Original :

: 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 }

Todo lo que cambié fue lo siguiente:

• Envuelve todo lo que no sea 2 n15en un bloque ( {}) que aparece inmediatamente ( ;).

• Atrapado 2 n15al final. 2empuja una 2, nempuja una 0y 15empujones 15, que en última instancia se convierte 2015cuando la salida.

En realidad, esto me ayudó a encontrar un error: 2n15Por qué no funciona por alguna razón (imprime 215), pero ambos 2 n15y 2n 15trabajo. Tendré que descubrir por qué es eso ...

Aquí está la consulta de búsqueda que utilicé para encontrar este ejemplo de código perfecto:

creado: .. 2014-12-16 es: código de respuesta: código "2": código "0": código "1": código "5": "]" código: ";"

Esta respuesta funcionaría para 140, pero voy a ver si puedo ir más pequeño ...

JavaScript, 26 bytes

Original :

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

Reciclado:

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

Simplemente desplaza 4030 un poco a la derecha.

CJam, 14 bytes

Este es un poco complicado, así que tuve que publicarlo a pesar de que es un poco largo. La respuesta original también está en CJam, por lo que es válida.

Respuesta original:

92e8.17 5e6.3%

Reciclado 2015:

9.68e3 .7e2%15

Cómo funciona

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

Entonces la pila contiene 20y 15que se imprimen uno tras otro, imprimiendo 2015

Pruébalo en línea aquí

Maravilloso, 54 bytes

Respuesta aburrida (54 bytes)

32303135
:R
:Q
++003333333567QQRR}0

(seguido de una tonelada de nuevas líneas finales para igualar 54 bytes)

Respuesta original

El tablero principal simplemente suelta canicas que representan cada uno de los caracteres de 2015. Ry los Qtableros están definidos, pero nunca se usan.

Respuesta alternativa (92 bytes)

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

Respuesta original

Se deben verificar los espacios como celdas en blanco. Primero imprime 2(0x32), luego imprime 0x03+0x02+0x0A=0x0F=15como un decimal de tres dígitos ( 015). Las primeras tres líneas no hacen nada.

Prueba las respuestas aquí.

Pyth, 25

https://github.com/isaacg1/pyth

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

Aquí está la respuesta original (también escrita en pyth). Sé que esta no es una respuesta muy competitiva (hay una respuesta de pitón de longitud 26), pero realmente disfruté planteándola, y creo que resulta una respuesta bastante chistosa.

Explicación:

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

Básicamente, esto es filtrar una lista de los primeros dos millones de números por ser igual a 2015. Luego, trata esta lista de números como los dígitos de un número base de 10 MIL MILLONES. Afortunadamente, solo hay un número igual a 2015 en el rango, por lo que obtienes 2015 * 10000000000 ^ 0, que es solo 2015. Esto toma un par de segundos para ejecutarse.

Perl, 48 bytes

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

Respuesta original

Python 2, 26 bytes

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

Tomado del script Python más pequeño para imprimir números pares de 0 a 100 hilos. Esta es probablemente la solución a la que @FryAmTheEggman aludía.

Mathematica, 60 bytes

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

Fuente

La parte entre Floorparéntesis es solo una serie de aplicaciones de funciones de funciones no existentes (con las que Mathematica no tiene problemas, debido a su modelo de cálculo simbólico). Del mismo modo, solo escribir el piso y Print@2015es multiplicación, de lo que Mathematica tampoco se queja. Sin el azúcar sintáctico, sería

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

Dado que no estamos asumiendo un entorno REPL, el resultado evaluado de esto nunca se imprime (lo que sería Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), sino que solo el efecto secundario de la Printrealidad pasa a STDOUT.

Gracias a Sp3000 por subir la fuente a esto.

> <>, 57 bytes

Código original de C ++, del desafío RadioASCII :

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

Reciclado > <> (Pescado) código:

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

Al igual que Befunge,> <> es un lenguaje 2D basado en pila. La ejecución comienza desde la parte superior izquierda e inicialmente es hacia la derecha. Solo se ejecuta la primera línea del programa, de la siguiente manera:

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

Ahora la gran pregunta es: ¿por qué el código C ++ es válido> <>? En> <> hay formas de cambiar la dirección del flujo del programa (después de todo, es un lenguaje 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

Cuando se ejecuta el código C ++, la inicial #refleja el flujo del programa hacia la izquierda. Pero> <> es toroidal, por lo que el puntero de instrucción se envuelve, aparece desde el final de la línea y se encuentra con el >que dirige el flujo del programa hacia la derecha nuevamente. Luego, el puntero vuelve al #, rebota al >... y, por lo tanto, se produce un bucle infinito y nunca se produce un error.

Python 3, 1878 bytes

Muy largo, pero quería compartir de todos modos:

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

Tomado de la respuesta de KennyTM .

Vi que 2, 0, 1 y 5 y # se podían encontrar en el código, así que moví algunos caracteres para hacer print(2015)y podría comentar el resto. También puse la importación PIL en el comentario para que no requiera esa biblioteca.

PHP, 21 bytes

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

Intentemos esto de nuevo. Tomado de otra respuesta PHP de Descifrar el código fuente. Es bastante básico, pero hasta ahora es el programa más corto en un idioma que no es de golf. Puede verificarlo en http://codepad.org/15EjIYAU . El código original es el siguiente:

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