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

• Even though numbers are ignored in brainfuck, I thought I'd post one anyway. 32 Chars: ++++++[>++++++++<-]>++.--.+.+++. Commented Apr 1, 2015 at 21:37
• Brainfuck isn't a valid language for this challenge. Commented Apr 1, 2015 at 22:49
• I know. That's why I posted it as a comment Commented Apr 1, 2015 at 22:51
• I wonder if this question gets a small spike in popularity around New Year's. Commented Dec 26, 2015 at 23:28
• Waiting for "Come on folks, don't you realize it's 2016?" :) Commented Jan 4, 2016 at 23:35

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

• Normally we put the code first and the explanation afterwards Commented Jan 3, 2023 at 14:32
• You could save a byte by switching to Python 2: print int("BBC",ord("\r")) Commented Jan 3, 2023 at 14:35
• I already pointed out that. Commented Jan 3, 2023 at 14:57

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

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

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

• What’s non-competing about this? Looks fine to me Commented Jan 12 at 19:02
• So upvote it then? idk... Commented Mar 14 at 15:01
• I didn’t upvote because I was (and still am) confused what you meant by non-competing, if that means the answer is invalid then why should I upvote it Commented Mar 14 at 15:53
• It is not invalid, it is non-competing or just for fun/just for a laugh. Commented Mar 14 at 16:15
• I guess I don’t get the joke Commented Mar 14 at 20:25

# PHP (21 chars)

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

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

• That looks like 19 characters to me. Commented Jan 2, 2014 at 15:06
• (Oh wait, nonprintables.) Commented Jan 2, 2014 at 15:07
• If it contains non-printables, you should provide a hex dump or list them. Commented Mar 4, 2016 at 20:06

# Python 51

Using true = 1 and false = 0

t=True
print str(t+t)+str(t-t)+str(+t)+str(t+t+t+t)
• clever. 40 chars in PHP: $t=true;echo$t+$t.$t-$t.$t.$t+$t+$t+$t; Commented Jan 5, 2014 at 10:08
• Damn just wrote that while reading the answers well done, Commented Jan 5, 2014 at 10:37

# 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 ## 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. • Shorter version using hexadecimal literals: print*,z'FBC'/len('hi');end. Commented Jan 8, 2014 at 12:31 • @HristoIliev: Totally forgot about printing hex via z! Thanks a bunch! Commented Jan 8, 2014 at 14:51 # Bash, 29 bytes Bash without using external programs: echo$((x=++y+y))$?$y$((x+x)) • Reduce to 25 bytes by using: echo$[y=++x+x]$?$x$[y+y]. – user92894 Commented Aug 30, 2019 at 14:50 # ~-~! (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. # 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 • 12 chars: +/&" ~~~~h'"; 6 chars, 7 bytes, unicodey: i$"ߞ" Commented Apr 13, 2017 at 13:00

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

• You could shorten 'ߞ'n; to 'n;ߞ, I believe. Commented Nov 1, 2015 at 12:03

### 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'
• Just thought I'd point out that a different sequence can save you a few characters. For instance, '.'*'.'-'f' is only 11 characters. Commented Jun 6, 2014 at 3:36
• @GlenO thanks! I added it as an edit. Commented Jun 6, 2014 at 7:15

# C#, 4 characters, 5 bytes

+'ߞ'

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

• It's 4 characters, yes, but 5 bytes. Commented Sep 20, 2014 at 17:37
• @JoeZ. ok, updated to reflect the number of bytes. Still way better than previous 63 and 64 bytes solutions.
– Cœur
Commented Sep 21, 2014 at 17:45

# JavaScript, 24 bytes

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

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

• That code doesn't work. Did you mean alert("ߞ".charCodeAt())? Commented Dec 27, 2014 at 21:12
• @hsl String.charCodeAt is present only in Firefox, it seems. But I'll use charCodeAt since its multi browser and shorter . Thanks! Commented Dec 27, 2014 at 21:25

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

• I tested on Python 2.7, and it works fine there; so you can save one character. Commented Jan 1, 2015 at 16:40
• I found the same python 3 version, but shorter (16 bytes) as I didn’t restrict myself to ASCII :print(ord('ߞ')) Commented Nov 4, 2015 at 14:37

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

# 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

# Python (30 chars)

(10 + 9) * 106 = 2014

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

# 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

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.

# Jolf, 3 bytes

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

@ߞ
@  Get charcode of next character
ߞ charcode 2014

# JavaScript, 9 bytes

btoaÛMx`

This Base-64 encodes ÛMx to make 2014.

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

# 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

• Using the integer metagolfer in WheatWizard's brain-flak optimizer I found ((((((()()()()()){}){})){}{}()){()()({}[()])}{}()) which is 4 bytes shorter. Commented Dec 15, 2016 at 7:30
• The challenge requires languages in which 0123456789 are valid tokens. Does Brain-Flak satisfy this requirement? Commented Jan 7, 2017 at 17:17

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

• The challenge requires languages in which 0123456789 are valid tokens. Does Brain-Flak satisfy this requirement? Commented Jan 7, 2017 at 17:17
• @Dennis yes @lt flags use decimal literals Commented Jan 7, 2017 at 21:59

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

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

I like this.

# Jelly, 3 bytes

⁽¥Æ

Try it online!

• Commented Aug 11, 2017 at 1:14

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

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

do'bbbc',~":_bd

# 11 bytes

,":_bk,:_be

## ><>, 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.
• 6 bytes: eaa+n<
– Jo King
Commented Apr 12, 2018 at 0:43