Ein guter Vorsatz für 2015 ist, nachhaltiger zu leben. Wir beginnen mit dem Recycling. Recycling-Code, das ist!

Ihre Aufgabe ist es, die Nummer 2015mit oder ohne Zeilenumbruch an STDOUT zu senden (und nur das). Allerdings müssen Sie dies tun , indem das Recycling einige alte Code aus PPCG. So funktioniert das:

• Wählen Sie eine Antwort aus, die vor dem 16.12.2014 00: 00: 00Z auf CodeGolf.SE veröffentlicht wurde (an dem Tag, an dem ich dies in der Sandbox veröffentlicht habe). Ausnahme: Sie dürfen keine Antworten aus der letztjährigen Neujahrs-Challenge verwenden .
• Wählen Sie einen Codeblock aus dieser Antwort aus (kein Inline-Codeausschnitt, sondern ein eigener Absatz). Dieser Block muss als tatsächlicher Code angekündigt werden, z. B. können Sie keine Testfälle oder Beispielausgaben verwenden, die eine Monospace-Formatierung verwenden.
• Ordnen Sie die Zeichen in diesem Codeblock neu an, um Ihre Übermittlung für diese Herausforderung zu bilden. Sie dürfen nur die Reihenfolge ändern, keine Zeichen hinzufügen oder entfernen. Dies schließt Zeilenumbrüche ein.
• Sie müssen nachweisen können, dass der ursprüngliche Quellblock in Ihrer Sprache syntaktisch gültig ist. Im besten Fall können Sie dies tun, indem Sie zeigen, dass es ohne Kompilierungs- oder Laufzeitfehler ausgeführt wird. Während der ursprüngliche Code möglicherweise Java war, können Sie ihn für eine Whitespace-Antwort verwenden (da jede Datei in Whitespace gültig ist), aber möglicherweise nicht für eine Python-Antwort (da das Original keine gültige Python-Syntax hat) ).

Beachten Sie, dass Ihre Antwort alle Eingaben und den externen Status (einschließlich des aktuellen Datums) ignorieren muss. Es kann beispielsweise aus STDIN lesen, solange es nicht abstürzt, wenn es leer ist, und für alle möglichen Inhalte des Streams dieselbe Ausgabe erzeugt.

Der resultierende Code muss ein vollständiges Programm sein (weder eine Funktion noch ein Snippet, das eine REPL-Umgebung voraussetzt).

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes ).

Bestenlisten

Ich bin mir sicher, dass dies in verschiedenen Sprachen sehr unterschiedlich ausfallen wird. Das folgende Stack-Snippet generiert daher sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# 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

Die ursprüngliche Antwort (dibs!) Ist ebenfalls in GolfScript, daher weiß ich, dass sie syntaktisch gültig ist. Ich habe auf http://golfscript.apphb.com/ getestet .

2015}{.**

Ich verabscheue die Verwendung von Sprachen, die für das Golfen entwickelt wurden, aber ich musste diese Herausforderung gewinnen, also habe ich meine Werte durch das Posten dieser Antwort verraten. Ich weiß nicht, was die meisten Charaktere in dieser Sprache tun, aber ich habe versehentlich beim Überfliegen einer GolfScript-Antwort erfahren, dass ein unübertroffener }Kommentar den Rest des Programms auskommentiert . Dies erlaubte mir, den Rest der Charaktere zu ignorieren.

Befunge-93, 2085 Bytes

Ich dachte, ich hätte Spaß und würde Meta machen, indem ich das Beste aus dem Recycling recycelte . Der Kürze halber werden hier keine Auszeichnungen vergeben.

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

Dies ist eigentlich auch ein Polyglot für 5 Sprachen: Befunge-93 , oOo Code , Pyth , Python 3 und Ruby. Da der ursprüngliche Code jedoch nur für Befunge-93 syntaktisch gültig ist, zähle ich das nur.

Leider hatte der ursprüngliche Code nur ein Paar []und zu viele .s, so dass ich Brainfuck nicht einbauen konnte (daher der oOo-Code).

Anmerkungen

Dies erwies sich als überraschend restriktiv, weil:

• Der vollständige verfügbare Ziffernsatz 001111111222erfordert die Verwendung von ordfür Ruby und Python. Insbesondere gibt es keine 5, was sich als Schmerz für Pyth herausstellte.
• Das Fehlen @bedeutete, dass pzur Platzierung eine @für Befunge verwendet werden musste.
• Das Fehlen von *bedeutete, dass wir multiplizieren mussten, indem wir durch die Umkehrung einer Zahl teilten. Spaß.

Befunge-93

Das Befunge-Programm ist

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

wo wir die nutzlosen Anweisungen übersprungen haben. Wir codieren jede Ziffer als Differenz der ASCII-Werte zwischen Zeichen, insbesondere cabfgegenüber a.

oOo Code

Der entsprechende BF ist

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

, von denen der einzige relevante Teil ist

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

Pyth

Pyth führt also nur die erste Zeile aus

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

Beachten Sie, dass Pyth eine Präfixnotation verwendet, der erste Teil der Zeile ist also tatsächlich

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

( Anmerkung: ebedeutet%10 )

Aufgrund der Natur von Pyth wird dies automatisch gedruckt. Der Rest der Zeile ist gültiges Pyth, aber das vorangestellte Leerzeichen vor dem ounterdrückt das automatische Drucken.

Python 3

Der Großteil des Python-Codes wird mit Strings auskommentiert, insbesondere mit einem großen String in dreifachen Anführungszeichen in der Mitte. Wenn wir ein paar Strings ignorieren, haben wir:

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

Die erste und letzte Zeile sind syntaktisch gültig, tun aber nichts. Die beiden mittleren Zeilen geben aus, was wir brauchen.

Rubin

Der Ruby-Code ist ähnlich, aber wir verwenden einen Heredoc anstelle einer dreifach zitierten Zeichenfolge, um den größten Teil des Programms zu kommentieren. Wir ignorieren einige verirrte Zeichenketten und haben:

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

Wieder ist die erste Zeile syntaktisch gültig, führt aber nichts aus. Die zweite Zeile gibt aus, was wir brauchen.

CJam, 12 Bytes

T~mp[]!_1+oE^

Das Thema Entschlüsseln des Codes ist eine gute Quelle für das Drucken von Zufallszahlen. Es hat sehr viel Spaß gemacht, diese zusammenzusetzen :)

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 Antworten

14 Bytes:

36.e8 .79e2%15

19 Bytes:

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

Strauß, 198

Ich freue mich auf eine Antwort von Ostrich. Es ist mir egal, wie lange es dauert. : P (das ist übrigens Version 0.5.0 )

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

Ich habe nur folgendes geändert:

• Umhüllt alles andere als 2 n15in einen Block ( {}), der sofort auftaucht ( ;).

• 2 n15Am Ende stecken . 2drückt a 2, ndrückt a 0und 15drückt 15, was letztendlich 2015bei der Ausgabe wird.

Das hat mir tatsächlich geholfen, einen Fehler zu finden: 2n15funktioniert aus irgendeinem Grund nicht (es wird gedruckt 215), aber beides 2 n15und 2n 15funktioniert. Ich muss herausfinden, warum das so ist ...

Hier ist die Suchanfrage, mit der ich dieses perfekte Codebeispiel gefunden habe:

Erstellt: .. 2014-12-16 ist: Antwortcode: "2" Code: "0" Code: "1" Code: "5" Code: "]" Code: ";"

Diese Antwort würde für 140 funktionieren, aber ich werde sehen, ob ich kleiner werden kann ...

JavaScript, 26 Bytes

Original :

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

Recycelt:

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

Es verschiebt nur 4030 ein Bit nach rechts.

CJam, 14 Bytes

Dieses ist ein bisschen schwierig, also musste ich es posten, obwohl es ein bisschen lang ist. Die ursprüngliche Antwort befindet sich ebenfalls in CJam, ist also gültig.

Ursprüngliche Antwort:

92e8.17 5e6.3%

Recycling 2015:

9.68e3 .7e2%15

Wie es funktioniert

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

Der Stapel enthält also 20und 15welche nacheinander gedruckt werden, Druck 2015

Probieren Sie es hier online aus

Marbelous, 54 Bytes

Langweilige Antwort (54 Bytes)

32303135
:R
:Q
++003333333567QQRR}0

(gefolgt von einer Tonne nachgestellten Zeilenumbrüchen, die 54 Bytes entsprechen)

Ursprüngliche Antwort

Auf der Hauptplatine werden einfach Murmeln abgelegt, die die einzelnen Zeichen von darstellen 2015. Rund QBoards werden definiert, aber nie verwendet.

Alternative Antwort (92 Bytes)

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

Ursprüngliche Antwort

Leerzeichen als leere Zellen sollten angekreuzt werden. Dies wird zuerst gedruckt 2(0x32) und dann 0x03+0x02+0x0A=0x0F=15als dreistellige Dezimalzahl ( 015). Die ersten drei Zeilen machen nichts.

Testen Sie die Antworten hier.

Pyth, 25

https://github.com/isaacg1/pyth

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

Hier ist die ursprüngliche Antwort (auch in Pyth geschrieben). Ich weiß, dass dies keine sehr konkurrenzfähige Antwort ist (es gibt eine Python-Antwort mit der Länge 26), aber ich habe es wirklich genossen, mir diese zu überlegen, und ich denke, es kommt eine ziemlich humorvolle Antwort heraus.

Erläuterung:

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

Grundsätzlich wird eine Liste der ersten zwei Millionen Zahlen so gefiltert, dass sie gleich 2015 ist. Anschließend wird diese Liste der Zahlen als die Ziffern einer 10-MILLIARDEN-Basiszahl behandelt. Zum Glück gibt es nur eine Zahl, die 2015 entspricht, sodass Sie 2015 * 10000000000 ^ 0 erhalten, also nur 2015. Die Ausführung dauert einige Sekunden.

Perl, 48 Bytes

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

Ursprüngliche Antwort

Python 2, 26 Bytes

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

Entnommen aus dem kleinsten Python-Skript, um gerade Zahlen von 0 bis 100 zu drucken . Dies ist wahrscheinlich die Lösung, auf die @FryAmTheEggman anspielte.

Mathematica, 60 Bytes

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

Quelle

Der Teil in FloorKlammern ist nur eine Reihe von Funktionsanwendungen nicht existierender Funktionen (mit denen Mathematica aufgrund seines symbolischen Berechnungsmodells kein Problem hat). Ebenso ist das einfache Schreiben des Bodens und Print@2015eine Multiplikation, über die sich Mathematica auch nicht beschwert. Ohne den syntaktischen Zucker wäre es

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

Da wir nicht von einer REPL-Umgebung ausgehen, wird das ausgewertete Ergebnis davon nie gedruckt (was wäre Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), sondern nur der Nebeneffekt von Printgeht tatsächlich an STDOUT.

Vielen Dank an Sp3000 für das Aufdrehen der Quelle.

> <> 57 Bytes

Ursprünglicher C ++ - Code aus der RadioASCII-Challenge :

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

Recycling- Code > <> (Fisch) :

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

Wie Befunge ist> <> eine stapelbasierte 2D-Sprache. Die Ausführung beginnt oben links und erfolgt zunächst nach rechts. Nur die erste Zeile des Programms wird folgendermaßen ausgeführt:

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

Die große Frage ist nun: Warum ist der C ++ - Code gültig> <>? In> <> gibt es Möglichkeiten, die Richtung des Programmflusses zu ändern (schließlich handelt es sich um eine 2D-Sprache):

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

Wenn der C ++ - Code ausgeführt wird, #spiegelt die Initiale den Programmfluss nach links wider. Aber> <> ist toroidal, so dass der Anweisungszeiger am Ende der Zeile erscheint und den >Programmfluss wieder nach rechts lenkt. Der Zeiger #springt dann zurück zu , springt zurück zu >... und somit tritt eine Endlosschleife auf und ein Fehler wird niemals geworfen.

Python 3, 1878 Bytes

Sehr lang, wollte aber trotzdem teilen:

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

Entnommen aus KennyTMs Antwort .

Ich habe gesehen, dass 2, 0, 1 und 5 und # im Code zu finden sind, also habe ich ein paar Zeichen verschoben, um sie zu machen, print(2015)und konnte den Rest auskommentieren . Ich habe auch den PIL-Import in den Kommentar eingefügt, sodass diese Bibliothek nicht erforderlich ist.

PHP, 21 Bytes

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

Versuchen wir es noch einmal. Entnommen aus einer anderen PHP-Antwort von Unscramble the Source Code. Es ist ziemlich einfach, aber bis jetzt ist es das kürzeste Programm in einer nicht-golfenden Sprache. Sie können es unter http://codepad.org/15EjIYAU überprüfen . Der ursprüngliche Code lautet wie folgt:

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