623
\$\begingroup\$

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>

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

333 Answers 333

1
3 4
5
6 7
12
2
\$\begingroup\$

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.

\$\endgroup\$
2
  • \$\begingroup\$ Shorter version using hexadecimal literals: print*,z'FBC'/len('hi');end. \$\endgroup\$ Jan 8, 2014 at 12:31
  • \$\begingroup\$ @HristoIliev: Totally forgot about printing hex via z! Thanks a bunch! \$\endgroup\$
    – Kyle Kanos
    Jan 8, 2014 at 14:51
2
\$\begingroup\$

Bash, 29 bytes

Bash without using external programs:

echo $((x=++y+y))$?$y$((x+x))
\$\endgroup\$
1
  • \$\begingroup\$ Reduce to 25 bytes by using: echo $[y=++x+x]$?$x$[y+y]. \$\endgroup\$
    – user92894
    Aug 30, 2019 at 14:50
2
\$\begingroup\$

~-~! (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.

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
1
  • 2
    \$\begingroup\$ 12 chars: +/&" ~~~~h'"; 6 chars, 7 bytes, unicodey: `i$"ߞ" \$\endgroup\$
    – zgrep
    Apr 13, 2017 at 13:00
2
\$\begingroup\$

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

\$\endgroup\$
1
  • 1
    \$\begingroup\$ You could shorten 'ߞ'n; to 'n;ߞ, I believe. \$\endgroup\$ Nov 1, 2015 at 12:03
2
\$\begingroup\$

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

C#, 4 characters, 5 bytes

+'ߞ'

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

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

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

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

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.

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

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-
\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

Python (30 chars)

(10 + 9) * 106 = 2014

(ord('\t')+ord('\n'))*ord('j')
\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

Jolf, 3 bytes

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

@ߞ
@  Get charcode of next character
 ߞ charcode 2014
\$\endgroup\$
2
\$\begingroup\$

JavaScript, 9 bytes

btoa`ÛMx`

This Base-64 encodes ÛMx to make 2014.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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

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

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.

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

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!

\$\endgroup\$
2
\$\begingroup\$

Lean Mean Bean Machine, 53 bytes

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

I like this.

\$\endgroup\$
2
\$\begingroup\$

Jelly, 3 bytes

⁽¥Æ

Try it online!

\$\endgroup\$
1
2
\$\begingroup\$

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

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

15 bytes

do'bbbc',~":_bd

11 bytes

,":_bk,:_be
\$\endgroup\$
2
\$\begingroup\$

><>, 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.
\$\endgroup\$
1
  • 2
    \$\begingroup\$ 6 bytes: eaa+n< \$\endgroup\$
    – Jo King
    Apr 12, 2018 at 0:43
2
\$\begingroup\$

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))
\$\endgroup\$
5
  • 2
    \$\begingroup\$ Welcome to the site, and nice first post! \$\endgroup\$ Mar 8, 2018 at 20:55
  • \$\begingroup\$ Thanks. Do you know of any ways to show all answers on one page so I can quickly check for duplicates next time? ;) \$\endgroup\$
    – Job
    Mar 8, 2018 at 20:57
  • 1
    \$\begingroup\$ @Job the stack snippet in the question body lists by shortest solutions and the shortest solutions by language. I've never been able to see them on mobile/in the app, though, so your mileage may vary. \$\endgroup\$
    – Giuseppe
    Mar 8, 2018 at 21:11
  • 1
    \$\begingroup\$ @Job You can do a search with inquestion. For just about all questions, there'll be just one page of results. The 17005 is this question's ID, found in the URL. \$\endgroup\$ Mar 8, 2018 at 21:23
  • 1
    \$\begingroup\$ Thanks for the tips! Added some more solutions :) \$\endgroup\$
    – Job
    Mar 9, 2018 at 0:28
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
  • \$\begingroup\$ Technically you don't need the ~~ before the true \$\endgroup\$
    – Jo King
    Jun 19, 2018 at 0:46
  • \$\begingroup\$ t=-~'';console.log(`${++t}${t-t}${t/t}${t*t}`) \$\endgroup\$
    – Jakob
    Jun 19, 2018 at 1:45
2
\$\begingroup\$

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.
\$\endgroup\$
5
  • 1
    \$\begingroup\$ Why not calculate the 2014 code point and skip the -A flag? 23 bytes \$\endgroup\$
    – Jo King
    Nov 1, 2018 at 9:46
  • \$\begingroup\$ @JoKing Ah, didn't thought about that.. Thanks a lot for halving the byte-count! :) \$\endgroup\$ Nov 1, 2018 at 10:18
  • 1
    \$\begingroup\$ 22 bytes. How it actually works is a bit weird... \$\endgroup\$
    – Jo King
    Nov 1, 2018 at 10:26
  • \$\begingroup\$ @JoKing Oh, smart! That 23-byter was pretty obvious and I can't believe I missed it now. But that 22-byter is very smart and not something I would have thought of myself. Well done! It's only my first Lost answer, so hopefully I will get better at it. Btw, out of curiosity, is there a reason the language is lacking a divide and modulo operator? \$\endgroup\$ Nov 1, 2018 at 10:43
  • \$\begingroup\$ shrugs Minimalism? \$\endgroup\$
    – Jo King
    Nov 1, 2018 at 12:53
2
\$\begingroup\$

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.

\$\endgroup\$
0
2
\$\begingroup\$

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
\$\endgroup\$
1
3 4
5
6 7
12

Not the answer you're looking for? Browse other questions tagged or ask your own question.