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

»
» All times are UTC - 5 Hours

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