Une bonne résolution pour 2015 est de vivre plus durablement. Nous allons commencer par le recyclage. Le code de recyclage, c'est!

Votre tâche consiste à imprimer le numéro 2015sur STDOUT, avec ou sans retour à la ligne (et seulement cela). Cependant, vous devez le faire en recyclant un ancien code de PPCG. Voici comment cela fonctionne:

• Choisissez n'importe quelle réponse publiée sur CodeGolf.SE avant le 2014-12-16 00: 00: 00Z (le jour où j'ai posté ceci dans le bac à sable). Exception: vous ne pouvez pas utiliser les réponses du défi du Nouvel An de l'an dernier .
• Choisissez un bloc de code dans cette réponse (pas un extrait de code en ligne, il doit être un sur son propre paragraphe). Ce bloc doit être annoncé en tant que code réel, par exemple, vous ne pouvez pas utiliser de cas de test ou d'exemple de sortie qui utilisent le formatage monospace.
• Réorganisez les caractères dans ce bloc de code pour former votre soumission pour ce défi. Vous pouvez uniquement modifier l'ordre, pas ajouter ou supprimer de caractères. Cela inclut les nouvelles lignes.
• Vous devez être en mesure de montrer que le bloc source d'origine est syntaxiquement valide dans votre langue. Dans le meilleur des cas, vous pouvez le faire en montrant qu'il s'exécute sans erreurs de compilation ou d'exécution. Ainsi, bien que le code d'origine ait pu être Java, vous pouvez l'utiliser pour une réponse Whitespace (car chaque fichier est valide dans Whitespace), mais vous ne pouvez probablement pas l'utiliser pour une réponse Python (car l'original ne sera pas une syntaxe Python valide). ).

Notez que votre réponse doit ignorer toutes les entrées et l'état externe (y compris la date actuelle réelle). Il peut lire STDIN, par exemple, tant qu'il ne plante pas s'il est vide, et produit la même sortie pour tous les contenus possibles du flux.

Votre code résultant doit être un programme complet (pas une fonction, ni un extrait de code qui suppose un environnement REPL).

Il s'agit du code golf, donc la réponse la plus courte (en octets ) l'emporte.

Classements

Je suis sûr que cela se jouera très différemment dans différentes langues. Ainsi, l'extrait de pile suivant génère à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

La réponse originale (dibs!) Se trouve également dans GolfScript, c'est ainsi que je sais qu'elle est syntaxiquement valide. J'ai testé sur http://golfscript.apphb.com/ .

2015}{.**

Je méprise l'utilisation de langues conçues pour le golf, mais j'ai dû gagner ce défi, j'ai donc trahi mes valeurs en publiant cette réponse. Je ne sais pas ce que la plupart des personnages font dans ce langage, mais j'ai appris par inadvertance, en parcourant une réponse GolfScript, qu'un }commentaire inégalé sur le reste du programme. Cela m'a permis d'ignorer le reste des personnages.

Befunge-93, 2085 octets

Je pensais que je m'amuserais et que je ferais du méta en recyclant le meilleur du recyclé . Je ne vais pas chercher de prix pour la brièveté ici.

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

Il s'agit en fait également d'un polyglotte pour 5 langues: Befunge-93 , oOo Code , Pyth , Python 3 et Ruby. Cependant, étant donné que le code d'origine n'est valide que sur le plan syntaxique pour Befunge-93, je ne compte que cela.

Malheureusement, le code d'origine ne comportait qu'une paire []et trop de .s, donc je n'ai pas pu intégrer Brainfuck (d'où le code oOo).

Remarques

Cela s'est révélé étonnamment restrictif, car:

• L'ensemble complet de chiffres disponibles est 001111111222, nécessitant l'utilisation de ordpour Ruby et Python. En particulier, il n'y en a pas 5, ce qui s'est avéré être une douleur pour Pyth.
• L'absence de @signifiait qu'il pfallait utiliser pour placer un @pour Befunge.
• Le manque de *signifiait que nous devions multiplier en divisant par l'inverse d'un nombre. Amusement.

Befunge-93

Le programme Befunge est

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

où nous avons ignoré les instructions inutiles. Nous chiffrons chaque chiffre que la différence des valeurs ASCII entre caractères, en particulier par cabfrapport à a.

oOo Code

Le BF correspondant est

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

, dont la seule partie pertinente est

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

Pyth

Pyth n'exécute que la première ligne, donc

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

Notez que Pyth utilise une notation de préfixe, donc la première partie de la ligne est en fait

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

( Remarque: esignifie%10 )

En raison de la nature de Pyth, cela est automatiquement imprimé. Le reste de la ligne est Pyth valide, mais l'espace précédent avant le osupprime l'impression automatique.

Python 3

La majorité du code Python est commentée en utilisant des chaînes, en particulier une grande chaîne entre guillemets triples au milieu. Ignorant quelques chaînes errantes, nous avons:

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

La première et la dernière ligne sont syntaxiquement valides, mais ne font rien. Les deux lignes du milieu indiquent ce dont nous avons besoin.

Rubis

Le code Ruby est similaire, mais nous utilisons un heredoc au lieu d'une triple chaîne entre guillemets pour commenter la plupart du programme. En ignorant certaines chaînes errantes, nous avons:

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

Encore une fois, la première ligne est syntaxiquement valide, mais ne fait rien. La deuxième ligne imprime ce dont nous avons besoin.

CJam, 12 octets

T~mp[]!_1+oE^

La rubrique Déchiffrer le code est une très bonne source pour l'impression de nombres aléatoires. Celui-ci était assez amusant à reconstituer :)

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

Réponses bonus

14 octets:

36.e8 .79e2%15

19 octets:

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

Autruche, 198

Je suis ravi de recevoir une réponse d'Autruche; Je me fiche de combien de temps c'est. : P (c'est la version 0.5.0 , soit dit en passant)

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

Tout ce que j'ai changé, c'est ce qui suit:

• Enveloppé tout autre que 2 n15dans un bloc ( {}) qui est immédiatement sauté ( ;).

• Coincé 2 n15à la fin. 2pousse un 2, npousse un 0et 15pousse 15, ce qui devient finalement 2015lors de la sortie.

Cela me fait aidé à trouver un bug: 2n15ne fonctionne pas pour une raison quelconque (il imprime 215), mais les deux 2 n15et le 2n 15travail. Je vais devoir comprendre pourquoi c'est ...

Voici la requête de recherche que j'ai utilisée pour trouver cet exemple de code parfait:

créé: .. 2014-12-16 est: code de réponse: code "2": code "0": code "1": code "5": "]" code: ";"

Cette réponse fonctionnerait pour 140, mais je vais voir si je peux aller plus petit ...

JavaScript, 26 octets

Original :

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

Recyclé:

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

Il décale simplement 4030 d'un bit vers la droite.

CJam, 14 octets

Celui-ci est un peu délicat, j'ai donc dû le poster même s'il est un peu long. La réponse originale est également dans CJam, donc c'est valable.

Réponse originale:

92e8.17 5e6.3%

Recyclé 2015:

9.68e3 .7e2%15

Comment ça marche

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

Donc, la pile contient 20et 15qui sont imprimées les unes après les autres, impression 2015

Essayez-le en ligne ici

Marbelous, 54 octets

Réponse ennuyeuse (54 octets)

32303135
:R
:Q
++003333333567QQRR}0

(suivi d'une tonne de sauts de ligne pour atteindre 54 octets)

Réponse originale

Le plateau principal laisse simplement tomber des billes représentant chacun des personnages de 2015. Ret les Qtableaux sont définis, mais jamais utilisés.

Réponse alternative (92 octets)

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

Réponse originale

Les espaces en tant que cellules vides doivent être vérifiés. Cela imprime d'abord 2(0x32), puis imprime 0x03+0x02+0x0A=0x0F=15sous forme de décimal à trois chiffres ( 015). Les trois premières lignes ne font rien.

Testez les réponses ici.

Pyth, 25

https://github.com/isaacg1/pyth

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

Voici la réponse originale (également écrite en pyth). Je sais que ce n'est pas une réponse très compétitive (il y a une réponse en python de longueur 26), mais j'ai vraiment apprécié de proposer cela, et je pense que cela se traduit par une réponse plutôt humoristique.

Explication:

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

Fondamentalement, cela filtre une liste des deux premiers millions de nombres pour qu'ils soient égaux à 2015. Ensuite, il traite cette liste de nombres comme les chiffres d'un nombre de base de 10 MILLIARDS. Heureusement, il n'y a qu'un seul nombre égal à 2015 dans la plage, vous obtenez donc 2015 * 10000000000 ^ 0, qui est juste 2015. Cela prend quelques secondes pour s'exécuter.

Perl, 48 octets

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

Réponse originale

Python 2, 26 octets

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

Tiré du plus petit script python pour imprimer les nombres pairs de 0 à 100 thread. C'est probablement la solution à laquelle @FryAmTheEggman faisait allusion.

Mathematica, 60 octets

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

La source

La partie Floorentre crochets n'est qu'une série d'applications fonctionnelles de fonctions inexistantes (avec lesquelles Mathematica n'a pas de problème, en raison de son modèle de calcul symbolique). De même, il suffit d'écrire le sol et de Print@2015multiplier, ce dont Mathematica ne se plaint pas non plus. Sans le sucre syntaxique, il serait

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

Puisque nous ne supposons pas un environnement REPL, le résultat évalué de celui-ci n'est jamais imprimé (ce qui serait le cas Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), mais seul l'effet secondaire de la Printva réellement à STDOUT.

Merci à Sp3000 d'avoir tourné la source vers cela.

> <>, 57 octets

Code C ++ original, issu du challenge RadioASCII :

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

Code recyclé > <> (poisson) :

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

Comme Befunge,> <> est un langage 2D basé sur la pile. L'exécution commence en haut à gauche et est initialement à droite. Seule la première ligne du programme est exécutée, de la manière suivante:

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

Maintenant, la grande question est - pourquoi le code C ++ est-il valide> <>? Dans> <> il y a des façons de changer la direction du déroulement du programme (c'est un langage 2D, après tout):

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

Lorsque le code C ++ est exécuté, l'initiale #reflète le flux du programme vers la gauche. Mais> <> est toroïdal, donc le pointeur d'instructions s'enroule, apparaissant à la fin de la ligne, rencontrant à nouveau le >flux de programme qui dirige vers la droite. Le pointeur revient ensuite au #, rebondit au >... et ainsi une boucle infinie se produit et une erreur n'est jamais levée.

Python 3, 1878 octets

Très long, mais je voulais quand même partager:

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

Tiré de la réponse de KennyTM .

J'ai vu que 2, 0, 1 et 5 et # pouvaient être trouvés dans le code, j'ai donc déplacé quelques caractères pour faire print(2015)et commenter le reste. J'ai également mis l'importation PIL dans le commentaire afin qu'il ne nécessite pas cette bibliothèque.

PHP, 21 octets

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

Essayons à nouveau. Tiré d' une autre réponse PHP de Déchiffrer le code source. C'est assez basique, mais jusqu'à présent c'est le programme le plus court dans une langue non golfique. Vous pouvez le vérifier sur http://codepad.org/15EjIYAU . Le code d'origine est le suivant:

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