Recycling for the New Year

Question

A good resolution for 2015 is to live more sustainably. We'll start by recycling. Recycling code, that is!

Your task is to print the number 2015 to STDOUT, with or without trailing newline (and only that). However, you have to do so by recycling some old code from PPCG. Here is how that works:

• Pick any answer posted on CodeGolf.SE before 2014-12-16 00:00:00Z (the day I posted this in the sandbox). Exception: You may not use any answers from last year's New Year's challenge.
• Choose one code block from that answer (not an inline code snippet, it has to be a on its own paragraph). This block must be advertised as actual code, e.g. you cannot use test cases or example output which happen to use monospace formatting.
• Rearrange the characters in that code block to form your submission for this challenge. You may only change the order, not add or remove any characters. This includes newlines.
• You must be able to show that the original source block is syntactically valid in your language. In the best case you can do this by showing that it runs without compile-time or run-time errors. So while the original code may have been Java, you could use it for a Whitespace answer (as every file is valid in Whitespace), but probably can't use it for a Python answer (as the original won't be valid Python syntax).

Note that your answer must ignore all input and external state (including the actual current date). It may read from STDIN, say, as long as it doesn't crash if it's empty, and produces the same output for all possible contents of the stream.

Your resulting code has to be a full program (not a function, nor a snippet which assumes a REPL environment).

This is code golf, so the shortest answer (in bytes) wins.

Leaderboards

I'm sure this will play out very differently in different languages. So the following Stack Snippet generates both a regular leaderboard and an overview of winners by language.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

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

Answer 1

GolfScript, 9 bytes

The original answer (dibs!) is also in GolfScript, which is how I know it is syntactically valid. I tested on http://golfscript.apphb.com/ .

2015}{.**

I despise the use of languages designed for golfing, but I had to win this challenge, so I betrayed my values by posting this answer. I don't know what most of the characters do in this language, but I once inadvertently learned, while skimming a GolfScript answer, that an unmatched } comments out the rest of the program. This allowed me to ignore the rest of the characters.

Answer 2

Befunge-93, 2085 bytes

I thought I'd have fun and go meta by recycling the best of the recycled. Not going for any awards for brevity here.

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

This is actually also a polyglot for 5 languages: Befunge-93, oOo Code, Pyth, Python 3 and Ruby. However, since the original code is only syntactically valid for Befunge-93, I'm only counting that.

Unfortunately the original code had only one pair of [] and too many .s, so I wasn't able to actually fit Brainfuck in (hence the oOo Code).

---

Notes

This turned out to be surprisingly restrictive, because:

• The full set of digits available is 001111111222, requiring the use of ord for Ruby and Python. In particular there's no 5, which turned out to be a pain for Pyth.
• The lack of @ meant that p needed to be used to place an @ for Befunge.
• The lack of * meant that we had to multiply by dividing by the inverse of a number. Fun.

Befunge-93

The Befunge program is

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

where we've skipped the useless instructions. We encode each digit as the difference in ASCII values between chars, specifically cabf vs. a.

oOo Code

The corresponding BF is

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

, of which the only relevant part is

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

Pyth

Pyth only executes the first line, so

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

Note that Pyth uses an prefix notation, so the first part of the line is actually

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

(Note: e means %10)

Due to the nature of Pyth, this is automatically printed. The rest of the line is valid Pyth, but the preceeding space before the o suppresses the automatic printing.

Python 3

The majority of the Python code is commented out using strings, especially a large triple-quoted string in the middle. Ignoring a few stray strings, we have:

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

The first and last lines are syntactically valid, but do nothing. The middle two lines print what we need.

Ruby

The Ruby code is similar, but we're using a heredoc instead of a triple quoted string to comment out most of the program. Ignoring some stray strings, we have:

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

Once again, the first line is syntactically valid, but does nothing. The second line prints what we need.

Answer 3

CJam, 12 bytes

T~mp[]!_1+oE^

The Unscramble the Code topic is a really good source for random number printing. This one was quite fun to piece together :)

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 answers

14 bytes:

36.e8 .79e2%15

19 bytes:

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

Answer 4

Ostrich, 198

I'm excited to get an Ostrich answer out; I don't care how long it is. :P (this is version 0.5.0, by the way)

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

All I changed was the following:

• Wrapped everything other than 2 n15 in a block ({}) that is immediately popped (;).

• Stuck 2 n15 at the end. 2 pushes a 2, n pushes a 0, and 15 pushes 15, which ultimately becomes 2015 when output.

This actually helped me find a bug: 2n15 doesn't work for some reason (it prints 215), but both 2 n15 and 2n 15 work. I'll have to figure out why that is....

Here's the search query I used to find this perfect code sample:

created:..2014-12-16 is:answer code:"2" code:"0" code:"1" code:"5" code:"]" code:";"

This answer would work for 140, but I'm going to see if I can go smaller....

Answer 5

JavaScript, 26 bytes

Original:

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

Recycled:

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

It just shifts 4030 one bit to the right.

Answer 6

CJam, 14 bytes

This one is a bit tricky, so I had to post it even though its a bit long. Original answer is also in CJam, so its valid.

Original answer:

92e8.17 5e6.3%

Recycled 2015:

9.68e3 .7e2%15

How it works

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

So the stack contains 20 and 15 which are printed one after another, printing 2015

Try it online here

Answer 7

Marbelous, 54 bytes

Boring answer (54 bytes)

32303135
:R
:Q
++003333333567QQRR}0

(followed by a ton of trailing newlines to equal 54 bytes)

Original Answer

The main board simply drops marbles representing each of character of 2015. R and Q boards are defined, but never used.

Alternative answer (92 bytes)

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

Original Answer

Spaces as blank cells should be checked. This first prints 2 (0x32), then prints 0x03+0x02+0x0A=0x0F=15 as a three digit decimal (015). The first three lines do nothing.

Test answers here.

Answer 8

Pyth, 25

https://github.com/isaacg1/pyth

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

Here is the original answer (also written in pyth). I know that this is not a very competitive answer (there is python answer of length 26), but I really enjoyed coming up with this, and I think it comes out into a rather humourous answer.

Explanation:

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

Basically this is filtering a list of the first two million numbers for being equal to 2015. Then, it treats this list of numbers as the digits of a base 10 BILLION number. Thankfully, there is only one number equal to 2015 in the range, so you get 2015*10000000000^0, which is just 2015. This takes a couple seconds to run.

Answer 9

Perl, 48 bytes

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

Original Answer

Answer 10

Python 2, 26 bytes

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

Taken from the Smallest python script to print even numbers 0 to 100 thread. This is probably the solution @FryAmTheEggman was alluding to.

Answer 11

><>, 57 bytes

Original C++ code, from the RadioASCII challenge:

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

Recycled ><> (Fish) code:

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

Like Befunge, ><> is a stack-based 2D language. Execution starts from the top left and is initially rightward. Only the first line of the program is executed, in the following manner:

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

Now the big question is — why is the C++ code valid ><>? In ><> there are ways to change the direction of program flow (it's a 2D language, after all):

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

When the C++ code is executed, the initial # reflects program flow leftward. But ><> is toroidal, so the instruction pointer wraps around, appearing from the end of the line, meeting the > which directs program flow rightward again. The pointer then wraps back to the #, bounces back to the >... and thus an infinite loop occurs and an error is never thrown.

Answer 12

Mathematica, 60 bytes

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

Source

The part in the Floor brackets is just a series of function applications of non-existing functions (which Mathematica doesn't have a problem with, because of its symbolic computation model). Likewise, just writing the flooring and Print@2015 is multiplication, which Mathematica also doesn't complain about. Without the syntactic sugar, it would be

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

Since we're not assuming a REPL environment, the evaluated result of this is never printed (which would be Null Floor[ggggiiimmnnoorrrstt[ee[RS[DF[IM], ad], ee], 0.22346]]), but only the side effect of the Print actually goes to STDOUT.

Thanks to Sp3000 for turning up the source to this.

Answer 13

Python 3, 1878 bytes

Very long, but wanted to share anyway:

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

Taken from KennyTM's answer.

I saw that 2, 0, 1 and 5 and # could be found in the code, so I moved some chars to make print(2015) and could comment out the rest. I also put the PIL import into the comment so it doesn't require that library.

Answer 14

PHP, 21 bytes

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

Let's try this again. Taken from another PHP answer from Unscramble the Source Code. It's pretty basic, but so far it's the shortest program in a non-golfing language. You can verify it at http://codepad.org/15EjIYAU. The original code is as follows:

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