# Question
Title: Produce the number 2014 without any numbers in your source code
> *Note to challenge writers as per meta consensus: This question was well-received when it was posted, but challenges like this, asking answerers to Do X without using Y are likely to be poorly received. Try using the sandbox to get feedback on if you want to post a similar challenge.*

---

> It's ~~2017~~ ~~2018~~ ~~2019~~ ~~2020~~ ~~2021~~ ~~2022~~ ~~2023~~ 2024 already, folks, go home.

> Woo, 10 years of this challenge!

So, now that it's 2014, it's time for a code question involving the number 2014.

Your task is to make a program that prints the number `2014`, without using any of the characters `0123456789` in your code, and independently of any external variables such as the date or time or a random seed.

The shortest code (counting in bytes) to do so in any language in which numbers are valid tokens wins.

---

Leaderboard:

```
var QUESTION_ID=17005,OVERRIDE_USER=7110;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```

```
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><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```

# Answer
# Mouse-2002, 4 bytes.

That's 4 bytes of pure, sweet ***ASCII.***

In Mouse, the letters of the alphabet are initialised to the values 0-25. `!` is the operator for printing integers, thus this prints `20` then `14` (no intermittent newline).

```
U!O!

```

There's no online interpreter available, but here you will find an interpreter written in C (needing some tweaks before one can coerce `gcc` to compile it) and the same compiled interpreter for `Win32` but which works perfectly on Linux with `wine`.

Here you can find the fixed version of the interpreter, which compiles.
> 154 votes

# Answer
# Python 2, 51 bytes

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

```

Try it online!

Updated for 2015 thanks to @Frg:

```
print sum(ord(c) for c in 'A Happy New Year to You!')

```

Try it online!

Mouse over to see 2016 version:

> `print sum(ord(c) for c in 'Happy New Year to you!!!')`

Try it online!
> 1407 votes

# Answer
# Go, 2 bytes (UTF-16)

One unicode character (2 bytes in UTF-16, 3 bytes in UTF-8 format), output 2014 as part of an error

http://ideone.com/dRgKfk

```
can't load package: package :
prog.go:1:1: illegal character U+2014 '—'

```
> 291 votes

# Answer
# Ruby, 15

```
p Time.new.year

```

Temporary ;)

---

Note that the section of the question

> independently of any external variables such as the date or time or a random seed

was not edited in until long after I posted my answer...

---

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

```
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!

```
> 260 votes

# Answer
# Befunge-98 (FBBI), ~~17~~ ~~11~~ ~~9~~ 8 bytes

```
'-:*b-.@

```

Try it online!

Similar to the old version, but I remembered about `'`

```
'-:* pushes 45, duplicates it, then squares it, producing 2025
b-   subtracts 11 from it, resulting in 2014
.@   prints the result, then ends the program

```

Interestingly, \\$45^2-11\\$ is the only pairing of numbers a,b where $$(a,b)∈\[32,126\]\times\[10,15\]\land a^2-b=2014$$ The significance of those sets is that \\$\[32,126\]\\$ is the set of printable ascii characters and \\$\[10,15\]\\$ is the set of easily accessible Befunge numbers. I found that pair with this python program:

```
for a in range(32,127):
    for c in range(10,16):
        if (a**2-c)==2014:
            print("%s,%s"%(a,c))

```

---

Or, if your interpreter supports unicode, then this works:

# Befunge 98 - 5 bytes (4 chars)

```
'ߞ.@

```

It at least works on http://www.quirkster.com/iano/js/befunge.html with the following code (Befunge 93 - 6 bytes / 5 chars):

```
"ߞ".@

```

---

# Befunge-98 (FBBI), 9 bytes

Old version:

```
cdd**e-.@

```

Try it online!

computes the number, then prints it:

```
cdd pushes numbers to the stack so that it is this: 12,13,13
**  multiplies top three values of stack, which is now: 2028
e   pushes 14
-   subtracts the top two values of the stack, resulting in: 2014
.   prints the numerical value
@   end of program

```

---

# Befunge-98 (FBBI), 17 bytes

Older version:

```
"*'&("#;:a`j@a+,;

```

Try it online!

Pushes the ascii values for 2014, -10. Then prints each after adding 10 to it.
> 249 votes

# Answer
# Python 2, 26 bytes

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

```

Try it online!
> 193 votes

# Answer
## MATLAB, Scala (4 characters, 5 bytes)

You can take advantage of MATLAB's (and Scala's) relatively weak type system, here. The trick is to apply the unary `+` operation on a string composed only of the character `ߞ` (of UTF-8 code point U+07DE, or 2014 in decimal). This operation implicitly converts the string to a double (in MATLAB) and to an `Int` (in Scala):

```
+'ߞ'

```

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 (~~32~~ 26 characters, as many bytes)

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

```

An even shorter alternative (proposed by Joseph Wright) is

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

```

## XeTeX/LuaTeX (13 characters, 14 bytes)

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

```
\number`ߞ\bye

```
> 151 votes

# Answer
# dc, 6 bytes

```
DiBBCp

```

Try it online!

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

Console output:

```
$ dc <<< "DiBBCp"
2014

```
> 124 votes

# Answer
# Scala, ~~32~~ 29 bytes

```
+"Happy new year to you!".sum

```

Try it online!

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

# Scala, 11 bytes

```
'@'*' '-'"'

```

Try it online!

# Scala, 22 bytes

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

```

Try it online!
> 96 votes

# Answer
# , ~~72~~ 45 bytes

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

```

Try it online!

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.

---

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.
> 91 votes

# Answer
# C (clang), 33 bytes

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

```

Try it online!
> 71 votes

# Answer
# PHP, 9 bytes

This requires PHP 7.1 or lower. It will work in PHP 7.2, but it will result in a warning. No guarantees for any future version.

`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

```

Alternatively, save this using ISO-8859-1 encoding.

```
<?=~ÍÏÎË;

```
> 70 votes

# Answer
### Python3.4.0b2 (0 bytes)

```
% python3.4
Python 3.4.0b2 (v3.4.0b2:ba32913eb13e, Jan  5 2014, 11:02:52)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

```
> 70 votes

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

TextRecognize@
> 59 votes

# Answer
# JavaScript (Node.js), 23 bytes

Uses Base 64 Conversion

```
alert(atob("MjAxNA=="))

```

Try it online!

*Or*

```
alert("MMXIV") // ;)

```
> 49 votes

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

```

**Perl (without high bits) - 14 characters**

say'````'^RPQT
</code></pre>

This uses a bitwise "or" on the two four-character strings `"RPQT"` and `"````"` (that is, four backticks).

```
$ ~/tmp/fourteen-stroke.pl
73:61:79:27:60:60:60:60:27:5e:52:50:51:54
$ perl -M5.010 ~/tmp/fourteen-stroke.pl
2014

```

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

**Perl (cheating) - 8 characters**

This is probably not within the spirit of the competition, but hdb on PerlMonks has pointed out that Perl provides a variable called `$0` that contains the name of the current program being executed. If we're allowed to name the file containing the script "2014", then `$0` will be equal to 2014. `$0` contains a digit, so we can't use it directly, but `${...}` containing an expression that evaluates to 0 will be OK; for example:

```
say${$|}

```

For consistency, let's do the hexcat-then-perl thing with that:

```
$ hexcat 2014
73:61:79:24:7b:24:7c:7d
$ perl -M5.010 2014
2014

```

I think this is cheating, but it's an interesting solution nonetheless, so worth mentioning.
> 44 votes

# Answer
# Ruby, 20 bytes

```
p 'bbc'.to_i ?\r.ord

```

Try it online!

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

# Answer
# PowerShell, 9 bytes

```
+"ߞ"[""]

```

Try it online!

`ߞ` (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.
> 30 votes

# Answer
## Javascript, 18 characters

```
alert(btoa('ÛMx'))
```

**Update:** in ES6, using a template literal can save two characters:

```
alert(btoa`ÛMx`)
```

The code above is fairly easy to understand by keeping in mind that `btoa` converts a string into another string according to a set of well-defined rules (RFC 4648). To see how the conversion works, we're going to write the input string "ÛMx" as a sequence of binary digits, where each character is rendered as its 8-bit character code.

```
Input character          |        Û |        M |        x
Character code (decimal) |      219 |       77 |      120
Character code (binary)  | 11011011 | 01001101 | 01111000

```

After reorganizing the binary digits in the last row in groups of 6, we get the binary representation of 4 new numbers, corresponding to the Base64 indices of the 4 characters in the string "2014".

```
Base64 index (binary)  | 110110 | 110100 | 110101 | 111000
Base64 index (decimal) |     54 |     52 |     53 |     56
Output character       |      2 |      0 |      1 |      4

```

As per HTML specification, the output characters can be retrieved from their Base64 indices according to this table: http://dev.w3.org/html5/spec-LC/webappapis.html#base64-table.

If you don't care about the details, you could let the browser do the calculations for you and find out that "ÛMx" is the result of evaluating `atob('2014')` in Javascript.
> 29 votes

# Answer
# Scala, 6 bytes

```
"?="##

```

Try it online!

(`##` is Scala's symbol meaning `hashCode`, and the Java string `"?="` hashes to 2014.)

# Scala, 5 bytes

```
+'ߞ'

```

Try it online!

Math on our favorite unicode character produces an `Int`.
> 27 votes

# Answer
# GolfScript, 9 bytes

Yet another GolfScript entry. I believe this is shorter than any of the printable GolfScript entries so far:

```
"!="{*}*)

```

Try it online!

(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. ;-)
> 24 votes

# Answer
# C (gcc), 31 bytes

```
main(){printf("%o",' b'/'\b');}

```

Try it online!

# C (gcc), 32 bytes

```
main(){printf("%x%o",' ','\f');}

```

Try it online!

# C (gcc), 30 bytes

```
main(){printf("%x",' j'^'~');}

```

Try it online!

# C (gcc), 30 bytes

```
main(){printf("%d",'\a\xde');}

```

Try it online!
> 22 votes

# Answer
# GolfScript, 14 bytes

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

```

Try it online!

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).
> 21 votes

# Answer
# Forth (gforth), 14 bytes

```
'> '" * '^ - .

```

Try it online!
> 21 votes

# Answer
# Python 2, 32 bytes

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

```

Try it online!

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

Quincunx notes that

```
a=ord('.');print a*a-ord('f')

```

Try it online!

is shorter by three chars.
> 19 votes

# Answer
## 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'ߞ'

```
> 19 votes

# Answer
# Python 2, 32 bytes

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:

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

```

# Python 2, 10 bytes

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

```
ord(u'ߞ')

```

Try it online!

# Python 2, 83 bytes

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)

```

Try it online!
> 19 votes

# Answer
# , 20 bytes

@popojan (he is not allowed to post an answer here yet) has provided the solution within 20 characters.

```
sum(T+T:exp(T+pi))-T

```

Try it online!

Output:

```
[1] 2014

```

# , 22 bytes

Anonymous user has suggested shorter solution.

```
strtoi("bbc",pi*pi+pi)

```

Try it online!

`2014` is `BBC` in base 13. `pi*pi+pi` (=13.0112) is treated by R in this context as the integer 13. Output:

```
2014

```

# , 30 bytes

```
cat(a<-T+T,T-T,T/T,a*a,sep="")

```

Try it online!

Output:

```
2014

```

# , 31 bytes

```
cat(T+T,T-T,T/T,T+T+T+T,sep="")

```

Try it online!

Inspired from the answer by AmeliaBR. Output:

```
2014

```
> 17 votes

# Answer
# Java (JDK), ~~77~~ 75 bytes

75 characters if `print` is added in a class with the main method:

```
class C{public static void main(String[]a){System.out.print('#'*'<'-'V');}}

```

Try it online!

It means `35*60-86` which is equal to 2014
> 15 votes

# Answer
# CJam, 2 bytes

```
KE

```

Try it online!

`K` and `E` are variables preset to 20 and 14.
I created CJam in 2014 so it's ok if it doesn't qualify.
> 14 votes

# Answer
## 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.
> 12 votes

# Answer
## Haskell, 23 characters, 24 bytes

```
main=print$fromEnum 'ߞ'

```

That's U+07DE N'Ko letter KA
> 11 votes

# Answer
# Mathematica, 47 bytes

```
Total@ToCharacterCode@"Happy New Year for all!"

```

> 2014
> 11 votes

# Answer
## EXCEL, 24 characters:

```
=COLUMN(T:T)&COLUMN(N:N)

```
> 11 votes

# Answer
## Mathematica, 23 bytes

```
Tr@ToCharacterCode@"ߞ"

```

(Using the 2014 unicode char. Credit for `Tr` goes to alephalpha)

## Mathematica, 46 bytes (pure math)

```
a=⌊E⌋;b=⌈E⌉;c=⌈Pi⌉;a^(b*c-(c-b))-a*a^c-a

```

idea taken from here.
> 10 votes

# Answer
I and others have posted shorter Mathematica solutions to this challenge, but here are two methods that I don't believe have been tried in any of the other examples, in any languages.

## Mathematica, 27 characters / 27 bytes

```
FromDigits["MMXIV", "Roman"]

```

## Mathematica, 37 characters / 37 bytes

```
(ToString /@ FromDigits /@ {"K", "E"}) <> ""

```

and the following 58 character variation

```
FromDigits[Flatten[IntegerDigits /@ FromDigits /@ {"K", "E"}]]

```
> 10 votes

# Answer
## Mathematica (24)

Found by randomly generating expression trees. `TraditionalForm` chops 5 characters for the floor symbol but I think rich text doesn't count.

```
Floor[π E(Sin@E+E^E)E^E]

```
> 10 votes

# Answer
# 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('ϯ'+'ϯ');}

```
> 9 votes

# Answer
# J - 11 bytes - Base arithmetic

```
+:_bj*p:_bf

```

**Explanation**

`_bf` and `_bj` are 15 and 19 in infinite base, therefore `p:_bf` is 15th prime, which is 53. The result is then 19\*53 doubled, which is 2014.

# J - ~~31~~ 28 bytes - Math

```
(((!>:&+:)-(!>:))+:&+:)>.^*_

```

**Explanation**

The implementaion of A004126 sequence from OEIS where I searched for the ways to calculate 2014. Basically it's C(2\*n+1,3)-C(n+1,3) where n=12.

This means ceiling(exp(signum(infinity))), which is 3

```
>.^*_

```

To get 12 we double it two times.

```
+:&+:

```

Everything else is a combo of a dyadic fork and monadic hook. You can read about them here.

**Other's solution in *J***

```
+/(>.^*_)&u:'Happy new year to you!'

```

Which normally is `+/3&u:'Happy new year to you!'`, it's a shame we need a number to work with strings.

It was fun to remember ***J*** :).
> 9 votes

# Answer
# Java (68)

**Solution 4:** 68 chars (Thanks @radiodef))

```
class C{public static void main(String[]a){System.out.print(+'ߞ');}}

```

**Solution 3:** 69 chars (Thanks @Kamran)

```
class C{public static void main(String[]a){System.out.print(~~'ߞ');}}

```

**Solution 2:** 71 chars

```
class C{public static void main(String[]a){System.out.print('޾'+' ');}}

```

**Solution 1:** 72 chars

```
class C{public static void main(String[]a){System.out.print((int)'ߞ');}}

```

\<3 Unicode.

---

**Solution Derivation Technique:** Copy the output from the following line and convert that character back to int for your a working solution.

```
System.out.println((char)2014));

```
> 9 votes

# Answer
# Perl 6, 37 bytes

This is not my actual solution (the real solution is in PHP, and is shorter), but I decided to make shorter version of Python's solution, because it's a really interesting idea.

```
say [+] ords 'Happy new year to you!'

```

Try it online!

So, what does it do? Well, it gets list of character positions (`ords` function), sums them together (`[]` is a reduce operator, which takes the exact operator between square brackets, in this case `+`), and `say` prints the result with new line. Could be WAY shorter by abusing `~^` prefix operator (which isn't implemented in Rakudo Perl) or Unicode characters, but this is just for fun solution.

Perl 6 is a quite an interesting language, even if it's not as good as Perl 5 in most code golf tasks (because of mandatory whitespace in many situations, and generally less DWIM). However, in this case, because of builtin sum and `ords`, it wins with Perl 5.
> 8 votes

# Answer
### JavaScript ~~59~~, ~~44~~, ~~36~~, 29

```
a=+'';b=''+a+++a++;a+++b+ ++a

```

Assuming alert can be skipped due to implicit return

---

```
a=+'';b=''+a+++a++;alert(a+++b+ ++a)

```

---

```
alert([-~-~'',+'',-~'',-~-~-~-~''].join(''))

```

---

Those are `l` characters not `1`
```
l='length';alert([[,,][l],[][l],[,][l],[,,,,][l]].join(''))

```
> 8 votes

# Answer
# Python 3, 9 bytes

```
license()

```

Try it online!

unfortunately this does not work on tio.run but it does work on my device

`license()` stdouts text which luckily contains 2014 :)

```
...
2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Python Software Foundation;

All Rights Reserved" are retained in Python alone or in any derivative version
prepared by Licensee.
...

```
> 8 votes

# Answer
## AutoHotkey 31/13

```
send % ++(z:=true) z-z true z+z

```

### This year special solution

```
send % A_year

```
> 7 votes

# Answer
# 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 462-102.

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

```
> 7 votes

# Answer
# GolfScript, 10 bytes

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

```
'N,,'{}/*+

```

Try it online!

(it calculates 44\*44+78)

# GolfScript, 26 bytes

And now a different approach :)

```
'codegolfing is yummy'{+}*

```

Try it online!
> 7 votes

# Answer
# Raku (Perl 6), 12 bytes

```
say 'ߞ'.ord

```
> 7 votes

# Answer
# R using roman numbers, 29 characters

```
as.numeric(as.roman('MMXIV'))

```
> 7 votes

# Answer
# C#, 60 characters

```
class a{static void Main(){System.Console.Write(- -'ߞ');}}

```

Thanks to mleise for the original answer for D!

Note: space between hyphens is important
> 6 votes

# Answer
### Ruby — 8 characters

```
p ?ߞ.ord

```

where ߞ is Unicode character U+07DE — N'Ko letter ka.

This is what it looks like when I copy and paste the above line and run it in my Terminal. Notice the character does not display:
> 6 votes

# Answer
# Python 3 (17 bytes)

```
print(ord("ߞ"))

```

# Python 2 (50 bytes)

```
s,t=str,True;print s(t+t)+s(t-t)+s(t/t)+s(-~t<<t)

```
> 6 votes

# Answer
## JavaScript:

```
alert(+!![]+!![]+[+[]]+ +!![]+(+!![]+!![]+!![]+!![]));

```

---

each `+!![]` is 1 (`![]` is `false`, `!false` is `true` and `+true` is `1`)

`+[]` is 0, and `[0]` is `"0"`

so this turns into `1+1+"0"+1+(1+1+1+1)`
> 6 votes

# Answer
guess this is already beaten but I like the approach:

```
<?php
$three=round(pi());
$one=pi()/pi();
$two=$three-$one;
$four=$three+$one;
$zero=$one-$one;
echo $two.$zero.$one.$four;
?>

```
> 6 votes

# Answer
## T-SQL, ~~50~~ 40

My original entry seems too straightforward. How's this?

PRINT RIGHT(CHECKSUM(',,.'),LEN('````'))
</code></pre>

(Disclaimer: Given Steve Matthews's comment, the above may be dependent on configuration.)

Here's the SELECT version in SQL Server 2012.

Original entry:
This may look obscene in more ways than one, but it's valid.

```
DECLARE @ INT=\PRINT CONCAT(-~-~@,@,-~@,-~-~-~-~@)

```

Try it in SQL Server 2012. Here is a version using SELECT.

Explanation: "\\" is a valid currency symbol. (Do a find for "String to" here.) If you assign just a currency symbol to an INT variable, you store 0. Also, "@" is a valid variable name. "~" is bitwise NOT, and "-" is negative. If you negate a NOT-ed INT, you get the INT plus 1. So, repeat "-~" until you make @ into the digit you need. Then CONCAT() your digits.
> 6 votes

# Answer
## Bash 28

```
echo $((`printf %d \':`#yG))

```

Similar to the Ruby and Python solutions, but uses base62, now without literal `6` and `2` (but pretty long...)! Using base58 as recommended by @DigitalTrauma along with removing quotes around the printf format string, Thanks!

## Better 17 (Thanks @user13955 and @DigitalTrauma!)

```
tr a-l /-:<<<dbcf

```

"It's shorthand for tr abcdefghijkl /0123456789:. Not very geeky, I'm afraid." -user13955 Also updated to use a heredoc instead of echo, thanks @DigitalTrauma!
> 5 votes

# Answer
**PHP: 54 chars**

Slightly different approach, albeit long, using concatenation, and not using ordinal values:

```
<?=floor(M_E).floor(M_EULER).ceil(M_EULER).ceil(M_PI);

```
> 5 votes

# Answer
# Javascript (29 chars)

```
t=!'',a=t+t+'';a+!t*t+t*t+a*a

```

Not the shortest but some boolean logic
> 5 votes

# Answer
## PHP - 13 bytes

```
<?=m_n_^_o_k;

```

A fairly trivial ASCII-only solution.

Other variants:

```
<?=Q__Q^cone;
<?=VonV^d__b;
<?=PAAP^bqpd;
<?=BEAU^pupa;

```

etc.
> 5 votes

# Answer
# Javascript, 37 bytes

```
((_=+!![])<<''+_+''+_)-(_<<_+++_+_)-_

```

It's not code golf until someone bitshifts.

```
$ node
> ((_=+!![])<<''+_+''+_)-(_<<_+++_+_)-_
2014

```

It is *actually* Javascript, I promise.

```
((_=+!![])    // create 1 and save in _
  <<          // left bitshift by 11 to get 2048
    ''+_+''+_ // create 11 from '1' + '1'
  )
  -           // subtract (2048 - 32) === 2016
  (
    _<<       // bitshift by 5 to get 32
  _+++_+_     // create 5 from 1 + (++1) + 2
)-_           // subtract 2 to get 2014

```
> 5 votes

# Answer
# Japt, 3 bytes (2 chars)

*Japt is newer than this competition (created in 2015), but was not created specifically to answer it.*

That's right. 2 chars. Explanation:

```
#   // Char-code of next character
 ߞ  // Character with char-code of 2014
    // Implicit output

```

**Try it online!**
> 5 votes

# Answer
# C, ~~33~~ 30 bytes

**Numerical Solution 1**

```
f(){printf("%d",'<'*'#'-'V');}

// 2014 = 60 * 35 - 86

```

---

# C, ~~86~~ 83 bytes

**Numerical Solution 2**

```
#define A ((int)'}')
#define B (((int)'r')-((int)'d'))
f(){printf("%d",A*B+A+A+B);}

// A = 125
// B = 14
// 2014 = 125*14 + 125 + 125 + 14

```

---

# C, ~~53~~ 50 bytes

**ASCII Art 1**

```
f(){printf("┌┐ ┌┐ ┐ ┐┌\n┌┘ ││ │ └┤\n└┘ └┘ ┴  ┴");}

```

Result

```
┌┐ ┌┐ ┐ ┐┌
┌┘ ││ │ └┤
└┘ └┘ ┴  ┴

```

---

# C, ~~94~~ 91 bytes

**ASCII Art 2**

```
f(){printf("╔═╗ ╔═╗ ╗ ╦ ╦\n  ║ ║ ║ ║ ║ ║\n╔═╝ ║ ║ ║ ╚═╣\n║   ║ ║ ║   ║\n╚═╝ ╚═╝ ╩   ╩\n");}

```

Result

```
╔═╗ ╔═╗ ╗ ╦ ╦
  ║ ║ ║ ║ ║ ║
╔═╝ ║ ║ ║ ╚═╣
║   ║ ║ ║   ║
╚═╝ ╚═╝ ╩   ╩

```
> 5 votes

# Answer
# Vim 7.4, 18 bytes

```
:h os_v<CR>$bbbyiwZZp

```

Here, `<CR>` means a literal newline. Uses the help page `os_vms.txt` which contains the number 2014 on the first line.

How it works:

```
:h os_v<CR>            This opens the help page for os_vms.txt, the line the cursor lands on contains '2014'.
           $bbb        Move the cursor to the '2014' (end-back-back-back)
               yiw     Copy it (yank-in-word)
                  ZZ   Close the help page
                    p  Paste the copied word

```

If numbers were allowed we could do:

```
i2014

```
> 5 votes

# Answer
# TI-BASIC, 12 bytes

A completely new approach.

```
iPart(π+iPart(e)sinh(π+√(π

```

This could probably be golfed further, using a 1-byte token in place of e, but I have spent far too long on this today...
> 5 votes

# Answer
# Javascript, 6 characters (8 bytes)

I never saw any rule saying we had to produce the number 2014 *in the absence of any other output.*
(Nor anything about not outputting to an error, but that's more obvious.)

```
new`—`

```

For me, on Firefox Nightly, this produces `TypeError: "\u2014" is not a constructor`, which contains the number 2014.

(If it isn't obvious, this happens because the em dash, —, is U+2014. Or, in other terms, it's the unicode character that can be represented by the **hexadecimal** number 2014.)
> 5 votes

# Answer
## Javascript: 47 characters

Not the shortest, but another solution:

```
$ node
> [!+[]+!+[]]+[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]
"2014"

```

Source

## Javascript: 6 characters

> *Your task is to make a program that prints the number 2014 without using any of the characters `0123456789`*

Ok, here you go: 6 characters.

```
$ node
> "²⁰¹⁴"
'²⁰¹⁴'

```

Yeah, only for ASCII lowers. :-)

Will I win? :-D
> 4 votes

# Answer
Ruby:

```
p eval("#{""=~//}x#{"\a".ord}de")

```

Here is how it works inside IRB shell:

```
>> p eval("#{""=~//}x#{"\a".ord}de")
2014

```
> 4 votes

# Answer
# TI-Basic, ~~49~~ ~~41~~ 31

```
π/π+π/π→B:B^B^B→C:C^C(C/B)-CB-B

```

**Explanation**

* `π/π+π/π→B` Store 2 in B
* `:B^B^B→C` Store 16 in C
* `:C^C(C/B)-CB-B` Display `2014`
> 4 votes

# Answer
## J (18)

This one doesn't use any character codes. Uses the idea that the sum of the sequence of natural numbers from 1 -\> 63 = 2016.

```
<:<:+/i.*:+~+~p:%_

```
> 4 votes

# Answer
Multiboot x86 Assembly (250 bytes):

```
[BITS N]
%define L(x) mov dword [eax],'zaza'-x
O equ 'A'<<`\xe`
F equ 'bab'-'aaa'
M equ `\xFF\xAF\xAA\xFA`-`\xFD\xFF\xFC\xDE`
C equ -(M+F)
h:
dd M
dd F
dd C
dd h+O
dd h+O
dq 'a'-'a'
dd s+O
s:
mov eax,'\'<<`\r`
L('HBJB')
add eax,'e'-'a'
L('IBFB')
hlt

```

Compile with:

```
nasm src.S -o 2014.bin -f bin -DN=32

```

*(If someone has a suggestion for replacing the N macro, I'm all ears)*
> 4 votes

# Answer
## x86 - 16 bytes (Assembled)

This little snippet moves the stack so it overlaps the video memory, to then push the individual numbers straight to the screen (They even blink! Surely a sign of good times to come).

Code: (Note: '0'-'9' -\> 0x30-0x39)

```
B890A8 8ED0 2C5C 50 2C04 50 48 50 40 40 50

```

Assembled from:

```
mov ax, 0xA890
mov ss, ax
sub al, 0x5c
push ax
sub al, 3
push ax
dec ax
push ax
inc ax
inc ax
push ax

```

Build'n run:

```
nasm -f bin -o 2014.com 2014.asm
dosbox 2014.com

```
> 4 votes

# Answer
# Golfscript, 6 chars

```
{xy}.*

```

Inspired from Peter Taylor's answer.

This solution involves non-printable characters too.

Where *x* and *y* represent *20* and *14* in ASCII (the non-printable characters we were talking about before).
> 4 votes

# Answer
# awk (28)

There's definitely a need for an "`awk`y" answer... ;-)

```
BEGIN{print++I+I--I++I++I*I}

```

...oookaaayyy... the last `*` may be a `+` too. But please don't call it an "`awk`f\*ck" solution then... ;-)

```
BEGIN{print++I+I--I++I++I+I}

```

I think, I prefer the later version now because of less different characters...

(tested with `gawk` and `mawk`)
> 4 votes

# Answer
# Windows Calculator - 5 characters

Inspired by this answer to a different question.

Open the Windows Calculator in Programmer View (Hex mode) and type:

`D``F``E``C``±`

This is what the result looks like.
> 4 votes

# Answer
# BASIC v2.0 (Commodore 64), 24 bytes

```
PRINT ASC("&")*(ASC("V")-ASC("!"))

```

The Commodore BASIC tokens are single-byte representations of BASIC keywords. This should result in storing the above line as **24 bytes** instead of **34**.

I was aiming to construct an equation based on character codes, so I was looking for ideal characters in PETSCII. To minimize the number of operations in the equation, it seemed like a good idea picking a pair of divisors of 2014.

However, none of the combinations were perfect, because either one of the divisors were too large, too small or the character code of a number.

So I ended up using **38** which is `CHR$("&")` and **53**, but instead of directly using the latter which is `CHR$("5")`, I used the difference of **86** and **33**. These are the character codes for `CHR$("V")` and `CHR$("!")` respectively.

Tested in VICE and FC64.
> 4 votes

# Answer
# Emotinomicon, 14 bytes

```
ߞ

```

Try it online!

Explanation:

```
  ߞ       explanation
              begin quote string
    ߞ
              end quote string
              pop N and output as a number

```

`ߞ` is U+7DE. 0x7DE is 2014.
> 4 votes

# Answer
# The Shakespeare Programming Language, 219 bytes

I am using drsam94's compiler.

```
.
Ajax,.
Puck,.
Act I:
Scene I:
[Enter Ajax and Puck]
Ajax:
You is the difference between a fat fat fat fat fat fat fat fat fat fat fat cat and the sum of a fat fat fat fat fat cat and a fat cat!Open thy heart!
[Exeunt]

```

## Explanation

```
.

```

Everything from the first line to the first period is the title, parsed as a comment.

```
Ajax,.
Puck,.

```

These are characters from Shakespeare's plays, and descriptions (also comments)

```
Act I:
Scene I:

```

Act I and Scene I, used for gotos (not used here)

```
Ajax:

```

The character speaking.

```
You is the difference between

```

Assigns the difference of the next two values to the character being spoken to.

```
a fat fat fat fat fat fat fat fat fat fat fat cat

```

Every adjective multiplies by 2, a noun is either 1 or -1 depending on its connotation (in this case it's 1). 2^11 * 1 = 2048.

```
the sum of a fat fat fat fat fat cat and a fat cat

```

The sum of the next two values. 32 + 2 = 34, so 2048 - 34 = 2014

```
Open thy heart!

```

Prints the value of the character being spoken to as a number.
> 4 votes

# Answer
# \>\<\>, ~~7~~ 4 bytes

```
"nߞ

```

Try it online!

## Explanation

```
"nߞ      : Put the string nߞ onto the stack.            Stack: [110, 2014]
 n       : Print the top item of the stack as a number. Stack: [110]
  ߞ      : Error out.

```
> 4 votes

# Answer
# 05AB1E, 6 bytes

```
T·žvÍ«

```

Uses the **CP-1252** encoding. Try it online!

Explanation:

```
T       # Push 10
 ·      # Multiply by 2
  žv    # Push 16
    Í   # Subtract 2
     «  # Concatenate
        # Implicit output

```
> 4 votes

# Answer
# PHP, 27 bytes

not in any way competitive to xfix´s solution, but here are a few versions with 27 bytes each:

```
<?=hexdec($c=hexdec(e)),$c;   # e->14->20, e->14
<?=ord(U)-ord(A),hexdec(e);   # 85-65,14
<?=($c=ord(","))*$c+ord(N);   # 44*44+78
<?=($c=ord("."))*$c-ord(f);   # 46*46-102

```

The first one already has been posted by brother Filip; but the others have not.

---

This one has 37 bytes, but I like it (inspired by the Calculator solution)

```
<?=dechex(hexdec(dfeb)^hexdec(ffff));

```

or 13 bytes with

```
<?=sqpu^AAAA;

```

But that idea has already been used by primo
> 4 votes

# Answer
# Rockstar, ~~34~~ 32 bytes

```
X was up equalizing a word
Say X

```

Say hello to rockstar! (No I didn't make this one)

## Explanation:

This first line:

```
X was up equalizing a word

```

Uses Rockstar's Poetic number literals. (As opposed to regular literals, which use numbers).

This means that the length of every word after `was` indicates the digit in that position. So here we have a 2 length (up), a 10 length (equalizing) a 1 length (a) and a 4 length (word). The length is `% 10`, so `equalizing` becomes a 0, and the result is that the variable `X` has the value `2014`.

Then of course we print it with `Say`
> 4 votes

# Answer
# 05AB1E, 4 bytes

```
ToRÀ

```

Try it online!

```
T        # 10
 o       # 2**x (1024)
  R      # reverse (4201)
   À     # rotate left (2014)
         # implicit output

```
> 4 votes

# Answer
# Add++ `-i`, 13 bytes

```
L,"j"O"&"OL/*

```

Try it online!

Caird why no halve built-in you have like 3 fricking built-ins for doing special stuff with doubling but absolutely nothing for halving why do you do this to me?

## Explained

```
L,"j"O"&"OL/*
L,             # start a lambda that's automatically called by the -i flag
  "j"O         #    push the number 106 to the stack - that's the ascii value of j
      "&"O     #    push 38 to the stack - that's the ascii value of &
          L/   #    push the length of the stack (2) and divide 38 by that. This is not a definitive way to consistently divide by 2...it's a miracle the circumstances allowed this. This results in 19
            *  #    and multiply the two items (106 and 19) to get 2014.

```
> 4 votes

# Answer
# C++, 50 bytes

```
#include<iostream>
int main(){std::cout<<'U'^'A';}

```
> 3 votes

# Answer
## LiveScript, 18 bytes

The temporary solution

```
new Date!.getYear!

```

Unicode

```
\ߞ .charCodeAt!

```

Over Excitement

```
x=!Happy
Happy = -> console.log it
New = -> +it
Year = ->++x and Year
Year.valueOf = -> x

Happy New Year!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

```
> 3 votes

# Answer
### C, 37 Characters

```
main(){printf("%d%d",'d'-'P','\xE');}

```
> 3 votes

# Answer
## MATLAB (no char codes), 47 chars

```
p=pi,q=p^p;e=exp(p);floor(q*q+q*e-q-q-q-p-e-e)

```
> 3 votes

# Answer
# JSFuck, 1267 bytes

In Javascript, here is the alert(2014) ! (Try in browser Console).

```
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[!+[]+!+[]]+[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

```

This sample uses only six different characters to write and execute code. This was generated by https://github.com/aemkei/jsfuck.
> 3 votes

# Answer
# Python 2, 68 bytes

Not really short, but it abuses the fact that Python accepts booleans where an integer is required, because `bool` is a subclass of `int`.

```
import string;d=string.digits;T=True;print d[T+T]+d[:T+T]+d[T+T+T+T]

```
> 3 votes

# Answer
## bash 35

I want something that doesn't use ASCII or UNICODE.

```
[ ];x=$?;y=$[x+x];echo $y$?$x$[y+y]

```

If you don't mind some error messages mixed in (28 characters):

```
[;x=$?;echo $x$?$[x/x]$[x+x]

```

You can get rid of the error messages if you don't mind corrupting a file (32 characters):

```
[ 2>x;x=$?;echo $x$?$[x/x]$[x+x]

```
> 3 votes

# Answer
# VB.NET, 59 bytes

```
MsgBox(((Asc(vbTab) + Asc(vbTab)) & Asc("~")) / Asc(vbTab))

```

takes the ascii values of a Tab twice (18) concats the ascii value of "~" (126), giving "18126" and then divides the lot by ascii of a Tab (9) = 2014

Alternatively, you can do

```
MsgBox Asc("j") * vbKeyPause

```

i.e. ascii of "j" (106) * value of the constant vbKeyPause (19), for a total of 28 characters (less than half the original).
> 3 votes

# Answer
### newLISP - 61 characters

I can't seem to play golf in Lisp -- is it just too wordy?

```
(int(apply string(map(fn(c)(find c'(b c a e d)))'(a b c d))))

```
> 3 votes

# Answer
# Clojure (~~177~~ 49 characters)

# EDIT

Just tripped over this question again and realized there's a much better way to approach this:

```
(Integer.(apply str(map count["AA""""A""AAAA"])))

```

which cuts the length down by quite a bit.

How it works:

1. `(map count ["AA" "" "A" "AAAA"])` returns `(2 0 1 4)`, which is a list containing the lengths of each of the strings in the argument vector.
2. `(apply str (...))` converts the elements of the list `(2 0 1 4)` into the string `"2014"`.
3. `(Integer. (...))` converts the string from #2 ("2014") into the integer value `2014`.
4. This snippet returns the value `2014`.

# Original

In the true Lisp-ish spirit that "too many parentheses are never enough" I present:

```
(Integer. (clojure.string/join [(+ (second (range))  (second (range))) (first (range)) (second (range)) (+ (second (range)) (second (range)) (second (range)) (second (range)))]))

```

How it works:
The function `range` produces a lazy sequence of numbers. If no starting point and ending point are specified the range starts at zero and extends infinitely in the positive direction; however, because it's a *lazy* sequence the numbers are not produced until needed. Thus, applying the `first` function to the result of the `range` function without arguments produces the value 0, which is the first element in the sequence 0 to positive infinity. Applying the function `second` to such a range produces the value 1. From there it's a simple matter of producing enough 1's and summing them up to get 2 and 4, then converting them (implicitly) into strings to join then together, then converting the resulting string back to an integer. (I find it amusing that this is actually longer than some of the Brainf\*ck answers - and to add to the horror, it's also legible :-).

Share and enjoy.

:-)
> 3 votes

# Answer
# C# - 64 chars

```
class P{static void Main(){System.Console.Write('!'*'>'-' ');}}

```

pretty printed

```
class P
{
    static void Main()
    {
        System.Console.Write('!' * '>' - ' ');
    }
}

```
> 3 votes

# Answer
## C, 31 bytes -- without a multi-character literal

```
main(){printf("%o",'\xe'*'J');}

```
> 3 votes

# Answer
# Clojure, 9 bytes

Inspired by the Matlab answer, converts char `\u075e` to an int:

```
(int \ߞ)

```
> 3 votes

# Answer
# Haskell, 69 bytes

How do you get a number without using any digits in the source? Lots of people had already done it with characters or strings, so I decided to use pi, predefined in most languages. From pi, you can get the numbers 3 and 4 easily using the ceiling and floor functions. Then you can use some combination of addition, subtraction, multiplication, and maybe division to get 2014. Just by experimenting around, it would be easy to figure out a function that takes in 3 and 4 and returns 2014 (such as 4^4 * 4 + 3^3\*3^3 + 4\*(3^4) - 4\*4\*4 + 4 - 3 = 2014). This one's **70** characters:

```
main=print$(\x y->y^y*y+x^x*x^x+y*x^y-y*y*y+y-x)(floor pi)$ceiling pi

```

Now, that's fine, but writing a function like that isn't much different than just repeatedly writing floor(pi) and ceiling(pi). Is it doable with only one pi? Well, in Haskell, functions can be treated as Monads with an instance defined in Control.Monad.Instances:

```
instance Monad ((->) r) where
        return = const
        f >>= k = \ r -> k (f r) r

```

So you can use the bind function to pass one value into two different functions: `g (f x) (h x)` can be rewritten `f >>= flip (g.h)`. `id >>= f` can be used to pass the one value twice into the same function: `id >>= (^)` for example is a function that returns x to the x power. The resulting program at **207** characters is more obfuscated than golfed, but it was fun to write:

```
import Control.Monad.Instances
main=print.((id>>=(^)>>=flip((+).(id>>=(+)>>=flip((+).(id>>=(-)>>=flip((+).(id>>=div))))))).floor>>=flip((-).(id>>=(^)>>=flip((*).(round.sqrt.fromInteger>>=(*)))).ceiling))$pi

```
> 3 votes

# Answer
# Sclipting, 3 characters (6 bytes)

This outputs the string `"2014"`.

```
꼣갱꽀

```
> 3 votes

# Answer
## Pure bash 18

Without fork!

```
echo $[$[$#xd]#bbc]
2014

```
> 3 votes

# Answer
# Pyth, 4 bytes

```
C"ߞ

```

Pretty straightforwards, just convert that character to an integer and print.
> 3 votes

# Answer
# J (13)

```
#.a.i.'_!!! '

```

Interprets the ASCII value of `_!!!`  (`95 33 33 33 32`) as a binary number (it's weird that this is possible, I agree). This produces 2014.

# J (15)

This one doesn't use any character strings. It's based on the weird coincidence that the sum of the first 46 primes is 4028: double 2014.

```
-:+/p:i.<:+:_bn

```

If anyone knows of a shorter way than `<:+:_bn` to represent 45 (preferably without strings), please let me know.
> 3 votes

# Answer
# Racket, 18 bytes

```
(~a(+ #xa #xa)#xe)

```
> 3 votes

# Answer
### Excel VBA, 51 bytes

```
MsgBox Len("aa") & Len("") & Len("a") & Len("four")

```

As it's 2015 you could add an extra character onto "four" for an extra byte.
> 3 votes

# Answer
# Quetzalcoatl, ~~11~~ ~~4~~ 5 bytes

```
::ord('ߞ')

```

The box should be replaced by Unicode character 2014.

### Edit

This is for an old version of Quetzalcoatl. New version:

```
'ߞ'O

```
> 3 votes

# Answer
# Java 8, 33 bytes

```
()->Integer.parseInt("bbc",'\r');

```
> 3 votes

# Answer
## EXCEL: 148 bytes

`=POWER(ROW()+ROW(),(ROW()+ROW()+ROW())*(ROW()+ROW()+ROW())+ROW()+ROW())-(POWER(ROW()+ROW(),ROW()+ROW()+ROW())*(ROW()+ROW()+ROW()+ROW())+ROW())-ROW()`

only works in A1.
> 3 votes

# Answer
# Sinclair ZX81 15 bytes 10 bytes

```
 PRINT CODE "=";CODE ":"

```

As the ZX81 has a non-ASCII compatible character set, the character code for = is 20 and for : it is 14 - simples.
> 3 votes

# Answer
## R, ~~39~~ 31 bytes:

```
x=T+T;x^(x*x*x+x)*x-x^(x*x)*x-x

```

### R, also ~~39~~ 31 bytes:

```
x=T+T;z=x*x;x^(z*x+x)*x-x^z*x-x

```

Thanks Scrooble!

### More entertaining version: 46 bytes

```
z=pi;x=z*z;y=exp;j=z/y(z);floor(y(x)/(x-j-j))

```

Not especially efficient, but I had a lot of fun messing around with this. I'm sure there's a shorter way using just those two numbers

Long-form, subbing in the variables: `floor(exp(pi*pi)/((pi*pi) - pi/exp(pi) - pi/exp(pi))`

In real-person numbers: `floor(19333.69 / (9.869604 - 0.1357605 - 0.1357605))` = `floor(2014.328)`
> 3 votes

# Answer
# Julia 0.6, 9 bytes

```
Int('ߞ')

```

Try it online!

Just for completeness' sake. Here's 2018 (same trick, different character):

```
Int('ߢ')

```

Try it online!

And just for fun, here's a function using bit shifting and arithmetic instead of using character codepoints (depends on this being Julia version 0.6, which seems an appropriately golf-y hack):

# Julia 0.6, 47 bytes

```
(l=VERSION.minor,o=true)->o<<(l+l-o)-o<<~-l-o-o

```

Try it online!

Here, `o=true` evaluates as 1 during arithmetic. `VERSION` is an inbuilt constant containing the current Julia version, and `VERSION.minor` is 6 in this case. We left shift 1 by 6+6-1=11, giving 2048, then subtract `1<<(6-1)`=32 and 1 and 1 from it, to give 2014.

2018 version would be:

```
(l=VERSION.minor,o=true)->o<<(l+l-o)-o<<~-l+o+o

```
> 3 votes

# Answer
# MathGolf, 2 bytes

```
ID

```

Try it online!

## Explanation

```
I   Pushes 20
 D  Pushes 14

```

The stack is printed in full on termination.
> 3 votes

# Answer
# Keg, 2 bytes

```
ߞ

```

Keg auto pushes any characters that aren't instructions to the stack, and `ߞ` has a unicode value of 2014, which then gets printed.

Try it Online!
> 3 votes

# Answer
# Raku (previously Perl6)

Raku interpret Unicode numbers as usual numbers, so:

## In REPL – 7 bytes (3 chars):

```
⑳~⑭

```

## Without REPL – 11 bytes (7 chars):

```
say ⑳~⑭

```

you can run it as `rakudo -e "say ⑳~⑭"`
> 3 votes

# Answer
# Hexagony, 3 bytes

```
ߞ!

```

Try it online!

Or if you prefer code that terminates, here's 4 bytes:

```
ߞ!@

```
> 3 votes

# Answer
# APOL, 38 bytes

`-(⒏ l(*("eeeeeeeeeeeeeeeee" l("ee"))))`

⒏ is a built-in constant that equals 2048, which is only 34 off from 2014. I use the length function to take the length of a 17-character string multiplied by 2 (which is shorter than a 34-character string) and implicitly print the result.
> 3 votes

# Answer
# Fig, 4 bytes (UTF-8)

```
C/ߞ

```

Try it online!

Char casting, as most others.
> 3 votes

# Answer
# Python 3, 27 bytes

I went through the effort of writing this script:

```
def to_base(n: int, b: int) -> str | None:
    if not 1 < b < 37:
        raise "Impossible base, try using a base between 1 and 37 (beginning and end not included)"

    if n == 0:
        return '0'

    possible_digs = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    res = []

    while n > 0:
        res += possible_digs[n % b]
        n //= b

    return ''.join(reversed(res))

def to_base_letters_only(n: int) -> str:
    bases_found = []
    for b in range(11, 37):
        c_n = to_base(n, b)
        digs_l_10 = False

        for d in c_n:
            if d in "0123456789":
                digs_l_10 = True
                break

        if not digs_l_10:
            bases_found.append([c_n, b])

    print(bases_found)

    if bases_found == []:
        return "No conversion found"
    return f"Conversion found: {(min_base := min(bases_found, key=lambda c: len(c[0])))[0]} in base {min_base[1]}"

print(to_base_letters_only(2014))

```

Which found `BBC` in base 13, which is 2014, without using arabic numerals.

So, my answer is this:

```
print(int("BBC",ord("\r")))

```

Try it online!

`\r` is Unicode 13.

Fun fact: This answer is 1 byte behind the Python 2 answer, because of `print` needing parentheses.

That script can also be used to find solutions for other numbers.
> 3 votes

# Answer
## Fortran: (43 27)

```
print*,z'FBC'/len('hi');end

```

Thanks to Hristo Iliev, the above is about 40% smaller! `z'FBC'` returns the decimal form of that hex value (which is 4028), `len` returns the length of `hi` (i.e.,2).

Original answer:

```
print*,ichar(',')*ichar(',')+ichar('N');end

```

Converts the string `,` and `N` to ASCII values: 44 & 78 respectively: 44\**2 + 78 = 1936 + 78 = 2014.
> 2 votes

# Answer
# PHP (21 chars)

```
<?=ord('').ord(''); //These are not empty strings ;)

```

If you don't believe it, see the proof.
> 2 votes

# Answer
# Python 51

Using true = 1 and false = 0

```
t=True
print str(t+t)+str(t-t)+str(+t)+str(t+t+t+t)

```
> 2 votes

# Answer
# Python, 30 chars

```
s=int('RZ',ord('$'));print s+s

```

2014 =\> 2 * 1007 =\> RZ in base 36 =\> ascii code for $ character

In interpreted mode, without the print statement it is 24 chars:

```
s=int('RZ',ord('$'));s+s

```
> 2 votes

# Answer
### Julia, 13 characters

```
('x'-'e')*'j'

```

In Julia, most arithmetic operations, when applied to a single character, convert this character to its ASCII integer value. `x`, `e` and `j` are respectively 120, 101 and 106, therefore (120-101)\*106 is 19\*106=2014.

```
julia> ('x'-'e')*'j'
2014

```

**Edit: 11 characters, thanks to Glen O**

A different choice of characters allows us to skip parentheses:

```
'.'*'.'-'f'

```
> 2 votes

# Answer
# Bash, 29 bytes

Bash without using external programs:

```
echo $((x=++y+y))$?$y$((x+x))

```
> 2 votes

# Answer
# ~-~! (No Comment), 41

Pretty basic solution.

```
'=~~~~~:''=~~,','@'':@''-~~:@''-~:@''+~~:

```

Pretty good for just 8 unique characters, eh? xD So this could theoretically be stored in 123 bits, or ~15.4 bytes.
> 2 votes

# Answer
# k \[16 chars\]

```
(*/"i"$".,")-@""
2014

```

### Explanation

Get the ASCII value of ",.".

```
"i"$".,"
46 44

```

Find the product

```
*/"i"$".,"
2024

```

Get the data type of char.

```
@""
10h

```

On running the complete code (2024-10)

```
(*/"i"$".,")-@""
2014

```
> 2 votes

# Answer
## \>\<\> (9 bytes ASCII)

In pure ASCII,

```
'd!:'*+n;

```

This pushes `d`, `!`, and `:` to the stack, then multiplies the numerical values of top two entries, and adds the value of the last entry before outputting the value on top of the stack as a number and ending.

Using Unicode this can be reduced to 6 bytes:

```
'ߞ'n;

```

Simply outputs the numerical value of `ߞ` and ends.
> 2 votes

# Answer
# C#, 4 characters, 5 bytes

```
+'ߞ'

```

Note: you need LINQPad to run it, not Visual Studio. LinqPad is good for CodeGolfing in C#.
> 2 votes

# Answer
# Insomnia, 7

Each line is one program doing the same thing: print `2014` to output stream.

```
e}u#Hi-
e}u#Hs-
e}u#H}-
e}g#*i-
e}g#*s-
e}g#*}-
e}gKHi-
e}gKH}-
e}gKxi-
e}gKxs-
e}gKx}-
e}u#dK-
e}u#eK-
e}u#fK-
e}gKdK-
e}gKeK-
e}gKfK-

```
> 2 votes

# Answer
# JavaScript, 24 bytes

A bit long, but no idea how this way got left out...

```
alert("ߞ".charCodeAt())
```

**Explanation**

The character `ߞ` is obtained by doing `String.fromCharCode(2014)` . Thus the code is actually just converting that character back to its character code and alerting it.

*Thanks to hsl for this shorter version*
> 2 votes

# Answer
## Python 2 (19 bytes, ASCII only, CPython-specific)

```
print hash("w_'qe")

```

Tested only on 64-bit, but I assume/hope that since 2014 is small and positive the results would be the same on 32-bit? Originally tested on Python 3, but ProgramFOX confirms it also works on Python 2.

## Python 3 (31 bytes, ASCII only)

```
print(ord("\N{NKO LETTER KA}"))

```

Quite fond of this one, even though better solutions exist. The equivalent Python 2 code is no shorter, as it required a u string prefix.
> 2 votes

# Answer
# CMD - 42 bytes

```
set/aa=f
set/a%a%xAAA-%a%xFF-%a%xFF-%a%xCE

```

The 'trick' is that when using the `/a` switch on the set command, letters (and other invalid characters) are evaluated as `0`. I then just use hexadecimal to evaluate 2014. The 0 is needed because in CMD hexadecimal must be expressed with the leading `0x`. There is almost definitely a shorter way to get to 2014...

```
%a%xAAA - %a%xFF - %a%xFF - %a%xCE = 2730 - 255 - 255 - 206 = 2014

```
> 2 votes

# Answer
# Python (30 chars)

(10 + 9) * 106 = 2014

```
(ord('\t')+ord('\n'))*ord('j')

```
> 2 votes

# Answer
# Hassium, 77 Bytes

Really excited about this one. It gets Math.pi and divides it by itself in variable a (1), then uses increment and basic math operators to get it to 2014.

```
use Math;func main(){a=Math.pi;a/=a;print(++a)print(a-a)print(a/a)print(a*a)}

```

Run online and see expanded here
> 2 votes

# Answer
**T-SQL 27 bytes**

```
PRINT ASCII('')*ASCII('j')

```

Note that the character that isn't rendered here is the DC3 (CHAR(19)) in the first set of quote marks. It's unicode U+009F which, it would appear, doesn't copy and paste here too well but I can assure you it works in SQL Management Studio.
> 2 votes

# Answer
# Jolf, 3 bytes

(It's almost 2016. Language *obviously* postdates question.)

```
@ߞ
@  Get charcode of next character
 ߞ charcode 2014

```
> 2 votes

# Answer
# JavaScript, 9 bytes

```
btoa`ÛMx`

```

This Base-64 encodes `ÛMx` to make `2014`.
> 2 votes

# Answer
## Lua, 32 bytes

```
print(#'XX'..#''..#'X'..#'XXXX')

```

This makes use of the length operator `#` used on string literals to get numbers, and the lengths are concatenated (with `..`) to print `2014`
> 2 votes

# Answer
# Fourier, 12 bytes

***Non-competing:*** *Fourier is newer than the challenge*

I know I'm two years too late, but it seemed like a fun challenge to do in Fourier.

```
^^ovvo^o^^^o

```

The command `^` increments the value of the accumulator (which starts at zero) and `v` decrements the value of the accumulator.

**Try it online!**
> 2 votes

# Answer
## Straw, 13 bytes

```
(…………………σ)«$>

```

`«` sum the codepoint of all characters in a string, `$` convert from unary to decimal and `>` is the print operator.

Try it online
> 2 votes

# Answer
# Jelly, 3 bytes

```
⁽¥Æ

```

Try it online!
> 2 votes

# Answer
# Brain-Flak, 50 bytes

```
((((((()()()()()){}){})){}{}()){()()({}[()])}{}())

```

Try it online!

Brain-flak is great for restricted source challenges because there are only 8 valid character to begin with: brackets. (e.g. `[]{}()<>`).

This was made possible with the help of @ASCII-only's integer metagolfer, which is currently hosted online at brain-flak.github.io/integer
> 2 votes

# Answer
# Brain-Flak, 46 + 3 = 49

Try it online

```
(([()]([(()()())]((((({}){}){}()){}){})))()())

```

This one uses the `-A` flag for +3 bytes. It pushes the ASCII values for 2014 to the stack which outputs as 2014 in ASCII mode.
> 2 votes

# Answer
# Lean Mean Bean Machine, 53 bytes

```
\\\
O))\ \
#)) o )
 ))u ))
 ))  ))
 ))  )u
 ))  ~
~~~

```

I like this.
> 2 votes

# Answer
# , 21 bytes

```
,":,.$,:~}.,:,:'golf'

```

Try it online!

```
               'golf'  One dimensional array
           ,:,:        Itemize twice (1x1x4 array)
         }.            Drop first element (0x1x4)
      ,:~              Append to itself as distinct items (2x0x1x4)
     $                 Get dimensions (2 0 1 4)
   ,.                  Flatten items, essentially prints 2014 vertically.
                       (so there are no spaces)
,":                    To strings, flatten.

```

# 20 bytes

```
#.(#_),,~(,~,~#_),%_
#.(#_),,~(,~$,._),%_

```

# 15 bytes

```
do'bbbc',~":_bd

```

# 11 bytes

```
,":_bk,:_be

```
> 2 votes

# Answer
## \>\<\>, 7 bytes

```
aa+nen;

```

Try it online!

```
aa                      +                           n                                    e                 n                                    ;
^^                      ^                           ^                                    ^                 ^                                    ^
Push 10 to stack twice, add top two items in stack, print top item in stack as a number, push 14 to stack, print top item in stack as a number, stop.

```
> 2 votes

# Answer
# JavaScript, various solutions: 131, 44, 43, 30, 28, and 16 characters (16 bytes)

**Original answer:**

JS-fuck inspired JavaScript, 131 characters:

```
(!![]<<(!![]<<!![])<<!![]<<(!![]<<!![])<<!![]<<(!![]<<!![])<<!![]<<(!![]<<!![]))-((!![]<<!![])<<!![]<<(!![]<<!![])<<!![])-!![]-!![]

```

Shifty truth edition:

```
(true<<(true<<true)<<true<<(true<<true)<<true<<(true<<true)<<true<<(true<<true))-((true<<true)<<true<<(true<<true)<<true)-true-true

```

## Addenda

**Edit:** I'm having too much fun with this... combining type coercion with hex strings, 44 characters.

```
a=+[];(a+'xade')-(a+'x'+(+!a+!a+!a)+a+a)
a=+[];(a+'xade')-(a+'x'+(++a+a+a)+--a+a)

```

`a` is 0, `0xade` is 2782. We need to subtract 768 to get 2014. 768 is 0x300. `(a+'x'+(+!a+!a+!a)+a+a)` and `(a+'x'+(++a+a+a)+--a+a)` are two ways of producing `"0x300"`, so the final result is `"0xade" - "0x300"`, which JavaScript coerces back to numbers, resulting in 2014.

Here is a radix 36-based `parseInt` solution, 43 characters:

```
(a=+[]);parseInt(++a+'jy',a+++a+++''+(a+a))

```

First, we initiate a variable `a` at 0 (clearly this requires non-strict mode), increment it to 1, concatenate with 'jy' - `1jy` happens to be 2014 in radix 36. The quickest way call parseInt at this radix is to generate the *string* `"36"` and abuse type coercion again: `a++ + a++` results in 3, with `a` set to 3 as well, which means `(a+a)` is 6, so `a+++a+++''+(a+a)` results in `"36"`, resulting in 2014.

After coming up with these two solutions I started looking at other JavaScript answers (thanks for the tip, Scrooble!), to see if combining ideas from other people gives interesting results.

Zaq's approach can be shortened with the hex string trick to 28 characters:

```
-~[]+!![]+[+[]]+ +(+[]+'xe')

```

How it works: `-~[]+!![]+[+[]]` results in `"20"`, `+[]+'xe'` results in `"0xe"`. `+"0xe"` is 14, so `"20" + +"0xe"` becomes `"20" + 14`, which becomes `"2014"`.

Now here's a fun fact: 20 in hexadecimal is `0x14`! Oh, and 14 is `0xe`. So `+('0x' + 0xe)` produces 20. Combining this with the above results in a 30 character solution:

```
_=+[]+'x';+(_+ +(_+='e'))+[+_]"

```

Finally, initially inspired by Dan Prince's answer I came up with what might be the shortest possible JavaScript solution abusing hex-strings, at 16 characters:

```
+[]+'xfbc'>>!![]

```

`0xfbc` is 4028. Shift right by one, and we have 2014. If anyone knows of a shorter way to generate 0 or 1, let me know.

**Edit2**: having exhausted the hexadecimals, we should of course also look at binary and octal notation!

```
// +'0b11111011110'
+(a=+[],a+++'b'+(a+(((a+=[a]+a+a+(+[])))+a)))
// +'0o3736'
+(a=-~[],a=a+++a+++''+(a+a),+[]+'o'+((+a+1)+a))

```
> 2 votes

# Answer
# Pyt, 27 bytes

```
ɳąḞḞ⬠⬠⬠π⎶⁻⦋ĐąžΠ²+ĐŚřƩ½*-⁻⁻Ɩ

```

Try it online!

Not exactly a serious contender, just had some fun.

```
ɳ             push '0123456789' as string
 ą             convert to array of digits [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  ḞḞ            for each item in array, replace with xth fibonacci # (2x) [1, 1, 2, 3, 8, 34, 377, 17711, 9227465, 225851433717]
   ⬠⬠⬠          for each item in array, replace with xth pentagonal # (3x) [1, 1, 1820, 66045, 240027425, 29321506727800, 6947548864499411875070L, 165405818231059923692911546880492501L, 898044801648686628863443901192030771814779461710865094720L, 115670237695821250427139838385782853032222541808893547195455834936957002151009052998969975100L]
       π⎶⁻           push pi, round, and decrement (2)
          ⦋         get the 2th element of that list (1820)
           Đ         Duplicate 1820
            ąž        make an array of digits and remove zeroes [1, 8, 2]
              Π        multiply together (16)
               ²+       square and add (2076)
                 ĐŚ      Duplicate and sum digits (15)
                   řƩ     make a range from 1 to 15 and sum all (120)
                     ½*    multiply by 1/2 (60)
                       -    subtract  (2016.0)
                        ⁻⁻   decrement (2x)   (2014.0)
                          Ɩ   cast to integer (2014)
implicit output

```
> 2 votes

# Answer
## JavaScript (ES6), 52 46 bytes

```
t=-~'';console.log(`${++t}${t-t}${t/t}${t*t}`)

```

Try it online!

Will log through `console.log` the number `2014` as a string.

*Thanks to Jacob for multiple optimizations saving 6 bytes*

### Explanation

```
t=-~'';

```

In JavaScript, `~~` will convert the proceeding value to a number, in this case, `true` equates to `1`.

Set the value of `t` to `1` by using `~` on an empty string, which would equate to `-1`, then take the opposite of that number, `1`.

For more info about tilde in JavaScript, see this article.

```
console.log(` ... `)

```

Logs the template string `...` with `${}` expressions available, where `...` includes:

```
${++t}

```

Sets `w` to `t+t`, which would be 2, which would return the number `2`. Added to string.

Set `t` to itself `+ 1`, and display the final result, `2`

```
${t-t}

```

Displays `t-t`, which would be `0`, which would return the number `0`.

```
${t/t}

```

Takes the value of `t` and divides by itself, returning `1`.

```
${t*t}

```

Takes the value of `w*w*w*w-w` (or `w ^ 4 - 1`), where w (as previously set) is `2`, and subtracts w from it, and returns the result. Added to string.

Takes the value of `t*t` (or `t ^ 2`), where `t` (as previously set) is `2`.

The added expressions equate to `2014`, which `...` is in the log.
> 2 votes

# Answer
# Lost, ~~57~~ ~~23~~ 22 bytes

```
<^/*(
 )/@+
">>v
^?%<<

```

My first Lost answer. Thought I'd start with an easy one.

Byte-count more than halved (-35 bytes) thanks to *@JoKing*.

Try it online or verify that it's deterministic.

**General explanation about Lost:**

Let me start with an explanation of Lost itself. Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that ***both the start position AND starting direction it travels in is completely random***. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.

A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up, down, left, or right.

In Lost you therefore want to lead everything to a starting position so it follows the designed path you want it to. In addition, you'll usually have to clean up the stack when it starts somewhere in the middle.

**Program explanation:**

The 22-bytes program is similar as the previous 23-bytes program below, but with a smarter path to save that byte:

```
v<<<<<>>>>>
>%?"^ <"*+@

```

Let me start with an explanation of the 23-bytes program:

The `"^ <"` will push the character-codepoints for the three characters in the string, being `94 32 60` respectively. The `*` multiplies the top two, and `+` adds the top two of the stack, so it becomes `94+(32*60)`, which results in `2014`.

The `@` will terminate the program, but only if the safety is 'off'. When the program starts the safety is always 'on', otherwise the program starting at the exit character immediately terminates without doing anything.
The `%` will turn the safety 'off'. So as soon as the `%` is encountered and the safety is 'off', the program can be terminated with an `@`.

The `?` is to clean up the stack if it started somewhere in the middle.

And finally the `v<<<<<>>>>>`, `>` and use of `^ <` in the string are to lead the program path towards the correct starting position for it to correctly print `2014`. Note that the top line could have been `v<<<<<<<<<<`, but that the reversed part `>>>>>` will wrap-around to the other side, making the path shorter and therefore the performance slightly better. The byte-count remains the same anyway, so why not.

---

Now for the 22-bytes solution, and how it actually is the same as the 23-bytes solution, but with a different path.

The arrows are still used to lead the path into the given direction. The `/` are used as a mirror. So if we go from right to left and encounter the `/`, it will continue downwards; if we go from the top to the bottom and encounter the `/`, it will continue towards the left; etc.

The `(` will pop the top value on the stack and push to to the scope, and the `)` will do the reversed: it pops from the scope, and pushes it back to the stack.

So regardless of where we start and in which direction we travel, the path leads towards the first `<` of the bottom row. From there, the program flow travels in this order:

```
%?^        Direction changed upwards
" <^" <    Direction changed towards the left
(*/        Direction changed downwards
/          Direction changed towards the left
) +@

```

So it will:

* Turn the safety 'off' with `%`;
* Clean the stack with `?`;
* Push the character-codepoints for `" <^"`, which are `32 60 94` respectively;
* Pop the `94` and store it in the scope with `(`;
* Multiply the `32 60` with `*`, resulting in `1920`;
* Push the `94` from the scope back onto the stack with `)`;
* Add the `1920 94` together with `+`, resulting in `2014`;
* And then terminates the program with `@`, implicitly outputting the top of the stack.
> 2 votes

# Answer
bc, 7 bytes. Try it Online!!

`K*ZZ+Y`

bc, 8 bytes. Try it Online!!

`K*A*A+E`

Which needs 14 bytes to run in bash:

`bc<<<"K*A*A+E"`

In `bc` the upper (single) letters maintan their meaning as a number in 10-36 range in **any input base**.

A previous approach changed the input base:

`echo ibase=D\;BBC|bc`

Make numeric base 13 (`D`) and print `BBC` in that base --\> 2014.
> 2 votes

# Answer
# Flobnar, ~~17~~ 14 bytes

```
<+\@:!
+<>.!..

```

Try it online!

### Explanation:

```
   @       Start, going left

  \        Push to the stack the value from the bottom row
  >

   .!..   Several print statements we will get back to
<   :!    Add the not of the top of the stack to itself
+         This is !0+!0 = 2

      .   Print the 2

     .    Print the result of the print (0)

   .!     Print the result of the not of the print (1)
  \       Continue forward after pushing the zero to the stack

<+   :!   Add the same 2 from the beginning to itself
+<        (!0 + !0)+(!0 + !0) = 4
          And print implicitly as the last value

```
> 2 votes

# Answer
# Python 3, 16 bytes (15 characters)

```
print(ord('ߞ'))

```

Try it online!

## Explanation

`ord` returns the decimal Unicode of a character, and the decimal Unicode of ߞ happens to be 2014.

## Python 2?

I tried doing the same thing in Python 2 (`print ord('ߞ')`), which would be 1 byte less, but this doesn't work. Why? Well, in Python 3, `len('ߞ')` returns `1`, so everything is fine. However, in Python 2, it returns `2`. And since `ord` only takes a string of length 1, Python 2 doesn't really like that: `TypeError: ord() expected a character, but string of length 2 found`
> 2 votes

# Answer
# C#, 25 bytes (24 characters)

```
Console.Write((int)'ߞ');

```

Try it online!

### Explanation

The decimal Unicode of ߞ is 2014, so you can just cast it to an int and `2014` is printed.
> 2 votes

# Answer
# 05AB1E, ~~22~~ ~~10~~ ~~8~~ ~~7~~ 6 bytes

```
T·žvÍJ

```

Try it online!

How it works:

* `T` pushes 10, `·` doubles it, we get 20.
* `žv` pushes 16, `Í` subtracts 2, we get 14.

Lastly, we concatenate them using `J`!
> 2 votes

# Answer
# Python, ~~52~~ 49 chars

```
from math import*
print(int((e*pi+e)**pi+e/e+e))

```

Works in Python 2 and Python 3.
> 2 votes

# Answer
# MAWP, 16 bytes

```
!!M:!!A:!:!!M!M:

```

```
chr:pos:stack
! : 1 : [1,1]
! : 2 : [1,1,1]
M : 3 : [1,2]
: : 4 : [1]
! : 5 : [1,1]
! : 6 : [1,1,1]
A : 7 : [1,0]
: : 8 : [1]
! : 9 : [1,1]
: : 10 : [1]
! : 11 : [1,1]
! : 12 : [1,1,1]
M : 13 : [1,2]
! : 14 : [1,2,2]
M : 15 : [1,4]
: : 16 : [1]

```

Try it!
> 2 votes

# Answer
# Labyrinth, 12 bytes

```
))!!)!))))!@

```

Try it online!

```
))))_#!!#!!@

```

Try it online!

```
))_#"
 ) !!@

```

Try it online!

```
))!"
)
)#!!@

```

Try it online!

I tried both linear and complex layouts, but I can't figure out how to remove a single byte from any of these programs.
> 2 votes

# Answer
# Hexagony, 18 bytes

```
g{A*'-"'-'"Av<@!}/

```

```
   g { A
  * ' - "
 ' - ' " A
  v < @ !
   } / .

```

I had trouble getting it to fit in 19 bytes (side length 3) because I was always 1 short, then I rearranged my memory accessing to be 1 shorter, which also allowed me to use a very efficient layout. Then I was able to shift a no-op somewhere in the code to the very end saving a byte.

Try it online!
> 2 votes

# Answer
# Husk, 4 bytes

```
c'ߞ

```

Try it online!
> 2 votes

# Answer
# Python 3, 49 bytes

```
for i in['..','','.','....']:print(len(i),end='')

```

# Python 3, 15 bytes

```
print(ord('ߞ'))

```
> 2 votes

# Answer
# Scratch, 82 bytes

```
when gf clicked
say(join(length of[The year two thousnd])(length of[and   fourteen

```
> 2 votes

# Answer
# CSASM v2.4.0.2, 83 bytes

```
func main:
push "  "
len
print
push ""
len
print
push " "
len
print
push "    "
len
print
ret
end

```

The only way to push numbers to the stack without using numbers is to create `str` instances and then get their lengths.
> 2 votes

# Answer
# Alphabetti spaghetti, 15 bytes

```
aiioaoaioaiiiio

```

Try it online!
> 2 votes

# Answer
not sure if others have used this one already :

> **from any UTF-8 aware shell**
>
> * ```
> printf %d \'ߞ
>
> ```

**13-chars** spanning **14-bytes**. the following are equivalent forms :

```
printf %d \'$'\xDF\x9E'
printf %d \'$'\737\636'

```
> 2 votes

# Answer
# ACCUMULATOR, ~~2015~~ 28 bytes

*-1987 bytes thanks to a near-escape from the Orwellian thought police!*

```
AAAAAAAAAAAAAAAAAAAACMMMMMMO

```

This is pretty simple:

* 20 `A`s increment the accumulator: `20`
* `C` concatenates it to itself: `2020`
* 6 `M`s decrement: `2014`
* `O` outputs

Old version here
> 2 votes

# Answer
# Desmos, ~~40~~ ~~26~~ 25 Bytes

```
b=\ln ee
k=bb
k^kkb-kkb-b

```

Desmos graph link

Now smaller by a whole 1 more byte! Yaaay...

## Version that needs each line to be pasted individually, ~~24~~ 23 bytes

```
b=lnee
k=bb
k^kkb-kkb-b

```
> 2 votes

# Answer
# Java, 18 bytes

Just for the sake of using hashCode().

```
"bmgjagr".hashCode() = 2014
"?=".hashCode() = 2014
"zsjpzdq".hashCode() = 2024

```

In order to find a candidate string, I iterated over all the strings of 7 and less characters in the range \['a', 'z'\]. It represents a set of 8'353'082'583 strings and thus a good probability that one of them has the required hashCode.

Thanks to anatolyg, using more characters allows a much simpler string : "?=" (ASCII 63 and 61), 63 * 31 + 61 = 2014.

79 bytes full class:

```
class C{public static void main(String[]a){System.out.print("?=".hashCode());}}

```

18 bytes lambda:

```
x->"?=".hashCode()

```
> 2 votes

# Answer
# Python 3, 54 bytes

```
n=mp.dps=ord('㤃');print(str(mp.pi)[n-len('year'):n])

```

Try it online!

# How it works

Extracts the year \\$2024\\$ beginning at the \\$14591^{st}\\$ digit of \\$\pi\\$

3.14...2761728583024355983003204**2024**512072872535581195840...

The next 10 years that eventually appear in Pi's decimal expansion!
> 2 votes

# Answer
## ANSI C - ~~95~~ ~~47~~ 52 characters

~~```
#include <stdio.h>
main() { printf("%i", (('a' + 'a')/'a') * ('\a' + '\f') * ('<' - '\a') ); }

```
This program uses characters to initialise integers and multiplies: 2 * 19 * 53.<br>~~

~~#include main(){printf("%i",'\aÞ');}~~

~~This program initialises an integer using charaterbytes and prints it. `'\aÞ'` is the bitpattern 00000111 11011110 this is also the bitpattern of 2014.<br>---~~

~~Disclaimer: this was made on a windows system with visual studio. This code depends on a lot of things, including - How your compiler endodes the characters you input. `Þ` has an ascii value of 222 (or its negative equivalent), this may vary depending on your system. The notation `int a = 'abcd';` is in itself evil and depends on how memory is handled on your system - this includes endian issues. `int a = '\0A';` a is 65 on my system but may be 16640 on your system.~~

```
main(){printf("%i",('C'-'A')*('T'-'A')*('v'-'A'));}

```

I went back to Version one and multiplied 2 * 19 * 53. This version uses only one byte at a time so it is endian compatible. Also it uses only characters in the range of \[0 - 127\] to be compatible to all systems.
> 1 votes

# Answer
# Racket: 20 (19 chars)

```
(char->integer #\ߞ)

```

ߞ is a unicode character that has 2014 as it's code.

This abuses the fact that every top level form gets its evaluation printed to stdout. This is quite unique amongst LISPs which usualy only have this behaviour in the REPL and not when running programs.

# Scheme: 29 bytes (28 chars)

```
(display(char->integer #\ߞ))

```
> 1 votes

# Answer
# Solution 1

### Octave/Matlab (55 chars)

```
a=pi;b=a*a;disp(ceil(a^a^a/a/a/a-b*b*a-a^a*b+b*b-b-b));

```

---

# Solution 2

### PHP (9 chars without tags, 12 with them Actually 2022 because of the new lines involved)

```

<?=__LINE__;

```
> 1 votes

# Answer
## Game Maker Language, 22

```
show_message(ord("ߞ"))

```
> 1 votes

# Answer
# C - 44 characters (85 with headers)

What, no one is abusing strings yet?

```
#include<stdio.h>
#include<netinet/in.h>
main(){printf("%u",ntohs(*(int*)"\a\xde"));}

```

Interestingly, this is a special case where neither character is printable, but their special code doesn't involve a number.

If we want no warnings, it needs to become 55 (96) characters:

```
#include<stdio.h>
#include<netinet/in.h>
int main(){return!printf("%u",ntohs(*(int*)"\a\xde"));}

```
> 1 votes

# Answer
# C/C++ 39

```
main(){printf("%d%d",':'-'&',':'-',');}

```

ASCII for: ':' = 58, '&' = 38, ',' = 44. Using that, 58-38 = 20 and 58-44 = 14.
> 1 votes

# Answer
**120** characters in **Squeak Smalltalk** trunk (4.5).
I did not search the shortest, but kind of graphical solution:

```
((Text string:'Happy\New year'withCRs attribute:TextEmphasis narrow)asMorph borderWidth:Float one+Float one)bounds area

```

It depends on font, margins, and so is quite fragile, but at least for me it worked.
In Squeak 4.4, it works with lowercase 'happy\new year'.
> 1 votes

# Answer
# JavaScript, 49 Chars

A mathematical JavaScript version making use of only PI and E as source numbers.

```
(m=Math).pow(e=m.E,e*(p=~~m.PI))/m.sqrt(p)+e+e|""

```

... mmmm PIE.

Oh and just in case implicit returns are vetoed **(56 Chars with alert)**:

```
alert((m=Math).pow(e=m.E,e*(p=~~m.PI))/m.sqrt(p)+e+e|"")

```
> 1 votes

# Answer
## C++ - 63 bytes

I'm not sure if this method has been used, but I designed this myself anyway:

```
#include<iostream>
int main(){std::cout<<int('&'*(','+'\t'));}

```
> 1 votes

# Answer
**Clojure - 22**

```
(apply *(map int"j#"))

```

(note: the # is ASCII character 19, Stack Overflow doesn't seem to like this but it's valid Clojure source...)

**Clojure - 36**

```
(dec(reduce +(nnext(range(int\@)))))

```
> 1 votes

# Answer
## vba (immediate window), 38 26 13

using regular ascii characters (no funny typing needed)

```
?&ha+&ha&&&he

```

26

```
?val("&hfbc")/-(true+true)

```

38

```
?year((cdbl(asc("ê"))*cdbl(asc("²"))))

```

find a date that can be represented as a number, and select the year from that (in this case, Jan, 13, 2014)

have to use cdbl, as it assumes signed int, and overflows
> 1 votes

# Answer
## Clojure, no unicode tricks (49 characters/bytes)

Uses the fact that `*` called with no args evaluates to 1:

`(let[b(inc(*))j(+(* b b b)b)](+(* b j j j)j b b))`

Using the same trick and doing string concatenation instead of arithmetic, the lowest I could get was 51 chars:

`(let[n(*)t(+ n n)z(+)f(+ t t)](print(str t z n f)))`
> 1 votes

# Answer
## Ruby 1.9, 10 bytes

```
p 'ߞ'.ord

```
> 1 votes

# Answer
# Python, 23

```
print ord("<DC3>")*ord("j")

```

`<DC3>` should be replaced with ASCII symbol 19 (device control 3).
> 1 votes

# Answer
## SAS, 34 characters/bytes

```
data a;x=put(' ',hex.);put x;run;

```

That puts it to the log, it's 6 longer if you need it to the output window. Note I'm not seeing the second character there; it is backwards-P, which is hex 14.

There should be a shorter solution with `%sysfunc(putc(...`, but I can't get that to work properly.
> 1 votes

# Answer
### Edited: bash 81 chars!

Just for fun:

```
wc -c < <(echo {,}{,,}{,}{,,,}{,}{,,,}film dbugjkqstvxz{,}{,,} 'Happy New Year!')

```

there is no numbers, all letters are used and this print exactly:

```
2014

```

> ( This method could reasonably be used until 2016: by just adding one or two exclamation point after the wish:
>
> ```
>    wc -c < <(echo {,}{,,}{,}{,,,}{,}{,,,}film dbugjkqstvxz{,}{,,} 'Happy New Year!!')
>    2015
>
> ```
>
> ;-)

### bash 27 chars

```
.;v=$?;echo $v$?${#v}$[v+v]

```

This will output:

```
bash: .: filename argument required
.: usage: . filename [arguments]
2014

```

Ok, this will generate some unwanted output, but **2014** is printed and is *a valid token*!

The two following sample are *error free* (a little longer but near *golfed*)

```
v=$(echo {V..v});echo $[${#v}#vu]
2014

```

or

```
printf -vv "%d" $?xfbc;echo $[v>>${#?}]
2014

```

or even:

```
echo $[$[$[${#?}$?-${#?}]$?>>${#?}]#Iy]
2014

```

Inspired by comment from GammaFunction:

```
echo $[$[a-a]xfbd>>${#?}]

```
> 1 votes

# Answer
# JavaScript 45

```
alert(parseInt('bbc','twentyonefour'.length))

```
> 1 votes

# Answer
# Bash - 10 (or 8)

Well there have been a couple of answers that have been disqualified because they rely on the year. When golfing, one side goal is to see how close we can get to breaking the rules as currently written without breaking the letter of the rules (I include the clarifications by Joe Z in the 66 existing comments on the rules). The question very specifically states that I can not `depend on 2014 being the current year`. I instead rely on it being 8:14pm in my timezone.

```
date +%H%M

```

When I ran it, it output 2014 exactly, thus it satisfies it `No, it has to be 2014 exactly.` comment. (Due to context people seem to misread it as `... 2014 always`, but that was not what was written, even if that were perhaps what was intended.) This lets me beat the current `Bash` record, at least until this loophole is closed. This interpretation may seem too cheaty since all the existing popular answers assume that the rules really meant `always`. Indeed some of them exploit this and export something that isn't exactly 2014, but instead contains 2014. I am fine with that interpretation too since `Bash` can do:

```
cat /*/*

```

This is a mere 8 characters, which will concatenates a bunch of files including `/dev/urandom/`, and it generally takes my machine under a minute to find 2014 in /dev/urandom. Although my rule twisting golfing code of honour won't let me pick this solution since it violates the letter of Joe Z's clarification, the only objection Joe Z raised to the random approach in the 66 comments was that it was too long. At 8 characters this answer is actually shorter than my rules-lawyer answer.
> 1 votes

# Answer
# Python, 55 bytes (no math import and no char or unicode trickery!)

```
x=False;a=x**x;b=a+a;c=b+b;print c**c*(c+c)-b**(c+a)-b

```

Uses the fact that zero to the zeroth power is defined as one and `False` can be implicitly casted to 0. Hence a, b and c will contain 1, 2 and 4 respectively.
> 1 votes

# Answer
# Marbelous 14

```
CB
CE
CF
CD
~~

```

**How it works**

the first 4 lines are language literals, in hexadecimal. Their values are 203, 206, 207 and 205. They will fall down by one cell on each tick. If you perform an 8-bit binary not on those values (which is exactly what `~~` does) you get the following values: 52, 49, 48 and 50. These values happen to be the ascii values of 4, 1, 0 and 2 respectively. The literals then fall off the board which causes their corresponding ascii character to be printed to STDOUT.
> 1 votes

# Answer
# C, 27 Bytes

```
main(){printf("%d",'\aÞ');}

```

Just a reminder that multi-character constants do exist :)

Alternatively, three bytes more:

```
main(){printf("%x",' i'-'U');}

```
> 1 votes

# Answer
# Lua - 30 bytes

`b=#" "print(b..b-b..b/b..b+b)`

`#` is the length operator, so `b = 2`.
> 1 votes

# Answer
(Java, 553 bytes as .class, 112 bytes as it stands, 84 bytes after renaming the class to 'm' and removing whitespace.)

This probably isn't the kind of answer you're looking for, but there are a bunch of strings that share a hashcode of 2014.

```
public class make2014 {
    public static void main(String[] args){
        System.out.println("={".hashCode());
    }
}

```
> 1 votes

# Answer
# Xojo, 27 chars (all ASCII)

```
MsgBox Str(&hFBC/(&hC-&hA))

```
> 1 votes

# Answer
## TinyMUSH, 16

We need more MUD language entries.

```
\encrypt($"#&,.)

```
> 1 votes

# Answer
## C++ 30

```
main(){cout<<('&')*(']'-'(');}

```
> 1 votes

# Answer
# x86 machine code, 19 bytes

`B8 3A 0E 2C 08 CD 10 2C 02 CD 10 04 01 CD 10 04 04 CD 10`

Assembly code equivalent:

```
mov ax, 0E3Ah; ah = 0Eh (bios teletype), al = 3Ah (ascii semicolon)
sub al, 08h; ascii 2
int 10h

sub al, 02h; ascii 0
int 10h

add al, 01h; ascii 1
int 10h

add al, 04h; ascii 5
int 10h

```

Yeah, I know: it logs `2015` rather than `2014`.

But seeing that this challenge is old and now the year is 2015, it seemed more appropriate to use the current year (it's my excuse for not "going home" :) )

*Note: This was tested using DOSBOX*
> 1 votes

# Answer
## JavaScript (19)

Obvious cheating, but these expression ran in REPL print strings "2014" and "2015":

```
''+'ߞ'.charCodeAt() // 2014
''+'ߟ'.charCodeAt() //2015

```

TIL: `.charCodeAt` implicitly converts it's first argument to 0.
> 1 votes

# Answer
# Vitsy, ~~5~~ 4 Bytes, 3 Characters

When in Rome...

```
'Nߞ
```

Get the character with the value 2014 and then print it as a number. Simple.

### More Interesting Version (~~12~~ ~~10~~ 9 Bytes):

```
"ca-^b-N-
```

My language supports hexadecimal, too. ;)

```
"         Capture the entire source as string by looping around the source.
 ca-      Push 2 to the stack
    ^     45^2
     b-   -11
       N  Output as a number.
        - Only here for character value 45.

```
> 1 votes

# Answer
# Perl 5, ~~8~~ 28 bytes

~~say 38\*53~~

~~Seems to do it.~~

Oh, *without cheating* ?

```
$z=ord("!")*ord("=");say++$z

```
> 1 votes

# Answer
# Milky Way 1.0.0, 22 bytes

```
<^a:::+;:l+:>h<::++-<-

```

---

### Explanation

```
<          <     <   # rotate the stack leftward
 ^                   # pop the TOS without outputting
  a                  # logical not on the TOS
   :::  :   ::       # duplicate the TOS
      +       ++     # push the sum the top two stack elements
       ;             # swap the top two stack elements
         >           # rotate the stack rightward
          h          # push the TOS to the power of the second stack element
                - -  # push the difference of the top two stack elements

```

The stack defaults to `["", 0]`.

---

### Stack Visualization

```
["", 0]                # default stack

[0, ""]                # <
[0]                    # ^
[1]                    # a
[1, 1, 1, 1]           # :::
[1, 1, 2]              # +
[1, 2, 1]              # ;
[1, 2, 1, 1]           # :
[1, 2, 1, 10]          # l
[1, 2, 11]             # +
[1, 2, 11, 11]         # :
[11, 1, 2, 11]         # >
[11, 1, 2048]          # h
[1, 2048, 11]          # <
[1, 2048, 11, 11, 11]  # ::
[1, 2048, 33]          # ++
[1, 2015]              # -
[2015, 1]              # <
[2014]                 # -

```

By default, if nothing has been output manually, the bottom stack item is output on termination of the program.

---

# Milky Way (current version), 8 bytes

```
XZ*W+U+!

```

---

### Explanation

```
X         # push 20 to the stack
 Z        # push 100 to the stack
  *       # push the product of the TOS and STOS
   W      # push 10 to the stack
    + +   # push the sum of the TOS and STOS
     U    # push 4 to the stack
       !  # output the TOS

```
> 1 votes

# Answer
# SMBF, 15 bytes

`\x00` is a literal NUL byte. This program adds 5 to each of `/,+-` and prints.

```
<[+++++.<]\x00/,+-

```

Only my Python interpreter can accept non-printable ASCII. Change the data line to this, and substitute the code you want to run with the non-printable values escaped (on line 169):

```
data = bytearray(b'the above code goes here')

```
> 1 votes

# Answer
# Retina, 24 bytes (newer than challenge)

Note the trailing space on lines 2 and 3. Language is newer than the challenge.

```

xx  x xxxx
+`(x)*
$#+

```

**Try it online**
> 1 votes

# Answer
# Factor, 10 bytes

Not gonna beat my winning answer, but as a follow-on to the other "2014th Unicode char" answers:

```
CHAR: ߞ .

```

Prints 2014.
> 1 votes

# Answer
# Base64, 9 Bytes

`MjAxNA==`

(You can decode it with: echo MjAxNA== |base64 -d)
> 1 votes

# Answer
## Jelly, 10 bytes

```
⁹⁴×H_⁴Ḥ¤’’

```

Explanation:

```
⁹            Set the current value to 256.
 ⁴×          Multiply by 16. The current value is now 4096.
   H         Divide by 2. The current value is now 2048.
    _⁴Ḥ¤     Subtract by 16/2. The current value is now 2016.
        ’’   Decrement twice. The current value is now 2014.

```
> 1 votes

# Answer
# Mathematica, 10 bytes

```
N[E,E^E^E]

```

Prints the decimal expansion of the number *e* to over 3.8 million decimal places. The first occurrence of 2014 in that decimal expansion starts at the 3180th decimal place.
> 1 votes

# Answer
# VBA, 21 characters

```
?cells(,"BYL").column

```

Write and run the above code in the Immediate Window. Basically, the code converts column name BYL to its column index (2014).
> 1 votes

# Answer
# Actually, 15 bytes

This language was created long after this challenge was made, but I thought I'd still try my hand at it. This answer avoids all numerals, including Actually's `²` for `a*a`. Golfing suggestions welcome. Try it online!

```
╜⌐u;*⌐úl¬¬τu;*-

```

**Ungolfing**

```
╜    Push register 0 (initialized to 0).
⌐u   Add 2 and increment. Returns 3.
;*   Duplicate and multiply. Equivalent to squaring. Returns 9.
⌐    Add 2 again. Returns 11.
úl   Pushes the lowercase alphabet and gets its length. Returns 26.
¬¬   Subtracts 2 twice. Returns 22.
τ    double(). Returns 44.
u    Increment. Returns 45.
;*   Square. Returns 2025.
-    Subtract. Returns 2025 - 11 == 2014.

```
> 1 votes

# Answer
# Vim 8.0, 15 bytes

```
:h u
ggf:wywZZp

```

I didn't see a vim answer yet, so I figured I'd add one. This opens up a helpfile, so it is *specifically* vim 8.0, since it might not work with a future version that updates that file.
> 1 votes

# Answer
## JavaScript, ~~81~~ 76 bytes

```
l="length";alert(("hi"[l]<<"javascript"[l])-"wow"[l]*"hello death"[l]-true);
```
> 1 votes

# Answer
# C, 24

*(Using GCC-4.9.2)*

`f(){printf("%i",'Þ');}` (Properly formatted version on Pastebin)

---

**IMPORTANT NOTE**: There is a U+0007 in-front of the `Þ` character but stackexchange removes it for some reason. Make sure you edit it back in before compiling my code. Here is a pastebin of the code that does include the unicode characters needed.
> 1 votes

# Answer
# SmileBASIC, 10 bytes

```
?&HFBC>>!.

```

&HFBC is hexadecimal for 2014\*2, which is right shifted by not(0.0)

`?ASC("ߞ")` looks shorter, but it's actually the same length when saved in UTF-8, and about 100000x more boring.
> 1 votes

# Answer
# √ å ı ¥ ® Ï Ø ¿, 8 bytes

```
TTX''_o

```

Try it online!

The rest of the code in the TIO link is the Python interpreter (because I can't be bothered to ask Dennis to add √ å ı ¥ ® Ï Ø ¿
> 1 votes

# Answer
# Braingolf, 3 bytes

Try it online!

The ordinal of `ߞ` is 2014, `#` pushes the ordinal of the next character to the stack, and Braingolf implicitly outputs the last item on the stack.
> 1 votes

# Answer
# Charcoal, 5 bytes

```
Ｉ²⁰¹⁴

```

Try it online!

Language was created after January 1, 2014, but as Charcoal uses the superindices `⁰¹²³⁴⁵⁶⁷⁸⁹` to represent the numbers, the answer is valid. :-)
> 1 votes

# Answer
# Lua, 27 bytes

Should work in Lua 5.1, Lua 5.2, and Lua 5.3.

```
x="ɅɅ"print(x:byte()..#x)

```

Try it online!

This is mean to be saved with the UTF-8 encoding. The first byte of the string is 201, and its length is four. Lua is mostly encoding agnostic, so as long as these things are true in whatever encoding, it works.

With only ASCII, 28 bytes:

```
x=""io.write(x:byte(y,#x))

```

Note: the string must contain ASCII 20 and ASCII 14 (which are not printable characters). `y` here is an undefined variable, so it is `nil`, which `byte` defaults to `1` in the first parameter.
> 1 votes

# Answer
# Lua, 29 bytes

```
b=("").byte print(b"?"..b"?")

```

NB: the two question marks are substitutes for characters that are not appearing properly in the post. See the tio link below for proof.

Try it online!

As an interesting point, although this is not the case with Lua, a language with an implementation of pi to at least 3137 digits would be able to print pi and find '2014' at digits 3133-3136!
> 1 votes

# Answer
# Python, 41 bytes

```
print(int(ord("j")/len("aa") * ord("&")))

```

Try it online!
> 1 votes

# Answer
# PHP, 25 bytes

`<?=IntlChar::ord("ߞ");?>`
> 1 votes

# Answer
# Pyt, 9 bytes

```
π!⬡⁻⁻⁻△⁻⁻

```

Try it online!
> 1 votes

# Answer
# LibreLogo (Paper Format: Tabloid), 55 bytes

> The document must be in Tabloid Format for this method to work.

**Code:**

```
print ''.join(set(str(pagesize.pop()))).replace('.','')

```

**Result:**

**Explanation:**

```
pagesize                                           ; Returns [792.0, 1224.0] (Tabloid Format)
pagesize.pop()                                     ; Returns 1224.0
str(pagesize.pop())                                ; Returns "1224.0"
set(str(pagesize.pop()))                           ; Returns {u'2', u'0', u'1', u'.', u'4'}
''.join(set(str(pagesize.pop())))                  ; Returns "201.4"
''.join(set(str(pagesize.pop()))).replace('.','')  ; Returns "2014"

```
> 1 votes

# Answer
## Canvas, 7 bytes

```
ＡＡ＋ｑ⁷┤ｔ

```

Try it online!

```
ＡＡ       | Push 10 to stack twice
   ＋      | Add top two items in stack
    ｑ     | Print top item in stack on current line
      ⁷    | Push 16 to stack
       ┤   | Decrement top item in stack twice
        ｔ | Print top item in stack on current line, disable implicit output

```
> 1 votes

# Answer
# Perl 5 + Perligata, 25 bytes

Byte count uses the new rule that command-line switches for choosing appropriate modules don't count.

```
perl -MLingua::Romana::Perligata -e'MMXIVimum egresso scribe.'

```

Tested in Strawberry 5.26.0 with Perligata 0.601 (with `"` instead of `'` in the above code).
> 1 votes

# Answer
# T-SQL, 32 bytes

Based on the idea of Steve Matthews, but avoiding unprintable characters:

```
SELECT -~(ASCII('=')*ASCII('!'))

```

Alternative (but rather obvious) solution, 23 bytes:

```
PRINT UNICODE(N'ߞ')

```
> 1 votes

# Answer
# jshell, 5 bytes

How to make Java an useful code golf language? Simple, just remove the need to declare classes, methods, make things automatically print and so on.

```
+'ߞ'

```
> 1 votes

# Answer
# Stax, 4 bytes

```
ü◘♥┐

```

Run and debug (ha) it online!

Obligatory Stax answer. This unpacks to `2014`. Implicit print.

I haven't yet found a shorter version.
> 1 votes

# Answer
# C# (.NET Core), 42 bytes

```
System.Console.Write((int)'ϯ'+(int)'ϯ');

// Btw. it's now 2018 ^^ so
System.Console.Write((int)'ϱ' + (int)'ϱ');

```

Try it online!
> 1 votes

# Answer
# CJam, 2 bytes

```
KE

```

K is predefined as 20, E is predefined as 14. The stack gets automatically printed after the program.

Try it online!
> 1 votes

# Answer
**C#, 28 bytes**

You don't need to cast to an int as Hille does, so it becomes

`Console.WriteLine('ϱ'+'ϱ')`
> 1 votes

# Answer
# Symbolic Python, 31 bytes

```
_=-~-~-~(_==_)
_=`""`[_::_]

```

Try it online!

Symbolic Python bans numbers anyway.

### Explanation:

```
_=-~-~-~(_==_)   # Set _ to 4
_=               # Set _ to
  `""`         # From the representation of some unprintables
                    # Which is '\x12\x10\x11\x14'
           [_::_]   # From the 4th character, take every 4th character
                    # Output the contents of _ implicitly

```

A more interesting solution at 34 bytes:

```
_=-~(_==_)
_=`_`+`_-_`+`_/_`+`_*_`

```

Try it online!

```
_=-~(_==_)               # Set _ to 2
_=`_`+`_-_`+`_/_`+`_*_`
# '2'+'2-2'+'2/2'+'2*2' = '2'+'0'+'1'+'4' = '2014'

```
> 1 votes

# Answer
## , 9 chars

```
-Σ*{~~}82

```

Explanation (syntactically invalid)

```
-       2  Subtract the result by 2(2014)
 Σ         Summation of all ASCII codes in the string(2016)
  *    8   Duplicate the string 8 times
   {~~}    Define the string "~~"

```

There is no Try It Online for @.

If the current year is 2016, it would be perfect(7 chars):

```
Σ*{~~}8

```
> 1 votes

# Answer
# Javascript, 45 characters

```
_=> new Date().getFullYear()-new Date().getDate()

```

Very Temporary!!

Another Day, another very Temporary answer :-)

```
f=new Date().getFullYear()-new Date().getDay()

```
> 1 votes

# Answer
# \>\<\>, 7 bytes

```
aa+nen;

```

You can try it on The Online \>\<\> interpreter.

## Explanation

```
a        # push 10
 a       # push 10
  +      # push sum of top two values (10 + 10 = 20)
   n     # output top value as number
    e    # push 14
     n   # output top value as number
      ;  # halt program

```

This **doesn't** print the following:

```
20
14

```

because `n` outputs the top value as a number **without a newline**.

## Alternate Solution (9 bytes)

This one actually puts 2014 on the stack as a single number and outputs it.

```
cbde**+n;

```

I basically just tried random values for this one :P
> 1 votes

# Answer
# Triangular, 12 bytes

```
tE**%Cdd.`>/

```

Try it online!

Y'know, I was *just* about to post a 14-byte solution; luckily I went back to double-check and had a hunch.

**Ungolfed:**

```
    t
   E *
  * % C
 d d . `
> /

-- Actual Execution Order --

t*C`          The first multiplication does nothing.
              12 is pushed twice, then direction changes and both are multiplied to get 144.

E*d>/d%       Push 14, then multiply 14*144=2016. Decrement twice and print.

```

---

The 14-byte I was going to post:
```
t*CE.`*...>dd%

```
> 1 votes

# Answer
# Wren, 27 bytes

Just like most other answers, convert to code points and print. However this uses control characters in the source code.

```
System.printAll("".bytes)

```

Try it online!

## Explanation

```
                ""        // An unprintable chain containing 0x14 (20 in decimal) and 0x0e (14 in decimal)
                  .bytes  // Convert them to a list of their decimal codes [20, 14]
System.printAll(        ) // Print them all without a separator (2014)

```
> 1 votes

# Answer
# ABC, 11 bytes

```
aacncacaaac

```

## Explanation

`a` increments the accumulator, `c` outputs it and `n` sets it to 0.
> 1 votes

# Answer
## `j`, 4 bytes

```
ë‘"C

```

## Explanation

<pre><code>ë‘"  % Push a list
   C % Convert to list of ord codes [20,14]

flag:j % Join without a separator
```

> 1 votes

# Answer
# MathGolf, 2 bytes

```
ID

```

Try it online!

## Explanation

```
I   # push 20
 D  # push 14
    # implicit output

```
> 1 votes

# Answer
## Spice, 145 97 bytes

Improvement using multiplication to get the `9` from `2*2*2+1`, as we already had those values.

```
;t;z;o;n;i@LEN i z;ADD i i i;LEN i o;PUT i i i;LEN i t;MUL t t i;MUL t i i;ADD o i n;OUT t z o n;

```

## Un-golfed explanation

```
;t;z;o;n;i@ - Declare vars
LEN i z;    - Get the length of [], 0, and store in z
ADD i i i;  - Adding implicitly uses the first element, or 0 if there is none, so we insert 0 into i
LEN i o;    - Store length of [0], 1, in o
PUT i i i;  - Insert 0th element of i into i at position i[0] (we're increasing the array size)
LEN i t;    - Store length of [0, 0], 2, into t
MUL t t i;  - Multiply t, 2, by itself and store in i
MUL t i i;  - Multiply t, 2, by i, 4, and store in i
ADD o i n;  - Add o, 1, to i, 8 and store in n
OUT t z o n;- Write to console - "[2] [0] [1] [9]"

```

## Original

```
;t;z;o;n;i@LEN i z;ADD i i i;LEN i o;PUT i i i;LEN i t;PUT i i i;PUT i i i;PUT i i i;PUT i i i;PUT i i i;PUT i i i;PUT i i i;LEN i n;OUT t z o n;

```

## Un-golfed explanation

In Spice, all variables are double arrays. Importantly, variables that have no assigned value are either treated as an empty list `[]` or `0` depending on the operation. The built-in `LEN` will give the length of an array and we can therefore produce numbers:

```
;t;z;o;n;i@ - Declare vars
LEN i z;    - Get the length of [], 0, and store in z
ADD i i i;  - Adding implicitly uses the first element, or 0 if there is none, so we insert 0 into i
LEN i o;    - Store length of [0], 1, in o
PUT i i i;  - Insert 0th element of i into i at position i[0] (we're increasing the array size)
LEN i t;    - Store length of [0, 0], 2, into t
PUT i i i;  - Now repeat until there are 9 elements...
PUT i i i;
PUT i i i;
PUT i i i;
PUT i i i;
PUT i i i;
PUT i i i;
LEN i n;     - ... and store in n
OUT t z o n; - Write to console - "[2] [0] [1] [9]"

```

For the original 2014 version, you save bytes for less `PUT`s - 95 bytes. So this solution will improve next year!
> 1 votes

# Answer
# FEU, 69 bytes

```
a/abcdeghij
m/a/bb/b/cc/c/dd/d/ee/e/ff/f/gg/g/hh/h/ii/i/jj/j/kk/g
U/k

```

Try it online!
> 1 votes

# Answer
# Excel, 12

```
=UNICODE("ߞ

```

Second best I could do was `=ARABIC("MMXIV` at 14 bytes.
> 1 votes

# Answer
# MAWP, ~~30~~ 28 bytes

```
!!+!!!!++!*+/!+!!+!+!!++++*:

```

Try it!

~~This will be fun to golf.~~

This is longer than @Lyxal 's answer, but outputs only one time as one number.
> 1 votes

# Answer
# Vyxal, ~~10~~ 3 bytes

```
»÷∩

```

Try it Online!

Simply the compressed number `2014`
> 1 votes

# Answer
# Poetic, 112 bytes

```
two`s a bad thing
using a two?o,hardly!i am using a poem
a numeric poem?oh,clearly,but a limited one for certain

```

Try it online!
> 1 votes

# Answer
# DROL, 13 bytes

`ziill<ukl<dfo`

I wanted to add a language that wasn't already included...

DROL is a limited instruction assembler-like language with only two registers as storage. The language does include numbers, so it think it qualifies for this question. But numbers are only used for loop length indicators, as well as being used as the name of some instructions. It's described on the Esolang Wiki DROL page.

Here's a rundown of what the code does:

```
z              set R1=0
 ii            increment R1 by 1 twice   (2)
   ll          square R1 three two      (16)
     <         shift left R1            (32)
      u        set R2=R1                (32)
       k       increment R2             (33)
        l      square R1              (1024)
         <     shift left R1          (2048)
          d    decrement R1           (2047)
           f   subtract R1 = R1 - R2  (2014)
            o  print R1 as an integer

```
> 1 votes

# Answer
# Kotlin, 42 bytes

```
fun main()=print("ް.".map{it.code}.sum())

```

I used U+1968 which is ް and a . which is U+46.
> 1 votes

# Answer
# Phooey, 16 bytes

```
=@+$i>$i=$i<@+$i

```

Try it online!

```
                 # Stk  Tape
=@+$i>$i=$i<@+$i # (0) >0  0   (initial state)
=                # (0) >1  0   tape = stack == tape to get 1
 @               #  1  >1  0   push to stack
  +              # (0) >2  0   pop; add stack to tape
   $i            # (0) >2  0   print tape as integer (2)
     >$i         # (0)  2 >0   move tape ptr right, print (0)
        =$i      # (0)  2 >1   same as above to get 1 again, print (1)
           <@    #  2  >2  1   move back, push
             +$i # (0) >4  1   add stack to tape, print (4)

```

Thank goodness for Phooey's `=` operator. This would be impossible in Foo.

---

# Phooey, ~~23~~ 19 bytes

This version actually generates the *number* 2014 instead of printing 2,0,1, and 4.

```
=@+@@@+@**@@*@+--$i

```

Try it online!

```
                    # stack       | tape
=@+@@@+@**@@*@+--$i #         (0) |    0  initial state
=                   #         (0) |    1  tape = tape == pop() (to get 1)
 @+                 #         (0) |    2  double by adding to self
   @@               #    2     2  |    2  push two copies to the stack
     @+             #    2     2  |    4  double
       @*           #    2     2  |   16  square by multiplying by self
         *          #          2  |   32  multiply by 2
          @         #    2    32  |   32  push 32 for later
           @*       #    2    32  | 1024  square
             @+     #    2    32  | 2048  double
               -    #          2  | 2016  pop and subtract
                -   #         (0) | 2014  pop and subtract
                 $i #         (0) | 2014  print 2014

```
> 1 votes

# Answer
# ARM assembly, ~~94~~ 85 bytes (28 bytes compiled)

Textual assembly for ARM mode.

```
s:subs sb,sb
adc sb,sb
add sb,sb
lsl sl,sb,sb
add sb,sl,lsl sb
rsb sb,sl,lsl sl
bx lr

```

A function which returns `2014` in `sb` (`r9`)

Clobbers `sl` (`r10`) and `sb` (`r9`).

Expanded version:

```
        // It feels so empty here...
        .globl s
s:
        // use the quirky way subs affects the flags
        // to set r9 to 1
        subs    r9, r9, r9
        adc     r9, r9, r9
        // double r9 by adding it to itself
        // lsl works just as well
        // r9 = 2
        add     r9, r9, r9
        // r10 = r9 << r9
        // r10 = 2 << 2
        // r10 = 8
        lsl     r10, r9, r9
        // r9 = r9 + (r10 << r9)
        // r9 = 2 + (8 << 2)
        // r9 = 2 + 32
        // r9 = 34
        add     r9, r9, r10, lsl r9
        // r9 = (r10 << r10) - r9
        // r9 = (8 << 8) - 34
        // r9 = 2048 - 34
        // r9 = 2014
        rsb     r9, r9, r10, lsl r10
        // Return
        bx      lr

```

This uses the same idea as my Phooey answer, of generating 2048, then subtracting 34. While I *do* have access to `push` and `pop`, ARM isn't a stack machine. It is a *register* machine. Additionally, we have `lsl` for shifting left which makes a few cases easier.

It is yet another rare case where the inverted carry flag on ARM is useful for something other than 64-bit subtraction, as it allows us to set a register to 1 when combined with `adc`.

Additionally, this **only** works in ARM mode: Thumb-2 did not show the return of shifting by register (which kinda was a dumb waste of encoding bits)

It uses the classic register names instead of the format which is `r[0-15]`.
> 1 votes

# Answer
# Python 3, 16 bytes

```
print(ord('ߞ'))

```

Try it online!
> 1 votes

# Answer
# Grok, 13 bytes

```
iNH`I:P-zP-zq

```

### Alternate 13 Byte solution:

```
i:H:N`-Yx-zZq

```
> 1 votes

# Answer
# Branch, 11 bytes

```
}}#/#}#^}}#

```

Try it on the online Branch interpreter!

Branch does have numbers in it. `}` is increment and `{` is decrement. `#` outputs as number. `/` goes to the left child, which is automatically initialized to `0`, which is shorter than `{{`. Finally, `^` goes to the parent, which is `2` when that command is called. Actually, since the current node is `1`, and the parent is `2`, we could do `^}}` or `}}}` to get `4`.

An alternative solution that produces 2014 on the tree itself instead of outputting it character by character:

# Branch, 50 bytes

```
}}^\}}}}}^*^\}}^*{^\}}^*^\/}}}}}}^\}}}}}}}}}^*{^*#

```

Try it on the online Branch interpreter!
> 1 votes

# Answer
# Deadfish~, 12 bytes

```
iioddoioiiio

```

Try it online!

This, this is surprisingly short!
> 1 votes

# Answer
# Python 3 (15 Bytes)

```
print(ord('ߞ'))

```

# Python 3 (24 Bytes)

```
print(ord('޴')+ord('*'))

```

## JavaScript (28 Bytes)

```
-~!+[]+[+[]]+-~[]+-~!''-~!''

```
> 1 votes

# Answer
# PICO-8, 24 18 bytes

```
?ord("⁙")*ord("j")

```

`ord()` gets the numerical index of a character; in P8SCII,  is at index 19 and `j` is at index 106, creating the equation \\$19\*106=2014\\$.
> 1 votes

# Answer
# C++ (gcc), 33 bytes

```
main(){std::cout<<('j'-'W')*'j';}

```

Try it online!
> 1 votes

# Answer
## Pascal, 76 B

See also Delphi.
This `program` requires a processor supporting ISO standard 10206 “Extended Pascal”, specifically `const`ant definitions may be expressions (`ord(true)` is an expression).

```
program p(output);const I=ord(true);begin write(I+I,I-I:i,I:i,I+I+I+I:i)end.

```

If `ord(maxChar)` ≥ `2014` we can use just *one character* in the **43 character** `program`

```
program q(output);begin write(ord('X'))end.

```

where `X` needs to be substituted by the implementation-defined `char` value having the ordinal value `2014`.

---

*For reference*, an Extended Pascal `program` printing the *current* year looks like this:

```
program t(output); var t: timeStamp; begin getTimeStamp(t); writeLn(t.year) end.

```
> 1 votes

# Answer
# Go, 56 bytes

```
func f(){for _,c:=range`-+,/`{print(string(c+'F'-'A'))}}

```

Attempt This Online!

Alternative to that other Go answer. Prints to STDERR.
> 1 votes

# Answer
# tinylisp 2, 5 bytes

```
(h"ߞ

```

Try it at Replit!

### Explanation

The same character-code solution as everybody else. `h` is short for `head`, which, when given a string, returns the character code of its first character. The string quote and the function-call parenthesis both auto-close at the end of the line/program.

## Non-string solution, 43 bytes

```
(d T(+(*)(*
(d X(* T T T T T
(-(* X X T)X T

```

Here, we take advantage of the fact that tinylisp 2's multiplication builtin `*` is variadic: it can take any number of arguments, including zero. Without arguments, its return value is the product of an empty list, or \\$1\\$.

```
(d T(+(*)(*)))

```

Define `T` as the sum of \\$1\\$ and \\$1\\$, or \\$2\\$.

```
(d X(* T T T T T

```

Define `X` as the product of five \\$2\\$s, or \\$32\\$.

```
(-(* X X T)X T

```

Output the product of \\$32\\$ and \\$32\\$ and \\$2\\$, minus \\$32\\$, minus \\$2\\$ (the `-` builtin is also variadic): \\$(32 \cdot 32 \cdot 2) - 32 - 2 = 2014\\$.
> 1 votes

# Answer
# Logically, 68 bytes.

```
@w:a,b,c;WRITE(h,a,b,c,l,h,h,l,l)()
@M w(l,h)()w()()w(h)()w(l,l,h)()

```

Consists of two gate definitions. `w` writes the 3 passed bits in the form of `00110cba`, and then `M` has 4 `w` gates for each of the digits.

Whilst logically *can* use numbers for both argument unrolling and high-low states, it can be avoided pretty easily.
> 1 votes

# Answer
# Thunno 2, 3 bytes

```
«¬ẓ

```

Attempt This Online! Simple compressed integer.

## Thunno 2, 4 bytes (UTF-8)

```
'ߞC

```

Attempt This Online! Charcode.

## Thunno, 4 bytes (UTF-8)

```
'ߞO

```

Attempt This Online! Basically the same so I won't create another answer for it.
> 1 votes

# Answer
# !+~%, 8 bytes

```
++!+~%+!

```

Stumbled over this challenge and sorry, could not resist. I promise this will not happen again. (-;

An explanation, to make this look serious:

* `++` twice adds 7 to the initial 6, so we end up at 20, that gets printe by `!`
* to the accumulator resetted to 6, `+` adds 7, and the `~` reverses the result from 13 to 31
* `%` does a modulo from the number with a leading 1, so 131 mod 31 happens to be 7.
* the `+` adds another 7, and `!` prints the 14 behind the 20.
> 1 votes

# Answer
# morsecco: 24 bytes

Now a more serious answer:

```
. -----.----. -.- -. ---

```

Morsecco codes numbers as binaries with dots and dashes (you could also write it as morse code, but each digit takes 6 bytes, resulting in a much longer code), so `. -----.----.` `E`nters 2014 on the stack, `-.- -.` `K`onverts this to a decimal `Number` which gets `Output` by `---`.
> 1 votes

# Answer
# Vyxal 3, 3 bytes

```
~¥ᴴ

```

Try it Online!

because of how the encoding works, vyxal 3 takes 4 bytes to use a base 252 encoding, but you can shave a byte because 2014 is only 2 bytes in base 255 and thus you can use the ~ element which converts 2 elements on the codepage to base 255
> 1 votes

# Answer
**Objective C**

```
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:@"yyyy"];
NSLog(@"%@",[formatter stringFromDate:[NSDate date]]);

```
> 0 votes

# Answer
You never said we couldn't put it on an external page!

## Javascript - 19 Chars

```
location='//x.vu/u'

```

PS. It took 2 tries to get a shortened URL without numbers :P
> 0 votes

# Answer
## C, 29 bytes (Emacs) / 40 bytes (VI)

Before creating program, execute the shell command

```
stty -ixon      ### 11 bytes, with the newline

```

N.B this is required for most terminal editors, but is not required for emacs

then write this code:

```
main(){printf("%d",'j'*'^S');}

```

N.B. '^S' is a single XOFF character e.g. in VI use control-V, control-S; in emacs use control-Q, control-S; emacs turns off flow control by default.

I assume the comment \[You can't type ^S in a Linux terminal\] below left off an implied \[without the stty command or equivalent e.g. emacs default behavior upon startup\], otherwise that comment is inaccurate.

And here is the requested hexdump:

```
$ od -a -t x1 x.c
0000000   m   a   i   n   (   )   {   p   r   i   n   t   f   (   "   %
         6d  61  69  6e  28  29  7b  70  72  69  6e  74  66  28  22  25
0000020   d   "   ,   '   j   '   *   ' dc3   '   )   ;   }  nl
         64  22  2c  27  6a  27  2a  27  13  27  29  3b  7d  0a

```
> 0 votes

# Answer
## GTB, 38

```
π/π→A:A++B:A+A→C:C*C→D~B*C*C+B*C-C-A-A

```

Compile assuming `:` at front
> 0 votes

# Answer
### C# (56 characters)

```
Class P{static void Main(){Console.Write(','*','+'N');}}

```
> 0 votes

# Answer
# Perl, 24 bytes

```
print-ord(A)+ord for U,O

```

Pure ascii, no nonprinting characters or utf8-only characters used. Uses the 21st and 15th letters of the alphabet to print 20, 14.
> 0 votes

# Answer
BAT (windows batch), 7 characters

```
echo %*

```

save as `a.bat` and invoke as `a 2014`

> is there any restriction on using command line parameters? – Einacio
>
> I don't think so, but `echo $1` still has a number in it. – Joe Z.

not a so valid answer, but noone was posting an answer in this wonderful language
> 0 votes

# Answer
# k 11 & 17 chars

this 11-char one is from a colleague

```
@:[:']*.(.)

```

this 17-char one is the best i could come up with on my own; it's a variant on ASCII abuse:

```
.,/$-/"i"$$`zz`fl

```

and just for interest, here are a few others of mine:

."c"$"RPQT"-"e"$" " / ascii (only 2.x)
."c"$-/"e"$("RPQT";" ") / ascii (all versions)

-_-(s*(exp acos@-`=`)xexp x)-(s xexp s:x*x)%x:+/``=`` / port of David Carraher's solution above

.,/$#:'(``;();`;````) / another approach
</code></pre>
> 0 votes

# Answer
**PHP (27) - not shortest ASCII PHP but more readable**

```
<?=hexdec($e=hexdec(E)).$e;

```
> 0 votes

# Answer
# Bash, 15 bytes

```
echo "^T "|od -x

```

(**`^T`** is one character.)
> 0 votes

# Answer
# Bat (Windows batch), 13 bytes (characters)

```
echo.^T |od -x

```

(**`^T`** is one character.)
> 0 votes

# Answer
# PYTHON

```
print(str(len('Happy new year to me')) + str(len('Happy new year')))

```
> 0 votes

# Answer
**PHP, 22 bytes**

```
echo ord('').ord('')

```

**Edit**

SE is stripping the characters. Working version here: http://codepad.org/unzjXNY2.
> 0 votes

# Answer
## Delphi (26bytes & 26 chars)

```
ord('-')*ord('/')-ord('e')

```

> Ascii values
> \- : 45
> / : 47
> e : 101
> 45\*47 = 2115 - 101 = 2014
> 0 votes

# Answer
## e-TeX, 21 bytes

```
\the\numexpr`*`j\bye
```

It contains an invisible control character with code 19 (0x13) before the asterisk. A version with printable ASCII characters needs two more bytes:

```
\the\numexpr`^^S*`j\bye

```

In TeX ``` takes the character code of the next token:

* `[0x13]` (`^^S`): 19
* `j`: 106

`\numexpr` calculates: 19 * 106 = 2014

The result is a DVI file with "2014" on the first page.

**Variant with 2014 as page number:**

```
\pageno\numexpr`^^S*`j~\bye

```

(25 bytes, if `^^S` is replaced by the byte with character code 19).
> 0 votes

# Answer
# Java without the weird unicode charas @ 115

```
enum A{A;public static void main(String[]z){int a=A.ordinal(),b=a++;System.out.print(""+(a<<a)+b+a+(a<<(a<<a)));}}

```

enumerators are pretty handy :)
> 0 votes

# Answer
## Python, 8 characters

```
ord('ߞ')

```

I think this ought to be valid :P

Ok, if you want me to use print(),

### 15 characters

```
print(ord('ߞ'))

```
> 0 votes

# Answer
# Microscript, 10 bytes

Noncompeting, language postdates the question..

```
'js'(s';-*

```

Explanation: 106\*(59-40), using the language's equivalent of character literals. I'd do 53\*38, but the character corresponding to 53... is the digit 5. And the character corresponding to 19 is, of course, nonprintable, so that wouldn't work.
> 0 votes

# Answer
# Cardinal, 14 chars

```
%n=*+.-d++.
 d

```

The pointer starts at %, reads in the character ‘d’(ASCII 100), creates a duplicate as inactive value (the bottom of the stack), adds active and inactive values, resulting in 200, adds 1, prints out the result `201`, subtracts one, divides by inactive value (100), resulting in 2, adds two, prints out `4`. Cardinal pointer stacks can only carry values up to 255 (OEM 437 range), everything above leads to a wrap-around.

```
0             100             100             200             201
0               0             100             100             100
>n=*+.-d++.    %>=*+.-d++.    %n>*+.-d++.    %n=>+.-d++.    %n=*>.-d++.
 d              d              d              d              d
———————————————————————————————————————————————————————————————————————
   201             200               2               3               4
   100             100             100             100             100
%n=*+>-d++.    %n=*+.>d++.    %n=*+.->++.    %n=*+.-d>+.    %n=*+.-d+>.

print:"201"
———————————————————————————————————————————————————————————————————————
          4
        100
%n=*+.-d++>

  print:"4"

```

Result:

```
Executing program..

2014

Execution complete.

```
> 0 votes

# Answer
# C, 24 / 68

```
main(){printf("MMXIV");}

```

Haha, Roman Numerals For The Win!

---

Or, for real:

```
main(){printf("%i%i%i%i",strlen("aa"),nil,strlen("a"),sizeof(int));}

```
> 0 votes

# Answer
# q, ~~20~~ 17 bytes

```
{x+y*z}."j"$"$+."

```
> 0 votes

# Answer
# TeaScript, 7 bytes

```
'ߞ'c()

```

Takes the char code of the character with a char code of 2014
> 0 votes

# Answer
# Groovy, 48 bytes

For 2015 change cabe to cabf...

```
n={it.each{print(((int)it)-(int)'a')}}
n('cabe')

```
> 0 votes

# Answer
# JavaScript, 17 Bytes

```
atob("MjAxNA==")

```
> 0 votes

# Answer
# C (gcc 5.3.1), 49 bytes

Pure arithmetic! \o/

```
main(a){printf("%d",(++a<<(a<<a|a))-(a<<a+a)-a);}

```

Undefined behaviours.

Specifically, use this compiler (languages are defined by implementation).

### Without undefined behaviour (which would work on all compilers), 51 bytes

```
main(a){a++;printf("%d",(a<<(a<<a|a))-(a<<a+a)-a);}

```

### Explanation

Basically `2048 - 32 - 2`, constructed using powers of 2.
> 0 votes

# Answer
# Swift 2.2, 28 bytes

```
print("\(ENOTDIR)\(EFAULT)")

```

Falling back on Darwin/glibc error codes from `errno.h`.
> 0 votes

# Answer
# Mathematica, 16 bytes

```
FromDigits@"JAE"

```
> 0 votes

# Answer
## QBIC, 10 bytes - Not Competing

```
?z^s*r+z+t

```

Calculates 2014 from the pre-initialised variables q-z (1-10) and prints it. Development of QBIC started some two years after 2014...

Alternative 12-byte version:

```
?(u*y)^r-z-q

```
> 0 votes

# Answer
# Pushy, 6 bytes

```
`��`j#

```

Contains control characters, so here's a hexdump:

```
0000-0006:  60 14 0e 60 6a 23

```

The first unprintable is the literal `DC4` byte (`\x14`), and the second is `SHIFT-OUT` (`\x0e`).

First these bytes are pushed as charcodes, so the stack is `[20, 14]`. The `j` operator concatenates these and `#` outputs the result: "2014".

---

**10-byte solution:**

```
`<:;>`KT-"

```

Uses char-code manipulation and the builtin `T` (10).

```
`<:;>`       Push string as char-codes: [60, 58, 59, 62]
     KT-     Take 10 from each: [50, 48, 49, 52]
        "    Interpret as char-codes and print: results in "2014"

```
> 0 votes

# Answer
## Pyke, 3 bytes, noncompetitive

Try it here!

Where `߾` is `0xDFBE`

Loads `ord(0xDFBD-0x20)` as an integer and implicit prints it
> 0 votes

# Answer
# tcl, 16

```
puts [scan ߞ %c]

```

Can be seen on: http://rextester.com/live/SVXB29034
> 0 votes

# Answer
## Groovy, casting to int, 8 bytes

```
(int)'ߞ'

```
> 0 votes

# Answer
# C, 25 bytes

```
f(){printf("%d",L'ߞ');}

```

24 characters, but one character is UTF-8 encoded. Still the shortest C answer! How it works:

```
U+07DE ߞ NKO LETTER KA

```

`7DE` in decimal is 2014.
> 0 votes

# Answer
# Python 3, 16 Bytes :

```
print(ord('ߞ'))

```

# 2017 version, 16 Bytes :

```
print(ord('ߡ'))

```
> 0 votes

# Answer
## Whitespace, 19 bytes

Visible representation:

```
SSSTTTTTSTTTTSNTNST

```

Just pushes 2014 onto the stack and prints it. Whitespace's lack of any visible characters makes this pretty easy.

Valid as numbers are completely valid tokens in whitespace, they just don't do anything.
> 0 votes

# Answer
# Common Lisp, 15 characters

```
(char-code #\ߞ)

```

Try it online!
> 0 votes

# Answer
# Ruby (8 bytes, 7 chars)

```
'ߞ'.ord

```

The question mark is ߞ represented in two bytes UTF8.

---
> 0 votes

# Answer
# Clojure - 35 characters ASCII only

```
(print(-(*(int\#)(int\<))(int\V)))

```

Based on True Soft's answer
> 0 votes

# Answer
# Aceto, 10 bytes

```
IIppIpPiIp

```

Try it online!

Uses int(Pi) to it's advantage

# 11 bytes (previous answer)

```
IIppIpIIIIp

```

Try it online!

Simply increments from zero 2, 0, 1, and 4 times, then prints each time

# Fun Version

```
Piddd++DsJiPidIIJi*p

```

Try it online!

Uses int(Pi) to base equations off of

# Lame Version

```
'ߞop

```

Try it online!

Converts the codepoint to number, which is 2014
> 0 votes

# Answer
# Implicit, 3 bytes

Try it online!

```
     implicit push command
`    character
 ߞ   U+07DE (2014 in decimal)
     implicit integer output

```
> 0 votes

# Answer
# Triangularity, 18 bytes

```
.. ..
."ߞ".
o

```

Try it online!
> 0 votes

# Answer
# Pyt, 16 bytes

```
áŁ!⁺²Đ⁺⁺!₀⁻⁻⇹ᴇ+₅

```

Explanation:

```
á                               Push stack into list (pushes empty list)
 Ł                              Get length of top of stack (0)
  !                             0!=1
   ⁺²                           (1+1)^2=4
     Đ                          Duplicate top of stack
      ⁺⁺!                       (4+2)!=720
         ₀⁻⁻                    720/10-2=70
            ⇹                   Swap top two items on stack (4 is on top)
             ᴇ                  10^4=10000
              +₅                (10000+70)/5=2014

```

Try it online!
> 0 votes

# Answer
# Brainf\*ck

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

```

More readable version:

```
> Move pointer pos over
++++++++++ Add 10
[ Start loop
<+++++>- Add 5, move over & subtract 1
] End loop
<.--.+.+++. Do some other stuff

```

Yes, I know this is an old post, but I'm really bored and want to get enough rep to comment because I don't have access to my other account.
> 0 votes

# Answer
# Brainfuck, 23 Bytes

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

```

Try it online!
> 0 votes

# Answer
# SNOBOL4 (CSNOBOL4), 42 bytes

```
	&UCASE 'N' @X ARB 'T' @Y
	OUTPUT =Y X
END

```

Try it online!

`@` assigns the index of the match and  (space) concatenates them.

I know, it's 2018, so I should go home...
> 0 votes

# Answer
# Python 3, 16 bytes

```
lambda:ord('ߞ')

```

Try it online!
> 0 votes

# Answer
# Objective-C, 27

```
NSLog(@"%i",'&'*('V'-'!'));

```
> 0 votes

# Answer
# x86, 15 bytes

No numbers in the source code. Returns in `eax`. Uses (252\*4 - 1) * 2.

```
   0:   31 c0                   xor    %eax,%eax
   2:   fe c8                   dec    %al
   4:   48                      dec    %eax
   5:   48                      dec    %eax
   6:   48                      dec    %eax
   7:   d1 e0                   shl    %eax
   9:   d1 e0                   shl    %eax
   b:   48                      dec    %eax
   c:   d1 e0                   shl    %eax
   e:   c3                      ret

```

If we permit numbers in the source but not binary, we have `mov $2014,%ax`/`ret` for 5 bytes.
> 0 votes

# Answer
# Ahead, 5 bytes

ezpz

```
'ߞO@

' push next cell to stack
ߞ U+7DE (2014 decimal)
O output as number
@ die

```

Try it online!
> 0 votes

# Answer
# Z80Golf, 10 bytes

```
00000000: 080a 0b0e 767e 23e5 ee3a                 ....v~#..:

```

Try it online!

### Disassembly

```
start:
  ex af,af'  ; db $3a ^ '2' ($08)
  ld a,(bc)  ; db $3a ^ '0' ($0a)
  dec bc     ; db $3a ^ '1' ($0b)
  ld c,$76   ; db $3a ^ '4' ($0e)
             ; halt         ($76)
  ld a,(hl)
  inc hl
  push hl
  xor $3a

```

Essentially the Hello World trick in Z80Golf.

In short, `hl` serves two purposes: data address for `a` and return address for `putchar` (which is at `$8000` and accessed by going all the way through zeroed memory, instead of `call $8000`).

The instructions in the data section have to be effective no-ops (not touching `hl` and `sp` should suffice), and the last one should be 2-byte in order to shadow `$76` (`halt`). I carefully selected the xor value so that the resulting binary has no digits (`$30` to `$39`).

# Z80Golf, 10 bytes, 2018 edition

```
00000000: 1416 171e 767e 23e5 ee26                 ....v~#..&

```

Try it online!

### Disassembly

```
start:
  inc d      ; db $26 ^ '2' ($14)
  ld d,$17   ; db $26 ^ '0' ($16)
             ; db $26 ^ '1' ($17) ; rla
  ld e,$76   ; db $26 ^ '8' ($1e)
             ; halt         ($76)
  ld a,(hl)
  inc hl
  push hl
  xor $26

```

Same principle, but this time we can't use `ld c,$76` since it gives `$36` for the xor value. So I moved to `e` which starts with `1e`. Also, different starting address gives two different interpretations of the data section:

* `$16 $17`: `ld d,$17`
* `$17`: `rla` (Rotate the register A to the left)

So I had to check both are effective no-ops in this program.
> 0 votes

# Answer
# Lua 5.3.1, 31 bytes

It's an old question, but I may as well join in on the fun!

For those not familiar with Lua, the `#` operator returns the length of an array or string, and the `..` operator is for string and number concatenation. The `//` operator is integer divide, and is used so that there is no trailing decimal in the numbers caused by Lua treating the result of regular divisions as a float.

2014 in 31 bytes: `t=#"aa"print(t..t-t..t//t..t*t)` = `print(2..2-2..2/2..2*2)`

2015 in 36 bytes: `t=#"aa"print(t..t-t..t//t..t*t+t//t)` = `print(2..2-2..2//2..2*2+2/2)`

2016 in 33 bytes: `t=#"aa"print(t..t-t..t//t..t*t+t)` = `print(2..2-2..2//2..2*2+2)`

2017 in 38 bytes: `t=#"aa"print(t..t-t..t//t..t*t+t+t//t)` = `print(2..2-2..2//2..2*2+2+2/2)`

2018 in 33 bytes: `t=#"aa"print(t..t-t..t//t..t*t*t)` = `print(2..2-2..2//2..2*2*2)`

The solutions for other years are pretty similar. Here's a function that can do any number:

```
function f(y)
    t=#"a"
    s=""
    for i=t, #(y.."") do
        n=t-t
        for j=t,(y..""):sub(i,i) do
            n=n+t
        end
        s=s..n
    end
    return s
end

```

And here's the golfed version of the function at 108 bytes:

`function f(y)t=#"a"s=""for i=t,#(y.."")do n=t-t for j=t,(y..""):sub(i,i)do n=n+t end s=s..n end return s end`
> 0 votes

# Answer
# ;# - 203

```
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

```
> 0 votes

# Answer
# K (ngn/k), 10 bytes

```
"&"*-/"U "

```

Try it online!

---

and 2018 just because this is so late

# K (ngn/k), 11 bytes

```
-"^"-*/"@!"

```

Try it online!

---

EDIT: I'm unsure when this language was created, it's a variant of k which has existed for a long time, but the gitlab link seems to indicate that it may be only a year or so old (judging by commit info), so this answer may be invalid as a result
> 0 votes

# Answer
# Aheui (esotope), 8 chars (24 bytes)

```
반밝따바뱟해망어

```

Try it online!

---

It's too easy for Aheui since it never use any kind of digits at all.

### Explanation:

```
# An Aheui code starts with default stack "아".
반: push 2, move cursor right by 1(→).
밝: push 7, →
따: mul(push 14), →
바: push 0, →
뱟: push 2, move cursor right by 2(→→).
해: end.
망: print as integer, →
어: move cursor left by 1(←).

```

Note: Print instruction moves cursor in reverse direction if current storage is empty.
> 0 votes

# Answer
# TI-BASIC, 7 bytes

```
int(₁₀^(³√(tan(cosh(cos(π

```

A significant improvement from the previously winning 12-byte TI-BASIC answer. Using one-byte functions allows the greatest number of chances to achieve a certain value within a given byte count.
> 0 votes

# Answer
# HaykamScript, 11 bytes

```
s[⛉,☄]i

```

## Explanation

```
s       - string
  [     - executed parameters
    ⛉   - constant for 201
    ,
    ☄   - constant for 4
  ]
i       - convert to integer

```

## Other Years

It's pretty simple to make any other year with the same amount of bytes, Unicode codepoints `0x2600` to `0x26FF` represent integers `0` to `255` in my language.

For example, to make the year this was posted:

```
s[⛉,☈]i

```
> 0 votes

# Answer
# Forth, 29 bytes

```
hex fbc 'B' '!' / / decimal .

```

Try it online!
> 0 votes

# Answer
\*nix shell (POSIX/bourne) 41 bytes

`a=.. c=. d=....;echo ${#a}${#b}${#c}${#d}`

### Other solutions

`printf %x \'— #` 13 characters Try it online!
`echo $[x=++y+y]$?$y$[x+x] #` 25 characters Try it online!
> 0 votes

# Answer
# C# .NET 75 bytes

```
public class p{public static void Main(){System.Console.Write((int)'ߞ');}}

```

Just displaying the integer value of the unicode character ߞ
Try online (also has 2015-2019)
> 0 votes

# Answer
# k4, 20 bytes

```
*/(-)."j"$("Ud";"/")

```

---

```
      "j"$("Ud";"/") / convert "Ud" and "/" to underlying integer representation -> (85 100;47)
  (-).               / subtract 47 from 85 and 100 -> 38 53
*/                   / multiply over

```
> 0 votes

# Answer
# MAWP 2.1, 15 bytes

```
!+!:!!-:!!$:!+:

```

Try it online lol.
> 0 votes

# Answer
# Neim,  ~~4~~  2 bytes

```
χρ

```

Try it online!

Push 20, push 14 and print the entire stack
> 0 votes

# Answer
# BRASCA, 4 bytes

```
'ߞn

```

Try it online!

### Explanation

```
'ߞ   - Push the character ߞ (Codepoint 2014)
  n  - Print as number

```

## Alternative solution, 9 bytes

```
ll+'.E-Sn

```

Try it online!

### Explanation

```
ll+         - 10+10 = 20
   '.E-     - code point 46-32  = 14
       S    - Concatenate 20 and 14
        n   - Print as number

```
> 0 votes

# Answer
# Desmoslang Assembly, 15 Bytes

`PDPP+PDDP+P+POT`
> 0 votes

# Answer
# Swift, 92 bytes (for 2014)

```
func f(){print("..::.:....".components(separatedBy:":").map({x in "\(x.count)"}).joined())}

```

Count the number of items in the substrings between the colons, convert to strings and join them.
> 0 votes

# Answer
# Commodore BASIC V2, tested on the Commodore C64, 37 PETSCII characters. Non-competing

Note that the `{CRSR LEFT}` in the following "source code" is the cursor left control character.

```
A=.↑.:A%=π+A:?A♥("╮")"{CRSR LEFT}"R╮(ST▂(A%),A)

```

Non-obfuscated, this would look like this:

```
A=.↑.:A%=π+A:PRINTASC("╮")"{CRSR LEFT}"RIGHT$(STR$(A%),A)

```

or on a Commodore C64 screen, it would look like this:
> 0 votes

# Answer
# Rattle, ~~12~~11 bytes

```
d|n*+b=+**b

```

Try it Online!

# Explanation

```
d|            take "d" as input
  n           get the ASCII int value of 'd' (100)
   *          multiply (by 2 without an argument) to get 200
    +         increment by 1 to get 201
     b        add "201" to print buffer
      =+**    reset, increment, multiply by 2, multiply by 2 to get 4
          b   add "4" to print buffer, output implicitly resulting in "2014"

```
> 0 votes

# Answer
## awk

```
mawk 'BEGIN { print (_+=++_)!_!!_ _^_ }'

```

---

```
2014

```
> -1 votes

---
Tags: restricted-source, code-golf
---