Ruby, 15

p Time.new.year

Temporary ;)

Jan Dvorak offers a great alternative in the comments:

Happy = Time
Happy.new.year

But it's so unenthusiastic. I prefer:

Happy = Time
class Time; alias year! year; end

Happy.new.year!

Or even:

class Have; def self.a; A.new; end; end
class A; def happy; Time; end; end
class Time; alias year! year; end

Have.a.happy.new.year!

And here's correct English grammar:

def noop x = nil; end
alias a noop
alias happy noop
alias new noop
alias year! noop
def Have x
    p Time.new.year
end

Have a happy new year!

Okay okay, I couldn't help it:

def noop x = nil; end
eval %w[we wish you a merry christmas! christmas and a happy new].map{|x|"alias #{x} noop"}*"\n"
def year!; p Time.new.year; end

we wish you a merry christmas! we wish you a merry christmas!
we wish you a merry christmas and a happy new year!

Python

print sum(ord(c) for c in 'Happy new year to you!')

Matlab (4 characters, 5 bytes)

The trick is to cast a string composed only of the character ߞ (of UTF-8 code point U+07DE, which corresponds to 2014 in decimal) to an integer, using the + operator:

+'ߞ'

Byte-count details:

• + is ASCII and counts for 1 byte
• ' is ASCII and counts for 1 byte (but appears twice in the expression)
• ߞ is a 2-byte UTF-8 character

Total: 5 bytes

TeX (33 27 characters, as many bytes)

\def~{\the\catcode`}~}~\\~\%\bye

An even shorter alternative (proposed by Joseph Wright) is

\number`^^T\number`^^N\bye

XeTeX/LuaTeX (14 characters, 15 bytes)

If XeTeX or LuaTeX are allowed, UTF-8 input can be used directly (as proposed by Joseph Wright):

\number`ߞ\bye

C

main(){printf("%d",'A'*' '-'B');}

33 characters

PHP (9 bytes)

xxd needed because of binary data (so copying and pasting it would be easier). May return E_NOTICE, but it doesn't really matter, does it?

~ $ xxd -r > 2014.php
0000000: 3c3f 3d7e cdcf cecb 3b                   <?=~....;
~ $ php 2014.php
2014

Python, 26

print int('bbc',ord("\r"))

Scala REPL

34 characters. Not the shortest. toInt is required to print the value of the char.

"Happy new year to you!".sum.toInt

Well ok if you really want it golfed with any chars, you can use:

'@'*' '-'"'

or

"{yz}".map(_-'I'toChar)

which have 11 and 23 chars respectively.

72 45 characters in the code; Zero character codes

This is far from the shortest answer posted, but no one has yet posted an answer that

• doesn't use character codes as a substitute for numbers, and
• doesn't call the system date.

Using pure math (okay, and an automatic boolean conversion) in R, from the R console:

x<-(T+T);x+floor(exp(pi)^x)*x*x-(x*x)^(x*x)/x

Prints out the number 2014. T is a pre-defined synonym for true in R. The floor and exp functions are directly available in the base package, as is the pi constant. R doesn't have an increment operator, but repeating the (x*x) turned out to be fewer characters that doing increment and decrement twice each.

Original version in Javascript (72 characters)

For the simple reason that I could test out in the console, and it doesn't mind a complete lack of whitespace:

m=Math;p=m.pow;t=true;++t+m.floor(p(m.exp(m.PI),t))*t*t++-p(++t,t--)/--t

run in your console and it will print back the number 2014.

Shorter Javascript version (68 characters):

m=Math;p=m.pow;t=true;++t+m.floor(p(m.exp(m.PI),t))*t*t-p(t*t,t*t)/t

Props to xkcd (and also) for getting me to think about exp(pi):

P.S. If you can make the same algorithm shorter in a different language, post a comment with it.

Python

newYear = '''
   _ _      _ _      /|     |     | 
  /   \    /   \    / |     |     | 
 |    /   |     |     |     |_ _ _| 
     /    |     |     |           | 
   _/_ _   \_ _/   _ _|_ _        | '''
print(newYear)

Javascript / Base 64 Conversion

alert(atob("MjAxNA=="))

23 chars (16 with atob by itself)

Or

alert("MMXIV") // ;)

Ruby, 20

p 'bbc'.to_i ?\r.ord

Explanation: bbc is 2014 in base 13. Shorter than Python. Not as short as Forth.

APL (6 bytes, 4 chars)

⊃⎕TS

Only works this year though.

Why it works:

      ⎕TS
2014 1 1 11 58 5 811
      ⊃⎕TS
2014

Without relying on the system date, it's 10 bytes (7 characters):

⎕UCS'ߞ'

GolfScript, 14

'-+,/'{)))))}%

How it works: ASCII goes like this:

...
+
,
-
.
/
0
1
2
3
4
...

So, this takes the ASCII codes of each character, subtracts five, and sticks it in a string.

{...}% yields an array of the characters of a string mapped, when given a string as an argument. So, it increments each character by 5 () means increment).

Perl - 10 characters

This solution is courtesy of BrowserUK on PerlMonks, though I've shaved off some unnecessary punctuation and whitespace from the solution he posted. It's a bitwise "not" on a four character binary string.

say~"ÍÏÎË"

The characters displayed above represent the binary octets cd:cf:ce:cb, and are how they appear in ISO-8859-1 and ISO-8859-15.

Here's the entire script in hex, plus an example running it:

$ hexcat ~/tmp/ten-stroke.pl
73:61:79:7e:22:cd:cf:ce:cb:22
$ perl -M5.010 ~/tmp/ten-stroke.pl
2014

Update: altered to use say instead of print as per @PeterTaylor's comment. Not only does this shave off two further characters, it adds an attractive line break at the end of the output.

print'````'^RPQT

(I initially had the two strings the other way around, which required whitespace between print and RPQT to separate the tokens. @DomHastings pointed out that by switching them around I could save a character.)

Mathematica, 14 characters (or 15 if you count the bitmap as a character)

TextRecognize@

dc, 6 chars

$ dc <<< "DiBBCp"
2014

D pushes 13 on the stack, even tho the input radix is 10 initially. i changes input radix (to 13) and BBC is 2014 base 13. p prints.

Powershell, 9

+"ߞ"[""]

ߞ (U+07DE NKO LETTER KA) is counted as two bytes according to the code-golf tag info.

[""] returns the first character from the string ("" is converted to 0). The unary plus opeartor (+) converts the character to an integer.

Python, 32 chars

print ord(',')*ord('-')+ord('"')

Probably possible to reduce it using the 2014 th Unicode char ߞ, but I didn't try.

GolfScript (10 8 7 chars)

This solution contains non-printable characters. As xxd output:

0000000: 2714 0e27 7b7d 2f                        '..'{}/

As base 64:

JxQOJ3t9Lw==

Unpacks the ASCII codes for characters 20 and 14 and prints those numbers without any separation.

To actually generate the number 2014, I'm currently at 8 chars:

0000000: 2713 6a27 7b2a 7d2a                      '.j'{*}*

JxNqJ3sqfSo=

Takes a string containing characters with ASCII values 19 and 106 and multiplies them to get 2014.

Mathematica, 20 bytes

ToCharacterCode@"ߞ"

(Using the 2014 unicode char)

Python 32 10 bytes, 91 85 (66 with math imported by default) bytes pure math

Had some fun writing this:

my_lst = []
for i in range(33, 126):
    for j in range(i, 126):
        if 2014 - 126 < i * j < 2014 - 33:
            if j not in range(48, 58):
                my_lst.append("ord('" + unichr(i) +
                              "')*ord('" + unichr(j) +
                              "')+ord('" + unichr(2014 - i * j) + "')")

for val in my_lst:
    print val, '->', eval(val)

Prints all the possible ways I can write 2014 using Bruno Le Floch's method (32 chars):

ord('!')*ord(':')+ord('d') -> 2014
ord('!')*ord(';')+ord('C') -> 2014
ord('!')*ord('<')+ord('"') -> 2014
ord('"')*ord(':')+ord('*') -> 2014
ord(')')*ord('/')+ord('W') -> 2014
ord('*')*ord('-')+ord('|') -> 2014
ord('*')*ord('.')+ord('R') -> 2014
ord('*')*ord('/')+ord('(') -> 2014
ord('+')*ord(',')+ord('z') -> 2014
ord('+')*ord('-')+ord('O') -> 2014
ord('+')*ord('.')+ord('$') -> 2014
ord(',')*ord(',')+ord('N') -> 2014
ord(',')*ord('-')+ord('"') -> 2014

But this is obviously redundant, so if your interpreter is set to utf-8 by default, then all it takes is:

>>> ord(u'ߞ')
2014

Also, thanks to AmeliaBR (for the idea), I tried my best to implement a pure math version:

from math import *
a,b,c=int(e),round(e),ceil(pi);print int(a**(b*c-(c-b))-a*a**c-a)

Golfscript - 11 10 chars

'&~I'{}/-*

computes 38 * 53 (ie an expansion of the prime factorization of 2014: 2 * 19 * 53)

Old Version

'f.'{}/.*\-

This computes 46²-102.

'f.'{}/ puts the ascii values of f and . on the stack.
.*      squares the value of the .
\-      swaps the two values, then subtracts

Forth, 14

'> '" * '^ - .      

GolfScript, 10

I can't beat Quincunx's 10-char plain ascii solution but I can match it:

'N,,'{}/*+

(it calculates 44*44+78)

And now a different approach :)

'codegolfing is yummy'{+}*

Yet another GolfScript entry, 9 printable characters

I believe this is shorter than any of the printable GolfScript entries so far:

"!="{*}*)

(Peter Taylor's 7-char entry beats it, but includes non-printable control characters.)

I call this the "that's so last year!" entry, because what it actually does is generate the number 2013 in 8 chars, as 33 × 61, and then increments it by one. ;-)

Haskell, 23 characters, 24 bytes

main=print$fromEnum 'ߞ'

That's U+07DE N'Ko letter KA

Morse Code 23

;)

..--- ----- .---- ....-

Javascript, 18 characters

alert(btoa('ÛMx'))

JSFiddle: http://jsfiddle.net/pBjL2/

D

ϯ has the numerical value 1007 in Unicode encoding.

as compiler message during compilation (20 chars)

pragma(msg,'ϯ'+'ϯ');

runtime version (45 chars)

import std.stdio;void main(){write('ϯ'+'ϯ');}