This is a reboot of the old 2015 thread.

I saw a lot of inputs in the old thread, I was wondering what we could come up with for 2017.

As before, no number inputs allowed (pi and e are allowed, though)

For an extra challenge, why not constrict it even further? Only one-line inputs are allowed, that can be run on the homescreen.

To start you off (29 bytes):

**Code:** `int(ππππππ+eeeeeee-πππ-ππ`

[EDIT]

Let's try for all the years 2000-2017.
10 bytes.

**Code:** `int(π+π+e^(π^√(π`

I'm gonna pretend that didn't happen and try for 2nd place.

18 bytes.

**Code:** `int(e)^int(πe+e)-int(πππ`

Edit: 17 bytes, via "rule change" in IRC:

**Code:** `int(e)^int(πe+e)-int(π³`

2001= int(-ππ+e^(π^√(π

2007= int(-π+e^(π^√(π

2010= int(e^(π^√(π

2013= int(e+e^(π^√(π

2014= int(π+e^(π^√(π

2018= int(ee+e^(π^√(π

2019= int(eπ+e^(π^√(π

EDIT:

**Code:** ```
int(seq(A+e^(pi^sqrt(pi)),A,~pipi,ee,e
```

={2001 2003 2006 2009, 2011, 2014, 2017}

(22 bytes)/(7 years)=3.14 bytes/year
Now I'm going for trickshots, rather than a whole-in-one:

(20 bytes)

**Code:** ```
:sum(int(seq(X,X,e,π²
```

:Ans²+int(π²²

In one line:

(21 bytes)

**Code:** `:sum(int(seq(X,X,e,π²)))²+int(π²²`

Note that π²² = (π²)²
**JWinslow23 wrote:**

10 bytes.

**Code:** `int(π+π+e^(π^√(π`

damm

I got 15 bytes for 2017:

**Code:** `int(π²e-e) nCr int(π)-int(e²`

and 12 bytes for 2016

**Code:** `int(-π³+int(e)^int(sinh(π`

Also, there used to be a topic specifically for the year 2015.

Here is an interesting answer from that topic:

If your calculator's time is correct,

**Code:** `getDate:Ans(π/π `

Also, there was a codegolf topic for the year 2014

EDIT: Inspired from lirto's routine, 8 bytes for 2017:

**Code:** `int([i]²+e^(cosh(e`

You can get a list of all the years 2000-2017 with 26 bytes:

**Code:** ```
int(e^(pi[i])+seq(A+e^(pi^sqrt(pi)),A,~pipi,e²
```

That works out to 1.44 bytes per year.
**jonbush wrote:**

You can get a list of all the years 2000-2017 with 31 bytes:

**Code:** ```
int(e^(pi[i])+seq(A+e^(pi^sqrt(pi)),A,~pipi,ee,~real(e^(pi[i]
```

That works out to 1.722 bytes per year.

You're over complicating this a lot.

**Code:** `seq(int(e)10^(int(π))+X,X,not(π),e^(sinh(sqrt(π`

23 bytes (1.277 bytes per year)

EDIT:

**Code:** `int(e)10^(int(π))+cumSum(binomcdf(int(e³-e),not(π`

25 bytes (1.388 bytes per year)
The e token is actually two bytes, unfortunately.

I'm currently actually working on that computer search I talked about two years ago... Maybe it will find the optimal solution.

You people make this look easy.

I was able to shave a byte off of mr womp womp's solution, for 24 bytes:

**Code:** `seq(X,X,not(π),e³-e)+int(e)10^(int(π`

23 bytes:

**Code:** `int(seq(X,X,~π-e²,e²)+e^(π^sqrt(π`

I think this can be improved further.
22 bytes:

**Code:** `int(seq(X,X,int(~π²),e²)+e^(π^√(π`

Also 22:

**Code:** `int(seq(X,X,~π²acosh(π),~π^-1)+e^(cosh(e`

6 bytes for 2017:

**Code:** `int(³√(10^(10^(tanh(π`

7 bytes for 2015:

**Code:** `int(sinh(πe^(tan⁻¹(³√(π`

21 bytes for the list:

**Code:** `int(seq(X,X,π,π³-π²)+10^(cosh(sinh⁻¹(sinh⁻¹cosh(π`

I believe the first two are the smallest possible, but 20 bytes may be possible for the list. There are certainly many 21-byte solutions.

EDIT: 20 bytes for the list. I believe this is optimal.

**Code:** ```
e^(sinh⁻¹(10^(int(π
```

int(seq(X,X,Ans,Ans+ππ√(π

Register to Join the Conversation

Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

»

Go to Registration page

You **cannot** post new topics in this forum

You **cannot** reply to topics in this forum

You **cannot** edit your posts in this forum

You **cannot** delete your posts in this forum

You **cannot** vote in polls in this forum