Dobrym rozwiązaniem na 2015 r. Jest życie w bardziej zrównoważony sposób. Zaczniemy od recyklingu. To znaczy kod do recyklingu!

Twoim zadaniem jest wydrukowanie numeru 2015do STDOUT, z końcowym znakiem nowej linii lub bez (i tylko to). Musisz to jednak zrobić poprzez recykling starego kodu z PPCG. Oto jak to działa:

• Wybierz dowolną odpowiedź opublikowaną na CodeGolf.SE przed 16.12.2014 00: 00: 00Z (dzień, w którym opublikowałem to w piaskownicy). Wyjątek: nie możesz używać żadnych odpowiedzi z zeszłorocznego wyzwania noworocznego .
• Wybierz jeden blok kodu z tej odpowiedzi (nie wbudowany fragment kodu, musi to być własny akapit). Ten blok musi być reklamowany jako rzeczywisty kod, np. Nie można użyć przypadków testowych lub przykładowych danych wyjściowych, które zdarzają się przy użyciu formatowania w przestrzeni pojedynczej.
• Zmień układ znaków w tym bloku kodu, aby utworzyć zgłoszenie do tego wyzwania. Możesz jedynie zmienić kolejność, nie dodawać ani nie usuwać żadnych znaków. Obejmuje to nowe linie.
• Musisz być w stanie wykazać, że oryginalny blok źródłowy jest poprawny pod względem składniowym w twoim języku. W najlepszym przypadku możesz to zrobić, pokazując, że działa bez błędów kompilacji lub błędów w czasie wykonywania. Więc chociaż oryginalnym kodem mógł być Java, możesz go użyć do odpowiedzi na spację (ponieważ każdy plik jest poprawny w spacji), ale prawdopodobnie nie może użyć go do odpowiedzi w Pythonie (ponieważ oryginał nie będzie poprawną składnią Pythona ).

Pamiętaj, że twoja odpowiedź musi zignorować wszystkie dane wejściowe i zewnętrzne (w tym aktualną datę). To może czytać ze standardowego wejścia, powiedzmy, o ile nie psuje, jeśli jest pusta, i wytworzy dla wszystkich możliwych zawartości strumienia.

Wynikowy kod musi być pełnym programem (nie funkcją ani fragmentem, który zakłada środowisko REPL).

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach ).

Liderów

Jestem pewien, że będzie to wyglądać zupełnie inaczej w różnych językach. Tak więc poniższy fragment kodu generuje zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# 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 bajtów

Oryginalna odpowiedź (dibs!) Jest również w GolfScript, który jest, jak wiem, że jest składniowo poprawny. Testowałem na http://golfscript.apphb.com/ .

2015}{.**

Nienawidzę używania języków przeznaczonych do gry w golfa, ale musiałem wygrać to wyzwanie, dlatego zdradziłem swoje wartości, zamieszczając tę ​​odpowiedź. Nie wiem, co większość postaci robi w tym języku, ale kiedyś niechcący nauczyłem się, przeglądając odpowiedź GolfScript, że niedopasowane }komentarze komentują resztę programu. To pozwoliło mi zignorować resztę postaci.

Befunge-93, 2085 bajtów

Pomyślałem, że dobrze się bawię i wykorzystam meta, przetwarzając to, co najlepsze z recyklingu . Nie będzie tu żadnych nagród za zwięzłość.

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

W rzeczywistości jest to również poliglot dla 5 języków: Befunge-93 , oOo Code , Pyth , Python 3 i Ruby. Ponieważ jednak oryginalny kod jest poprawny pod względem składni tylko dla Befunge-93, liczę tylko to.

Niestety oryginalny kod miał tylko jedną parę []i za dużo .s, więc nie byłem w stanie dopasować Brainfuck (stąd kod oOo).

Notatki

Okazało się to zaskakująco restrykcyjne, ponieważ:

• Dostępny jest pełny zestaw cyfr 001111111222, wymagających użycia języka ordRuby i Python. W szczególności nie ma 5, co okazało się dla Pyth uciążliwe.
• Brak @oznacza, że ptrzeba było użyć do postawienia @Befunge.
• Brak *oznaczał, że musieliśmy pomnożyć dzieląc przez odwrotność liczby. Zabawa.

Befunge-93

Program Befunge to

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

gdzie pominęliśmy niepotrzebne instrukcje. Mamy kodować każdą cyfrę jako różnicę pomiędzy wartościami ASCII znaków, a konkretnie cabfvs. a.

oOo Code

Odpowiedni BF to

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

, którego jedyną istotną częścią jest

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

Pyt

Pyth wykonuje tylko pierwszą linię, więc

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

Zauważ, że Pyth używa notacji przedrostkowej, więc pierwsza część wiersza jest w rzeczywistości

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

( Uwaga: eoznacza%10 )

Ze względu na charakter Pyth jest on automatycznie drukowany. Reszta wiersza jest poprawna w Pyth, ale poprzedzająca ją spacja przed opomijaniem automatycznego drukowania.

Python 3

Większość kodu Pythona jest komentowana za pomocą ciągów, szczególnie dużego potrójnego cudzysłowu w środku. Ignorując kilka bezpańskich ciągów, mamy:

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

Pierwszy i ostatni wiersz są poprawne składniowo, ale nie rób nic. Dwie środkowe linie drukują to, czego potrzebujemy.

Rubin

Kod Ruby jest podobny, ale używamy heredoc zamiast potrójnego cudzysłowu, aby skomentować większość programu. Ignorując niektóre zbłąkane ciągi, mamy:

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

Ponownie pierwszy wiersz jest poprawny pod względem składniowym, ale nic nie robi. Druga linia wypisuje to, czego potrzebujemy.

CJam, 12 bajtów

T~mp[]!_1+oE^

Rozszyfrować kod wątek jest bardzo dobrym źródłem losowej drukowania numeru. Ten był fajny do złożenia :)

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

Dodatkowe odpowiedzi

14 bajtów:

36.e8 .79e2%15

19 bajtów:

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

Struś, 198

Jestem podekscytowany, że mogę uzyskać odpowiedź na strusia; Nie obchodzi mnie, jak długo to trwa. : P ( nawiasem mówiąc , to jest wersja 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

Oryginał :

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

Wszystko, co zmieniłem, to:

• Zawija wszystko inne niż 2 n15w bloku ( {}), który jest natychmiast otwierany ( ;).

• Utknął 2 n15na końcu. 2popycha a 2, npopycha a 0i 15popycha 15, co ostatecznie staje się, 2015gdy dane wyjściowe.

To rzeczywiście pomógł mi znaleźć błąd: 2n15nie działa z jakiegoś powodu (drukuje 215), ale zarówno 2 n15i 2n 15pracę. Będę musiał dowiedzieć się, dlaczego tak jest ....

Oto zapytanie, którego użyłem do znalezienia idealnej próbki kodu:

utworzono: .. 16.12.2014 jest: kod odpowiedzi: kod „2”: kod „0”: kod „1”: kod „5”: ”]„ kod: ”;”

Ta odpowiedź działałaby dla 140, ale zobaczę, czy mogę zmniejszyć ...

JavaScript, 26 bajtów

Oryginał :

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

Z recyklingu:

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

Po prostu przesuwa 4030 nieco w prawo.

CJam, 14 bajtów

Ten jest nieco trudny, więc musiałem go opublikować, chociaż jest trochę długi. Oryginalna odpowiedź znajduje się również w CJam, więc jest poprawna.

Oryginalna odpowiedź:

92e8.17 5e6.3%

Recycled 2015:

9.68e3 .7e2%15

Jak to działa

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

Tak więc stos zawiera 20i 15które są drukowane jeden po drugim, drukując 2015

Wypróbuj online tutaj

Cudowny, 54 bajty

Nudna odpowiedź (54 bajty)

32303135
:R
:Q
++003333333567QQRR}0

(po której następuje tona nowych linii do 54 bajtów)

Oryginalna odpowiedź

Płyta główna po prostu upuszcza kulki reprezentujące każdą postać 2015. Ri Qtablice są zdefiniowane, ale nigdy nie są używane.

Alternatywna odpowiedź (92 bajty)

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

Oryginalna odpowiedź

Odstępy jako puste komórki należy sprawdzić. Najpierw drukowane 2(0x32), a następnie drukowane 0x03+0x02+0x0A=0x0F=15jako trzycyfrowe dziesiętne ( 015). Pierwsze trzy linie nic nie robią.

Testuj odpowiedzi tutaj.

Pyth, 25

https://github.com/isaacg1/pyth

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

Oto oryginalna odpowiedź (również napisana w pyth). Wiem, że nie jest to bardzo konkurencyjna odpowiedź (istnieje odpowiedź python o długości 26), ale naprawdę podobało mi się wymyślanie tego i myślę, że wychodzi to dość humorystycznie.

Wyjaśnienie:

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

Zasadniczo jest to filtrowanie listy pierwszych dwóch milionów liczb za równe 2015 r. Następnie traktuje tę listę liczb jako cyfry podstawowej liczby 10 MILIARDÓW. Na szczęście w zakresie jest tylko jedna liczba równa 2015, więc otrzymujesz 2015 * 10000000000 ^ 0, czyli tylko 2015. Uruchomienie zajmuje kilka sekund.

Perl, 48 bajtów

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

Oryginalna odpowiedź

Python 2, 26 bajtów

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

Wykonano z najmniejszego skryptu Pythona, aby wydrukować parzyste liczby od 0 do 100 wątków. Prawdopodobnie jest to rozwiązanie, do którego nawiązał @FryAmTheEggman.

Mathematica, 60 bajtów

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

Źródło

Część w Floornawiasach to tylko szereg aplikacji funkcyjnych nieistniejących funkcji (z którymi Mathematica nie ma problemu ze względu na swój symboliczny model obliczeniowy). Podobnie samo pisanie podłogi i Print@2015mnożenie, na co Mathematica też nie narzeka. Bez cukru syntaktycznego byłoby

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

Ponieważ nie zakładamy środowiska REPL, wynik tego nigdy nie jest drukowany (co byłoby Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), a jedynie efekt ubocznyPrint faktycznie przechodzi na STDOUT.

Dzięki Sp3000 za zwiększenie źródła do tego.

> <>, 57 bajtów

Oryginalny kod C ++ z wyzwania RadioASCII :

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

Recycled > <> (Fish) code:

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

Podobnie jak Befunge,> <> jest językiem 2D opartym na stosie. Wykonanie rozpoczyna się od lewego górnego rogu i początkowo jest prawe. Wykonywany jest tylko pierwszy wiersz programu w następujący sposób:

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

Najważniejsze pytanie brzmi: dlaczego kod C ++ jest prawidłowy> <>? W> <> są sposoby na zmianę kierunku przebiegu programu (w końcu jest to język 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

Kiedy kod C ++ jest wykonywany, początkowy #odzwierciedla przepływ programu w lewo. Ale> <> jest toroidalne, więc wskaźnik instrukcji zawija się, pojawiając od końca linii, spotykając kierunek, >który ponownie kieruje przepływ programu w prawo. Wskaźnik następnie wraca do #, odbija się do >... i dlatego pojawia się nieskończona pętla i błąd nigdy nie jest generowany.

Python 3, 1878 bajtów

Bardzo długo, ale mimo to chciałem się podzielić:

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

Zaczerpnięte z odpowiedzi Kenny'egoTM .

Widziałem, że 2, 0, 1 i 5 i # można znaleźć w kodzie, więc przesunąłem kilka znaków, aby zrobić, print(2015)i mogłem skomentować resztę. W komentarzu umieściłem również import PIL, aby nie wymagał tej biblioteki.

PHP, 21 bajtów

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

Spróbujmy jeszcze raz. Zaczerpnięte z innej odpowiedzi PHP z Rozszyfrować kod źródłowy. Jest dość prosty, ale jak dotąd jest to najkrótszy program w języku innym niż golfowy. Możesz to sprawdzić na stronie http://codepad.org/15EjIYAU . Oryginalny kod jest następujący:

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