Хорошее решение на 2015 год - жить более устойчиво. Начнем с переработки. Код переработки, то есть!

Ваша задача - напечатать номер 2015в STDOUT, с или без завершающего символа новой строки (и только это). Однако вы должны сделать это, переработав старый код из PPCG. Вот как это работает:

• Выберите любой ответ, опубликованный на CodeGolf.SE до 2014-12-16 00: 00: 00Z (день, когда я разместил его в песочнице). Исключение: Вы не можете использовать какие-либо ответы из прошлогоднего новогоднего задания .
• Выберите один блок кода из этого ответа (не фрагмент кода внутри строки, это должен быть отдельный абзац). Этот блок должен быть объявлен как фактический код, например, вы не можете использовать тестовые примеры или примеры выходных данных, которые используют моноширинное форматирование.
• Переставить символы в этом блоке кода, чтобы сформировать представление для этого задания. Вы можете только изменить порядок, но не добавлять и не удалять какие-либо символы. Это включает в себя новые строки.
• Вы должны показать, что исходный блок синтаксически допустим на вашем языке. В лучшем случае вы можете сделать это, показав, что он работает без ошибок во время компиляции или во время выполнения. Таким образом, хотя исходный код мог быть Java, вы могли бы использовать его для ответа в виде пробела (так как каждый файл допустим в пробеле), но, вероятно, не можете использовать его для ответа Python (так как оригинал не будет корректным синтаксисом Python ).

Обратите внимание, что ваш ответ должен игнорировать все входные и внешние состояния (включая текущую текущую дату). ЭтоНапример, может читать из STDIN до тех пор, пока не потерпит крах, если он пустой, и выдаст одинаковый вывод для всего возможного содержимого потока.

Ваш результирующий код должен быть полной программой (а не функцией или фрагментом, который предполагает среду REPL).

Это код гольф, поэтому самый короткий ответ (в байтах ) выигрывает.

Leaderboards

Я уверен, что это будет по-разному играть на разных языках. Таким образом, следующий фрагмент стека генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

# 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 байт

Оригинальный ответ (бабки!) Также в GolfScript, который , как я знаю , что это синтаксически правильным. Я тестировал на http://golfscript.apphb.com/ .

2015}{.**

Я презираю использование языков, предназначенных для игры в гольф, но мне пришлось победить в этом испытании, поэтому я предал свои ценности, опубликовав этот ответ. Я не знаю, что делают большинство персонажей на этом языке, но однажды я случайно обнаружил, просматривая ответ на GolfScript, что непревзойденный }комментарий остальной части программы. Это позволило мне игнорировать остальных персонажей.

Befunge-93, 2085 байт

Я думал, что получу удовольствие и пойду в путь, переработав лучшее из переработанного . Никаких наград за краткость здесь не собираюсь.

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

На самом деле это также полиглот для 5 языков: Befunge-93 , oOo Code , Pyth , Python 3 и Ruby. Однако, поскольку исходный код синтаксически действителен только для Befunge-93, я только считаю это.

К сожалению, в исходном коде была только одна пара []и слишком много .s, поэтому я не смог вписать Brainfuck (следовательно, код oOo).

Заметки

Это оказалось удивительно ограничительным, потому что:

• Полный набор доступных цифр 001111111222 , требующий использования ordдля Ruby и Python. В частности, нет 5, что оказалось болью для Пифта.
• Отсутствие @ означало, что pнужно было использовать его @для Befunge.
• Отсутствие * означало, что мы должны были умножить путем деления на обратное число. Весело.

Befunge-93

Программа Befunge

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

где мы пропустили бесполезные инструкции. Мы кодируем каждую цифру как разницу в значениях ASCII между символами, в частностиcabf против a.

oOo код

Соответствующий БФ

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

из которых единственная соответствующая часть

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

Pyth

Pyth выполняет только первую строку, поэтому

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

Обратите внимание, что Pyth использует префиксную нотацию, поэтому первая часть строки на самом деле

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

( Примечание: eозначает%10 )

Из-за природы Pyth, это автоматически печатается. Остальная часть строки является действительным Pyth, но предшествующий пробел перед oподавлением автоматической печати.

Python 3

Большая часть кода Python закомментирована с использованием строк, особенно большой строки в тройных кавычках в середине. Не обращая внимания на несколько случайных строк, мы имеем:

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

Первая и последняя строки синтаксически допустимы, но ничего не делают. Средние две строки выводят то, что нам нужно.

Рубин

Код Ruby похож, но мы используем heredoc вместо строки с тройными кавычками, чтобы закомментировать большую часть программы. Игнорируя некоторые случайные строки, мы имеем:

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

Еще раз, первая строка синтаксически допустима, но ничего не делает. Вторая строка печатает то, что нам нужно.

CJam, 12 байт

T~mp[]!_1+oE^

Расшифруй Кодекс тема является действительно хорошим источником для случайной печати чисел. Это было довольно весело собрать вместе :)

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

Бонусные ответы

14 байтов:

36.e8 .79e2%15

19 байтов:

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

Страус, 198

Я взволнован, чтобы получить ответ Страуса; Мне все равно, как долго. : P (это версия 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

Оригинал :

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

Все, что я изменил, было следующее:

• Обернут все, кроме 2 n15в block ( {}), который сразу же popped ( ;).

• Застрял 2 n15в конце. 2толкает 2, nтолкает 0и 15толкает 15, что в конечном итоге становится 2015при выходе.

Это на самом деле помогло мне найти ошибку: 2n15по какой-то причине не работает (печатает 215), но 2 n15и2n 15 работает. Я должен выяснить, почему это ....

Вот поисковый запрос, который я использовал, чтобы найти этот идеальный пример кода:

создано: .. 2014-12-16: код ответа: "2" код: "0" код: "1" код: "5" код: "]" код: ";"

Этот ответ будет работать для 140, но я посмотрю, смогу ли я пойти меньше ...

JavaScript, 26 байт

Оригинал :

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

Восстановленный:

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

Это просто сдвигает 4030 на один бит вправо.

CJam, 14 байтов

Это немного сложно, поэтому я должен был опубликовать его, хотя это немного долго. Оригинальный ответ также в CJam, поэтому он действителен.

Оригинальный ответ:

92e8.17 5e6.3%

Восстановленный 2015:

9.68e3 .7e2%15

Как это работает

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

Таким образом, стопка содержит 20и 15которые печатаются один за другим, печать 2015

Попробуйте это онлайн здесь

Marbelous, 54 байта

Скучный ответ (54 байта)

32303135
:R
:Q
++003333333567QQRR}0

(за которым следует тонна завершающих строк новой строки, равных 54 байта)

Оригинальный ответ

Основная доска просто сбрасывает шарики представляющие каждого из персонажей 2015. Rа такжеQ доски определены, но никогда не используются.

Альтернативный ответ (92 байта)

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

Оригинальный ответ

Пробелы в виде пустых ячеек должны быть проверены. Сначала печатается 2(0x32), а затем печатается 0x03+0x02+0x0A=0x0F=15как трехзначное десятичное число ( 015). Первые три строки ничего не делают.

Проверьте ответы здесь.

Пиф, 25

https://github.com/isaacg1/pyth

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

Вот оригинальный ответ (также написан на pyth). Я знаю, что это не очень конкурентный ответ (есть ответ на языке Python длины 26), но мне действительно понравилось придумывать этот ответ, и я думаю, что он дает довольно смешной ответ.

Объяснение:

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

По сути, это фильтрация списка первых двух миллионов чисел за совпадение с 2015 годом. Затем он обрабатывает этот список чисел как цифры из базового числа 10 МИЛЛИАРДОВ. К счастью, в диапазоне есть только одно число, равное 2015, так что вы получите 2015 * 10000000000 ^ 0, то есть всего 2015. Это займет пару секунд для запуска.

Perl, 48 байт

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

Оригинальный ответ

Python 2, 26 байт

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

Взято из самого маленького скрипта Python для печати четных чисел от 0 до 100 потока. Это, вероятно, решение @FryAmTheEggman, на которое ссылались.

Mathematica, 60 байт

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

Источник

Часть в Floorскобках - это просто набор приложений функций несуществующих функций (с которыми у Mathematica нет проблем из-за его модели символьных вычислений). Аналогично, просто написание настила и Print@2015умножение, на которое Mathematica также не жалуется. Без синтаксического сахара это было бы

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

Поскольку мы не предполагаем среду REPL, оценочный результат этого никогда не печатается (что будет Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]] ), а только побочный эффект Printфактически переходит в STDOUT.

Спасибо Sp3000 за то, что нашли источник.

> <>, 57 байт

Оригинальный код C ++, от вызова RadioASCII :

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

Переработанный код > <> (Рыба) :

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

Как и Befunge,> <> это двумерный язык на основе стека. Выполнение начинается сверху слева и изначально направо. Только первая строка программы выполняется следующим образом:

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

Теперь большой вопрос - почему код C ++ действителен> <>? В> <> есть способы изменить направление выполнения программы (в конце концов, это двумерный язык):

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

Когда код C ++ выполняется, начальная часть #отражает поток программы влево. Но> <> является тороидальным, поэтому указатель инструкции оборачивается вокруг, появляясь в конце строки, встречая точку, >которая снова направляет поток программы вправо. Затем указатель переносится обратно в #, возвращается обратно в >... и, таким образом, происходит бесконечный цикл, и ошибка не выдается.

Питон 3, 1878 байт

Очень долго, но все равно хотел поделиться

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

Взято из ответа KennyTM .

Я увидел, что 2, 0, 1 и 5 и # можно найти в коде, поэтому я переместил некоторые символы в make print(2015)и закомментировал остальные. Я также поместил импорт PIL в комментарий, чтобы он не нуждался в этой библиотеке.

PHP, 21 байт

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

Давайте попробуем это снова. Взято из другого ответа PHP из Unscramble исходного кода. Это довольно просто, но пока это самая короткая программа на языке без игры в гольф. Вы можете проверить это на http://codepad.org/15EjIYAU . Оригинальный код выглядит следующим образом:

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