628
\$\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\$ Commented Apr 1, 2015 at 21:37
  • 7
    \$\begingroup\$ Brainfuck isn't a valid language for this challenge. \$\endgroup\$
    – Joe Z.
    Commented Apr 1, 2015 at 22:49
  • 14
    \$\begingroup\$ I know. That's why I posted it as a comment \$\endgroup\$ Commented 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.
    Commented Dec 26, 2015 at 23:28
  • 5
    \$\begingroup\$ Waiting for "Come on folks, don't you realize it's 2016?" :) \$\endgroup\$
    – padawan
    Commented Jan 4, 2016 at 23:35

333 Answers 333

1
4 5
6
7 8
12
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\$ Commented 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
    Commented 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
    Commented 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\$ Commented Mar 8, 2018 at 21:23
  • 1
    \$\begingroup\$ Thanks for the tips! Added some more solutions :) \$\endgroup\$
    – Job
    Commented 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
    Commented Jun 19, 2018 at 0:46
  • \$\begingroup\$ t=-~'';console.log(`${++t}${t-t}${t/t}${t*t}`) \$\endgroup\$
    – Jakob
    Commented 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
    Commented Nov 1, 2018 at 9:46
  • \$\begingroup\$ @JoKing Ah, didn't thought about that.. Thanks a lot for halving the byte-count! :) \$\endgroup\$ Commented Nov 1, 2018 at 10:18
  • 1
    \$\begingroup\$ 22 bytes. How it actually works is a bit weird... \$\endgroup\$
    – Jo King
    Commented 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\$ Commented Nov 1, 2018 at 10:43
  • \$\begingroup\$ shrugs Minimalism? \$\endgroup\$
    – Jo King
    Commented 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\$
2
\$\begingroup\$

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!

\$\endgroup\$
7
  • 1
    \$\begingroup\$ Hi, welcome to PPCG! See here for an existing 6- and 5-byte 05AB1E answer. But to golf your approach a bit more: 1. you can remove all « and only have a single J (join) at the end. 2. You could save values in between with © and use it later on with ® (i.e. žh¦¦©нžhнžh¦н®¦¦нJ). 3. There are builtins for the numbers 0, 1, and 2 if you don't change them later on, which are ¾, X, and Y respectively, so an alternative 6-byter could be Y¾XY·J (push 2; push 0; push 1; push 2 and double it; join all values on the stack together). \$\endgroup\$ Commented Sep 2, 2019 at 8:12
  • \$\begingroup\$ (this last one doesn't really look like your initial approach anymore, but just stating it as example). And if you haven't seen it yet, tips for golfing in 05AB1E might be interesting to read through. :) \$\endgroup\$ Commented Sep 2, 2019 at 8:13
  • \$\begingroup\$ Digits aren't allowed though. Otherwise just Ž7æ (compressed 2014) or 2014 itself would be enough. :) \$\endgroup\$ Commented Sep 4, 2019 at 10:42
  • \$\begingroup\$ @KevinCruijssen Oh, how silly. I forgot. \$\endgroup\$
    – mekb
    Commented Sep 4, 2019 at 10:43
  • \$\begingroup\$ I've found a 10 byte solution now. I don't think there might be any room for improvement. \$\endgroup\$
    – mekb
    Commented Sep 4, 2019 at 11:08
2
\$\begingroup\$

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.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Welcome! Though admittedly, the answer is simple, in general it is best to add an explanation or link to an online interpreter. Code-only answers are usually automatically flagged as low-quality, meaning that those answers have to be reviewed by someone. \$\endgroup\$
    – mbomb007
    Commented Aug 30, 2019 at 21:19
  • \$\begingroup\$ @mbomb007 yeah i was thinking about adding a link to tio.run, i'll do that \$\endgroup\$ Commented Aug 31, 2019 at 9:09
2
\$\begingroup\$

Python, 52 49 chars

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

Works in Python 2 and Python 3.

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

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.

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

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

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

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!

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

Husk, 4 bytes

c'ߞ

Try it online!

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

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!

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Ayy, somebody actually uses my language :D \$\endgroup\$
    – Dion
    Commented Aug 6, 2020 at 5:22
  • \$\begingroup\$ I tried using _ in the online interpreter, but for some reason it didn't work. I made a Gtihub issue on it. I'd like to solve some more puzzles, but that operator is causing a bit of a problem. \$\endgroup\$
    – Razetime
    Commented Aug 6, 2020 at 5:24
  • \$\begingroup\$ Ok, will check and fix. Thanks for notifying me! \$\endgroup\$
    – Dion
    Commented Aug 6, 2020 at 5:25
2
\$\begingroup\$

Python 3, 49 bytes

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

Python 3, 15 bytes

print(ord('ߞ'))
\$\endgroup\$
2
  • 2
    \$\begingroup\$ Welcome to the site, and creative first answer! You can improve your score by remove the spaces before the [, before the print and before the end: Try it online! \$\endgroup\$ Commented Nov 17, 2020 at 21:54
  • \$\begingroup\$ @cairdcoinheringaahing thanks for notice me! \$\endgroup\$ Commented Nov 17, 2020 at 21:57
2
\$\begingroup\$

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

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

Scratch, 82 bytes

when gf clicked
say(join(length of[The year two thousnd])(length of[and   fourteen
\$\endgroup\$
6
  • 1
    \$\begingroup\$ Happy 2021! Scratch solutions make me happy though so take your upvote :P \$\endgroup\$
    – Citty
    Commented Apr 13, 2021 at 13:04
  • \$\begingroup\$ Out of almost 300 answers, I was surprised that nobody had done Scratch yet! \$\endgroup\$
    – Nilster
    Commented Apr 13, 2021 at 13:08
  • \$\begingroup\$ If functions are allowed, you can do 73 bytes: define say(join(length of[The year two thousnd])(length of[and fourteen \$\endgroup\$ Commented Nov 29, 2022 at 13:02
  • \$\begingroup\$ With \n a newline \$\endgroup\$ Commented Nov 29, 2022 at 13:03
  • \$\begingroup\$ @UndoneStudios Scratch's syntax is the bane of my existence! However, I generally prefer full programs over functions, since they can be easily viewed in a project. Also, OP only specifies "programs." Thanks, though! \$\endgroup\$
    – Nilster
    Commented Dec 2, 2022 at 17:19
2
\$\begingroup\$

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.

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

Alphabetti spaghetti, 15 bytes

aiioaoaioaiiiio

Try it online!

\$\endgroup\$
1
  • 2
    \$\begingroup\$ 11 bytes with iioaoioiiio or iiuuiuiiiio. \$\endgroup\$
    – ovs
    Commented Jul 10, 2021 at 8:16
2
\$\begingroup\$

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

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
\$\endgroup\$
7
  • \$\begingroup\$ Could you provide a Desmos graph link in order to easily be able to verify your code? Also, you need to provide the byte count of the program in the header of the post. \$\endgroup\$
    – Aiden Chow
    Commented Apr 26, 2023 at 4:54
  • 1
    \$\begingroup\$ You can shorten b=cos(\tau) to b=lne. \$\endgroup\$
    – Aiden Chow
    Commented Apr 26, 2023 at 4:58
  • \$\begingroup\$ For reference, your solution is 40 bytes at the moment. I have taken pretty much the same calculations which you have in your code, but shortened it considerably to 24 bytes: 24 bytes, Try It On Desmos! \$\endgroup\$
    – Aiden Chow
    Commented Apr 26, 2023 at 5:08
  • \$\begingroup\$ It looks like b=lnee doesn't work since there has to be a space between the function and the characters otherwise desmos does... weird stuff and you have to have a backslash before ln ee so that desmos doesn't just see it as 2 undeclared variables. (also, your last line uses the number 2 but that can be swapped out for b) Still, thanks for the help. \$\endgroup\$ Commented Apr 27, 2023 at 14:47
  • \$\begingroup\$ If you paste in one line at a time instead of the whole thing at once (so paste in b=lnee in the first box, k=bbb in the next line, and kkkbb-kbb-b on the next line), then you will see that it works. \$\endgroup\$
    – Aiden Chow
    Commented Apr 27, 2023 at 17:44
2
\$\begingroup\$

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 . -----.----. Enters 2014 on the stack, -.- -. Konverts this to a decimal Number which gets Output by ---.

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

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()
\$\endgroup\$
3
  • \$\begingroup\$ I thought 2024 was the required output this year. Also I checked your link and I couldn't find how it helps me to shorten ".hashCode()". \$\endgroup\$
    – Achaaab
    Commented Jan 10 at 18:56
  • 1
    \$\begingroup\$ The hashing algorithm is very simple: it's a series of additions and multiplications by 31. No need for brute-forcing. You can use, for example, 2014=63*31+61. \$\endgroup\$
    – anatolyg
    Commented Jan 10 at 19:45
  • \$\begingroup\$ Ok, I got it now, I first wanted to use only a-z characters which make it much more complicated, but "?=" works as well. \$\endgroup\$
    – Achaaab
    Commented Jan 10 at 19:57
2
\$\begingroup\$

Rattle, 1211 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"
      
\$\endgroup\$
1
\$\begingroup\$

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.

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


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.

\$\endgroup\$
3
  • \$\begingroup\$ You don't actually need to include stdio.h, most compilers will give a warning but include it for you. \$\endgroup\$
    – user344
    Commented Jan 1, 2014 at 21:58
  • \$\begingroup\$ This code yields 7 for me with tcc and 508830 with gcc. clang gives an error: character too large for enclosing character literal type. \$\endgroup\$
    – user344
    Commented Jan 1, 2014 at 22:02
  • \$\begingroup\$ @nyuszika7h ... 7 is equivalent with \a - this could be a problem with passing to the printf function, it would be interesting for me to see if int a = '\aÞ' is 2014 using tcc. 508830 looks very strange to me - i would guess some endian thing but n * 256 + 7 can never be that number. So this illuminates how string this code depends on the system. \$\endgroup\$
    – Johannes
    Commented Jan 1, 2014 at 22:58
1
\$\begingroup\$

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)

<!--Comment
  previous
  2013 lines -->
<?=__LINE__; <!-- This should be on line 2014 -->
\$\endgroup\$
5
  • \$\begingroup\$ That would be 2013 newlines followed by <?=__LINE__ for 2024 chars, not 9. \$\endgroup\$ Commented Jan 2, 2014 at 9:28
  • \$\begingroup\$ @PeterTaylor I didn't write 9 chars to win the challenge (since there are lots of shortest answers!), but because the actual code is that <?=__LINE__;?>, which I thought would be funny :) Nvm, I'll edit that. \$\endgroup\$
    – Vereos
    Commented Jan 2, 2014 at 9:31
  • \$\begingroup\$ If it doesn't work without the newlines, they're part of the "actual code". \$\endgroup\$ Commented Jan 2, 2014 at 9:32
  • \$\begingroup\$ I guess you're right, edited. \$\endgroup\$
    – Vereos
    Commented Jan 2, 2014 at 9:37
  • 1
    \$\begingroup\$ In PHP, you can skip ?> at end of the program. But interesting idea with __LINE__, even if it's ridiculous for such huge number. \$\endgroup\$
    – null
    Commented Jan 2, 2014 at 12:15
1
\$\begingroup\$

Game Maker Language, 22

show_message(ord("ߞ"))
\$\endgroup\$
1
\$\begingroup\$

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"));}
\$\endgroup\$
1
\$\begingroup\$

C/C++ 39

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

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

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

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

\$\endgroup\$
1
4 5
6
7 8
12

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