[Question]
  [
It is common to start countdowns 100 days prior to an event, probably because of our base 10 system. Examples of this can be found everywhere:
* 100 days until your birthday
* 100 days until the wedding
* 100 days until the election
* 100 days until our graduation
* 100 days until her due date
* 100 days until football season
* 100 days until you get the Fanatic badge
You get the picture. It seems that the 100th day before an event is second place only to the actual event. So for this challenge, I need to know what the date will be in 100 days, so that I can determine what I should start counting down too.
## Input
No input
## Output
The date 100 days from the current date based on the standard [Gregorian Calendar](https://en.wikipedia.org/wiki/Gregorian_calendar) (Make sure to account for leap years). Output is flexible as long as the date format is human read-able (eg `2016-10-8`, `10-8-16`, `[ 2016, 10, 8 ]`, `10/8/16 12:00:00 AM`).
## Winning
Code golf: shortest code in bytes
---
### Examples
100 days from today (Apr 5th, 2017) is Friday, July 14 2017.
```
Current                Future
-------                ------
01/01/2001 +100        04/11/2001
01/01/2004 +100        04/10/2004
01/01/1900 +100        04/11/1900
01/01/2000 +100        04/10/2000
07/04/2017 +100        10/12/2017
10/31/2017 +100        02/08/2018
12/25/2017 +100        04/04/2018
08/29/1941 +100        12/07/1941
06/03/2001 +100        09/11/2001
```
  
[Answer]
# Excel, 10
```
=NOW()+100
```
### Demonstration
[![enter image description here](https://i.stack.imgur.com/KQSSQ.gif)](https://i.stack.imgur.com/KQSSQ.gif)
[Answer]
# Bash, ~~17~~ ~~16~~ ~~15~~ ~~14~~ 13 bytes
```
date -d100day
```
It turns out the `date` command takes some pretty flexible input for relative timings. You can also do things like `1 year`, `1 week ago`, `yesterday`, etc. It's pretty cool.
-1 byte by realizing that bash does not care about grammar.  
-1 byte because the space between `100` and `day` is unnecessary.  
-1 byte because I don't need quotes anymore because I don't have a space in the string.  
-1 byte by removing the space after `-d` (thanks ASCII-only!) 
[Answer]
# PowerShell, 10 bytes
```
(date)+1e2
```
Thanks to ConnorLSW for the +1e2 trick.
It appears that doubles (`1e2` is a double) are also added as days.
### Previous version, 12 bytes:
```
(date)+"100"
```
Apparently you can add strings to dates in PowerShell. The string `"100"` is converted into a 100 days-`TimeSpan`.
[Answer]
# Mediawiki, 19bytes
```
{{#time:r|+100day}}
```
You may try it with [wikipedia's sandbox](https://en.wikipedia.org/w/index.php?title=Wikipedia:Sandbox&action=edit)
[Answer]
# PHP, 28 bytes
```
<?=date(Y_m_d,time()+864e4);
```
human readable version, 35 bytes:
```
<?=date(Y_m_d,strtotime("100day"));
```
almost readable, 34 bytes:
```
<?=date(Y_m_d,strtotime(1e2.day));
```
-4 bytes if also printing the time is accepted: replace `Y_m_d` with `r` or `c`.
It´s National Holiday in France in 100 days.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 16 bytes
```
p Time.now+864e4
```
[Try it online!](https://tio.run/nexus/ruby#@1@gEJKZm6qXl1@ubWFmkmry/z8A "Ruby – TIO Nexus")
[Answer]
# Javascript, ~~29~~ ~~26~~ 25 bytes
Saved 3 bytes thanks to @ASCII-only!
Saved 1 byte thanks to @JohanKarlsson
```
new Date(+new Date+864e7)
```
```
document.body.innerHTML=new Date(+new Date+864e7)
```
[Answer]
## SQL (PostgreSQL), 19 Bytes
```
SELECT now()+'100d'
```
[Answer]
# Vim, 27 bytes
```
:r!date "+\%F" -d"+100 day"
```
[try it online!](https://tio.run/nexus/v#@29VpJiSWJKqoKQdo@qmpKCbAmQZGhgopCRWKv3/DwA "Try it Online!")
[![enter image description here](https://i.stack.imgur.com/AkClj.png)](https://i.stack.imgur.com/AkClj.png)
Edit: Removed unnecessary space char.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 9 bytes
```
Z'100+1XO
```
Output format is `15-Jul-2017` (which I find most readable). Change `1XO` to `2XO` to get the format used in the examples, `07/15/17`.
[Try it online!](https://tio.run/nexus/matl#@x@lbmhgoG0Y4f///9e8fN3kxOSMVAA "MATL – TIO Nexus")
### Explanation
```
Z'      % Push current date and time as a serial date number
100+    % Add 100
1XO     % Convert to string with format 'dd-mmm-yyyy'. Implicitly display
```
[Answer]
**SQL (Microsoft), 35 31 bytes**
```
SELECT DATEADD(D,100,GETDATE())
```
[Answer]
# Java 8, ~~77~~, 61 bytes
```
()->System.out.print(java.time.LocalDate.now().plusDays(100))
```
[Try it online!](https://tio.run/nexus/java-openjdk#DcmtDsIwEABgv6eobAWXobGToCYJ4jiaUdK/7K4ly7LHRpeqT3zkkVnd0MV9yOXpHSkWlE5N7qVCDz3L6uJyfyhcl2r2Nm8sNkAqArmP6A9WBHHBwjUR@gnFQkxfbSD7whNurM/jaMylHcPRfjGdCOlt/w "Java (OpenJDK 8) – TIO Nexus")
[Answer]
# C#, 103 97 bytes
*Thanks to [raznagul](https://codegolf.stackexchange.com/users/42502/raznagul) for saving 6 bytes!*
```
using System;class P{static void Main(){Console.Write(DateTime.Now.AddDays(100).ToString("d"));}}
```
Full program which reads the current date, adds 100 days and displays the result in `M/d/YYYY` format.
You can change the date format by adding a few more bytes:
```
using System;class P{static void Main(){Console.Write(DateTime.Now.AddDays(100).ToString("d-M-yyyy"));}}
```
---
To eliminate boilerplate code - C# isn't exactly known to be very compact - an anonymous function can be used:
# C# lambda, 49 43 bytes
```
()=>DateTime.Now.AddDays(100).ToString("d")
```
Full program:
```
using System;
class P
{
    static void Main()
    {
        Func<string> f = 
        ()=>DateTime.Now.AddDays(100).ToString("d");
        
        Console.WriteLine(f());
    }
}
```
[Answer]
# [Noodel](https://tkellehe.github.io/noodel), 8 [bytes](https://tkellehe.github.io/noodel/docs/code_page.html)
```
]5@LaƇ⁺ƈ
```
[Try it:)](https://tkellehe.github.io/noodel/editor.html?code=%5D5%40La%C6%87%E2%81%BA%C6%88&input=&run=false)
---
## How it works
```
]5@LaƇ⁺ƈ
]5@La    # The string "]5@La" gets pushed onto the stack which in base 98 represents 8,640,000,000.
     Ƈ   # Pushes an integer that represents the current time where highest resolution is milliseconds.
      ⁺  # Add the time and the string which will be interpreted as 8,640,000,000ms.
       ƈ # Convert the integer to human readable time.
         # Implicitly output to the screen.
```
```
<div id="noodel" code="]5@LaƇ⁺ƈ" input="" cols="80" rows="2"/>
<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>
```
[Answer]
# Mathematica, ~~26~~ 21 bytes
-5 bytes thanks to @KiranLinsuain!
```
Today+Quantity@"100d"
```
If including the time is permitted, then we can save 2 bytes:
```
Now+Quantity@"100d"
```
[Answer]
# C, ~~87~~ ~~46~~ 44 bytes
*saved 2 bytes thanks to [Albert Renshaw](https://codegolf.stackexchange.com/users/16513/albert-renshaw)*
```
f(){time_t t=time(0)+864e4;puts(ctime(&t));}
```
I realized the output is flexible enough to allow for day of week and time, so there's no need to use `localtime` or the `tm` structure at all.
### Old answer
```
f(){time_t t=time(0)+8640000;char b[9];strftime(b,9,"%d-%m-%y",localtime(&t));puts(b);}
```
Based on [Khaled.K's answer](https://codegolf.stackexchange.com/a/115517/67236), but instead of messing with the `tm` structure, adds the number of seconds equivalent to 100 days directly to the `time_t` value. It also prints only the date, without time or day of week.
As it should happen on a golfed program, some ugly warnings are generated on compilation.
[Try it online!](https://ideone.com/ZFJc7k)
### Ungolfed:
```
f(){
    // Current time + 100 days
    time_t t=time(0)+8640000;
    // Buffer for printing formatted time
    char b[9];
    // Print the time in format dd-mm-yy to buffer
    strftime(b,9,"%d-%m-%y",localtime(&t));
    // print buffer
    puts(b);
}
```
[Answer]
# JavaScript, 42 bytes
```
(d=new Date()).setDate(d.getDate()+100)&&d
```
```
setInterval(_=>document.body.innerHTML=(d=new Date()).setDate(d.getDate()+100)&&d,1000)
```
[Answer]
# IBM/Lotus Notes Formula, 29 bytes
```
@Adjust(@Today;0;0;100;0;0;0)
```
Unfortunately `@Adjust` requires the trailing `0's` for the missing `hh:mm:ss`.
If we were allowed to display the time as well then changing `@Today` to `@Now` would save 2 bytes for 27.
[Answer]
## JavaScript (ES6), 44 bytes
```
_=>new Date(Date.now()+864e7).toDateString()
```
25 bytes if returning a date with the time is acceptable:
```
_=>Date(Date.now()+864e7)
```
[Answer]
# 30 bytes
**Mysql!**
```
select NOW()+INTERVAL 100 DAY;
```
**SQLite**
```
SELECT date('now','+100 day');
```
[Answer]
# F# (53 bytes)
```
printf"%s"(DateTime.Now.AddDays(100.0).ToString("d"))
```
[Answer]
## Swift 3, 39 bytes
```
print(Date(timeIntervalSinceNow:864E4))
```
[Answer]
# C, ~~120~~ 113 bytes
```
#include <time.h>
f(){time_t t=time(0);struct tm*tm=localtime(&t);tm->tm_mday+=100;t=mktime(tm);printf("%s",ctime(&t));}
```
[**Live Demo**](http://ideone.com/O15P4q)
```
#include <stdio.h>
#include <time.h>
void PrintDatePlus100days()
{
    // obtain current time
    time_t t = time( 0 );
    // convert to datetime struct
    struct tm *tm = localtime( &t );
    // add 100 days
    tm->tm_mday += 100;
    // convert to time_t
    t = mktime( tm );
    // print time in readable format
    puts( ctime( &t ) );
}
```
[Answer]
**PowerShell, 23**
```
(get-date).adddays(100)
```
This is my first ever try, so please give me constructive feedback. Thanks!
[Answer]
# R (REPL), 14 bytes
```
Sys.Date()+100
```
Try it on [Ideone](http://ideone.com/27USzq).
[Answer]
# Python, 63 bytes
```
from datetime import*
print(datetime.now()+timedelta(days=100))
```
Very simple solution really. Because the `datetime.now()` result is the same `type` as the result of `timedelta`, it happily adds the two together.
[Answer]
# JavaScript, 38 Bytes
```
d=new Date;d.setDate(d.getDate()+100);d
```
A little bit shorter than [ASCII-only answer](https://codegolf.stackexchange.com/a/115441/65663).
```
document.write(eval("d=new Date;d.setDate(d.getDate()+100);d"))
```
[Answer]
# Golang, 58 bytes
```
import ."time"
func f(){Println(Now().AddDate(0, 0, 100))}
```
Full Program
```
package main
import . "time"
import . "fmt"
func main() {
    Println(Now().AddDate(0, 0, 100))
}
```
[try it online!](https://tio.run/nexus/go#K0hMzk5MT1XITczM48rMLcgvKlHQU1BKyy1R@g/jKpVk5qYqcaWV5iUrpGloVgcUZeaV5ORp@OWXa2jqOaakuCSWpGoY6CgAkaGBgaZm7X@wWpCZGpoK1VycQF1ctf8B)
[Answer]
**Oracle, 34 bytes**
```
SELECT CURRENT_DATE+100 FROM DUAL;
```
[Answer]
# Python 2 + Pandas 0.19.1, 56 51 bytes
```
from pandas import*
print Timestamp('now','D')+100
```
]