[Question]
  [
The day this post was published was Christmas Eve. Tomorrow will be Christmas. Yesterday was Christmas Eve Eve. In two days it will be 
```
Christmas Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve Eve
```
.
Your job is to take the date the program is run and encode it in Christmas Eve format.
* If your program is run on Christmas, it should output the string "Christmas".
* If your program is not run on Christmas, it should output the string "Christmas", followed by the string " Eve" repeated `n` times, where `n` is the number of days until Christmas.
	+ Note that this must be based on the *next* Christmas. For example, if the day is April 26, 2019, you must do your calculation based on December 25, 2019, not any other Christmas.
	+ Remember to count leap days.
* Christmas is December 25th of every year.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code wins! Note though that the goal is not to find the shortest program in any language, but to find the shortest program in every particular language. For example, if you find the shortest C++ program, then it wins this contest for C++, even if someone finds a shorter program in Python.
  
[Answer]
# SmileBASIC, ~~73~~ ~~71~~ 67 bytes
```
?"Christmas";
@L?" Eve"*(D!=P);
P=D
DTREAD OUT,M,D
IF M/D-.48GOTO@L
```
The program prints "Christmas", then prints " Eve" every time a day passes, until it is December 25th. (12/25 = 0.48)  
May take up to a year to run.
[Answer]
# Excel formula, 59 bytes
```
="Christmas"&REPT(" Eve",DATE(YEAR(NOW()+6),12,25)-TODAY())
```
[Answer]
# [Perl 6](http://perl6.org/), ~~61~~ 47 bytes
~~say 'Christmas'~' Eve'x(Date.today...^{.month==12&&.day==25})~~
```
say 'Christmas'~' Eve'x(Date.today...^/12\-25/)
```
[Try it online!](https://tio.run/##K0gtyjH7/784sVJB3TmjKLO4JDexWL1OXcG1LFW9QsMlsSRVryQ/JbFST08vTt/QKEbXyFRf8/9/AA "Perl 6 ‚Äì Try It Online")
*-14 bytes (!) thanks to Jo King*
`Date.today ...^ /12\-25/` is the sequence of dates starting today and ending the day before Christmas. (The regular expression `/12\-25/` is matched against the string representation of the dates.) The string `" Eve"` is replicated a number of times equal to the length of that sequence, and is output after the string `"Christmas"`.
[Answer]
# [R](https://www.r-project.org/), ~~112 106~~ 72 bytes
Via @digEmAll and @J.Doe
```
x=Sys.Date()-1;cat('Christmas');while(!grepl('12-25',x<-x+1))cat(' Eve')
```
[Try it online!](https://tio.run/##bY1BbsIwEEX3OcXULGyruEqiUlECq7YnYJuNRWywFGxkT8AIcfbUoW02zSznvf@/72dw8fIExoIE3dkdGmcBHQRz7FqJChqjtfLKIhB0jbwGkmlYi1Fmkd8ygO01vHwmfzP@@S3eYTYC8Ao7bwPENBZQyQachkdliu8kMnRb9MbuU@OcrmpLeR83f3HGRVENFv04eBPwKAPl1eVgWsWe9l6dWkaLUpQLOo9rEZ8Lzh82fJ1VKvpZILUVE1dbwrN7ppn83SJlXizFUPdKOK9gEi0GNEneJsi7yBNZ/idlPpL@Gw "R ‚Äì Try It Online")
My original answer was prior to the clarification that the code was to take the date on which the code is run as input. It could be modified as above to save many bytes but I won't bother.
```
function(x,z=as.Date(paste0(strtoi(format(x,"%Y"))+0:1,"-12-25"))-x)cat("Christmas",rep("Eve",z[z>=0][1]))
```
[Try it online!](https://tio.run/##fcxLCsIwFIXhuasoF4QEE0mChfqoE3URUjsIJcEM@iC5SunmYyjoSDo8nI/fR5udeLSvrkHXd2RkU6nD9qrRkEEHNIIE9Ng7YnvfakwA1negdCMOkgGXiqs8TT7SJr1weXoXsNUBmDcDgdvbAJuq6VyKupI1pdGSbx@UkMVc2KXCMZsDjw7o6p/JF82ei2SKJaPEz8QP "R ‚Äì Try It Online")
Explanation: everyone's at church so I have time to do this. Extract the year, coerce to integer. Make vector of that year's Xmas and the next year's Xmas and subtract the input date to get a vector of two differences between the input date and those two Xmases. 
Pick the non-negative one and `cat` "Christmas" with that many "Eves".
[Answer]
# [Windows PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~67~~ ~~64~~ 63 bytes
```
for(;1225-'{0:Md}'-f(date|% *ys $i)){$i++}'Christmas'+' eve'*$i
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SMPa0MjIVFe92sDKN6VWXTdNIyWxJLVGVUGrslhBJVNTs1olU1u7Vt05oyizuCQ3sVhdW10htSxVXUsl87@SSiaIXaz0HwA "PowerShell ‚Äì Try It Online")
Managed to shave off ~~3 bytes~~ 4 bytes (thanks [Cows quack](https://codegolf.stackexchange.com/users/41805/cows-quack)) by using the `-f`ormat operator instead of `.ToString()`, and then subtracting the date string from the numerical value 1225 instead of doing a comparison with `-ne`. The resulting integer will be interpreted as a boolean for the conditional where `0` (which will happen on Christmas) is interpreted as `False` (don't enter the loop), and any other value is interpreted as `True` (enter the loop). 
Since the integer is on the left now, the date string will be converted to the integer and math will be done, as opposed to the previous version where the `1225` integer was converted to string for the comparison.
### Original Version
---
# [Windows PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 67 bytes
```
for(;(date|% *ys $i|% tost* Md)-ne1225){$i++};'Christmas'+' eve'*$i
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SMNaIyWxJLVGVUGrslhBJRPIKMkvLtFS8E3R1M1LNTQyMtWsVsnU1q61VnfOKMosLslNLFbXVldILUtV11LJ/P8fAA "PowerShell ‚Äì Try It Online")
Using a `for` loop as a `while` loop basically, because it's shorter. In the loop condition we check the current date (`date`, a shortened form of `Get-Date`), piped to `ForEach-Object`'s alias `%`, using the form that can invoke a method by wildcarded name; in this case the method is `AddDays()` on the `DateTime` object, and the value we give it is `$i`. 
This gets piped to `ForEach-Object` again to invoke the `ToString()` method, with format string `Md` (month, then day, minimal digits since we don't care for what comes next). This string is then tested to see if it's not equal `-ne` to the number `1225`, which will be converted to a string for the comparison, saving me the quotes. 
This is why it doesn't matter that the months and days are single digits, it will never be ambiguous because there's no other day of the year that would stringify to `1225`. 
The loop continues until the string *is* `1225`. At the beginning of the program, `$i` will be zero so it will be comparing today's date, and the loop will never execute, but for any other day `$i` gets incremented in the loop body, so that we will have a count of how many days until the next Christmas, automatically accounting for leap years and whether or not Christmas passed this year. 
After the loop we just output the string `Christmas` concatenated with the result of multiplying the string `eve` times the value of `$i` (which, on Christmas day, will be `0`, resulting in no `eve`s).
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 89 bytes
```
Write("Christmas");for(var t=DateTime.Now;$"{t:Md}"!="1225";t=t.AddDays(1))Write(" Eve");
```
[Try it online!](https://tio.run/##Sy7WTS7O/P8/vCizJFVDyTmjKLO4JDexWEnTOi2/SKMssUihxNYlsSQ1JDM3Vc8vv9xaRam6xMo3pVZJ0VbJ0MjIVMm6xLZEzzElxSWxsljDUFMTapSCa1kq0JT//wE "C# (Visual C# Interactive Compiler) ‚Äì Try It Online")
-3 bytes thanks to @JeppeStigNielsen!
My strategy is pretty straightforward:
1. Initialize a loop variable `t` to the current date
2. Print `Eve` if `t` is not Christmas
3. Add a day to `t` and repeat
I tried some fancier things, but this way required the fewest bytes.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~76~~ 63 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Assumes `‚éïIO‚Üê0` (zero-indexing).
```
‚éïCY'dfns'
'Christmas',' Eve'‚ç¥‚ç®4√ó12 25‚ç≥‚ç®‚çâ2‚Üë1‚Üì‚çâdate(‚ç≥366)+days‚éïTS
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGXI862gtAXOdI9ZS0vGJ1LnXnjKLM4pLcxGJ1HXUF17JU9Ue9Wx71rjA5PN3QSMHI9FHvZiDvUW@n0aO2iYaP2iYDmSmJJakaQAljMzNN7ZTEymKggSHB/4Fm/1cAgwIA "APL (Dyalog Unicode) ‚Äì Try It Online")
`‚éïCY'dfns'`‚ÄÉ**c**o**p**y in [the dfns library](http://dfns.dyalog.com/n_contents.htm)
`‚éïTS`‚ÄÉcurrent **t**ime **s**tamp as [year,month,day,hour,min,sec,ms]  
`days`[[c]](http://dfns.dyalog.com/c_days.htm "Code")‚ÄÉfind the number of days[[n]](http://dfns.dyalog.com/n_days.htm "Notes") since 1899-12-31 00:00:00.000  
`(‚ç≥366)`‚ÄÉadd the first 366 integers (0‚Ä¶365) to that  
`date`[[c]](http://dfns.dyalog.com/c_date.htm "Code")‚ÄÉfind the dates[[n]](http://dfns.dyalog.com/n_date.htm "Notes") that correspond to those numbers (366√ó7 table; one column per unit)  
`‚çâ`‚ÄÉtranspose (7√ó366 table; one row per unit)  
`1‚Üì`‚ÄÉdrop one row (the years)  
`2‚Üë`‚ÄÉtake the first two rows (months and days)  
`12 25‚ç≥‚ç®`‚ÄÉfind the index of the first Christmas  
`4√ó`‚ÄÉmultiply that by four  
`' Eve'‚ç¥‚ç®`‚ÄÉuse that to reshape the character list  
`'Christmas ',`‚ÄÉappend that to this
[c]‚ÄÉcode of that function  
[n]‚ÄÉnotes for that function
[Answer]
## T-SQL, ~~92~~ 88 bytes
```
PRINT'Christmas'+REPLICATE(' Eve',DATEDIFF(D,GETDATE(),STR(YEAR(GETDATE()+6))+'-12-25'))
```
Edit: Saved 4 bytes thanks to @BradC.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~111~~ 103 bytes
```
from datetime import*
d=date.today()
print"Christmas"+" Eve"*(date((d+timedelta(6)).year,12,25)-d).days
```
[Try it online!](https://tio.run/##FYxBCgMhDADv@wrxlOxuhQrtrafShwSSskJdJYaCr7f1OsxM7XaUM47x1pIdk4mlLC7lWtTWhR8TBStMHXCpmk7zz0NTs0zNb969vuJXmBYAbzNm@RjBHTF0Id2vcY83vDCG/6ON8QM "Python 2 ‚Äì Try It Online")
Update inspired by [Richard Crossley's answer](https://codegolf.stackexchange.com/a/178023/73368).
Explanation:
```
from datetime import*
# get today as a date, so we don't have to worry about rounding errors due to time
d=date.today()
                              # get the year of the Christmas to compare to
                              # if the current date is after this year's Christmas, the 6 day offset will give the next year
                              # otherwise, returns this year
                              (d+timedelta(6)).year
                         # next Christmas minus the current date
                         date(.....................,12,25)-d
# Christmas, plus (number of days until next Christmas) " Eve"s
print"Christmas"+" Eve"*(...................................).days
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 80 bytes
```
require'date'
t=Date.today
puts'Christmas'+' Eve'*(Date.new((t+6).year,12,25)-t)
```
[Try it online!](https://tio.run/##KypNqvz/vyi1sDSzKFU9JbEkVZ2rxNYFSOuV5KckVnIVlJYUqztnFGUWl@QmFqtrqyu4lqWqa2mAleSllmtolGibaepVpiYW6Rga6RiZauqWaP7/DwA "Ruby ‚Äì Try It Online")
Thanks to tsh for [his idea](https://codegolf.stackexchange.com/questions/178003/encode-the-date-in-christmas-eve-format/178022#comment429060_178010)
[Answer]
# PHP, 61 bytes
```
Christmas<?for($t=time();date(md,$t+=86400)-1226;)echo" Eve";
```
Run with `-n` or [try it online](http://sandbox.onlinephpfunctions.com/code/dd5e887fbcab9459a1752689ee2d6950a35e1d1c).
[Answer]
# JavaScript, ~~135~~ ~~131~~ ~~121~~ ~~92~~ 88 bytes
My first (na√Øve) solution (**135b**):
```
t=new Date();n=new Date();n.setMonth(11);n.setDate(25);'Christmas'+' Eve'.repeat((n>=t?n-t:(n.setFullYear(n.getFullYear()+1)-t))/864e5)
```
It sets 2 dates: now and Xmas of this year. If the latter hasn't passed yet, it just diffs them, if it has passed, diffs to next year's Xmas. Uses either diffs for the number of repeats.
(Trying to) Think Outside the Box (**131b**):
```
i=0;f=_=>{t=new Date();if(t.getMonth()!=11||t.getDate()!=25){i++;setTimeout(f,864e5)}else{alert('Christmas'+' Eve'.repeat(i))}};f()
```
The challange specifies WHICH output is required when running the program on a given day, but doesn't specify WHEN to return it...
This will just 'sleep' for a day, increment a counter by 1, and repeat till it's Xmas in order to give the output.
Since JavaScript doesn't guarantee the 'sleep' time, the actual result might be off.
It is also ugly for using the `alert` function, which means wer'e actually not dealing with pure JavaScript, but with browser APIs as well (we can use `console.log` at the cost of 6 extra bytes).
A better approach (**121b**):
```
t=new Date();i=0;while(t.getMonth()!=11||t.getDate()!=25){t=new Date(t.valueOf()+864e5);i++};'Christmas'+' Eve'.repeat(i)
```
Starting from today, increment the date by a day until it's Xmas, then use that loop's counter for the number of repeats required.
Improving (including going through a minifier and using 12Me21's trick to shave extra 5b) (**92b**):
```
for(s='Christmas',t=new Date;t.getMonth()/t.getDate()-.44;)t=new Date(t*1+864e5),s+=' Eve';s
```
Final touches (**88b**):
```
for(s='Christmas',t=new Date;t.getMonth()/(d=t.getDate())-.44;t.setDate(d+1))s+=' Eve';s
```
* For all of the above, REPL is assumed.
* See Vadim's submission - much better than mine!
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~68~~ ~~65~~ 61 bytes
*Golfed 4 bytes thanks to [Nahuel Fouilleul](https://codegolf.stackexchange.com/users/70745/nahuel-fouilleul)* by using ```` command substitution and `eval` in place of sed `e` and `xargs`
```
echo Christmas `eval date\ -d{0..366}day\;|sed /c.25/Q\;cEve`
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1/BOaMos7gkN7FYISG1LDFHISWxJDVGQTel2kBPz9jMrDYlsTLGuqY4NUVBP1nPyFQ/MMY62bUsNeH/fwA "Bash ‚Äì Try It Online")
Inside the ```` [command substitution](https://www.gnu.org/software/bash/manual/html_node/Command-Substitution.html#Command-Substitution), we have
`eval` run the following string as shell commands
* `date\ -d{0..366}day\;` under [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html#Brace-Expansion) of `{0..366}`, this results in the string `date -d0day; date -d1day; date -d2day; ... date -d366day;`, each command in this string computing the date between 0 and 366 days from present resulting in output of the format `Wed Dec 26 18:22:33 UTC 2018`, with each in its own line
`|sed` upon which, call the following sed commands
* `/c.25/Q` if the regex `/c.25/` is matched, `Q`uit without printing
* `\;cEve` otherwise change the line to `Eve`
All the required number of `Eve`s are produced each on its own line. This output is captured in ````, and is subject to [word splitting](https://www.gnu.org/software/bash/manual/html_node/Word-Splitting.html#Word-Splitting) where words are split on newlines. Each word is fed as an argument to `echo`.
`echo Christmas `...``
Each argument to `echo` is printed by being separated by spaces, resulting in the desired output.
[Answer]
# Bash +GNU date, ~~72~~, ~~73~~, 67 bytes
```
for((d=7;`date +%-j -d$d\day`-1;d++));{ x+=\ Eve;};echo Christmas$x
```
* one byte saved replacing `!=` with `-`
* another removing extra space
* fix -3 bytes `d=0`, because `date -dday` is date+1 and doesn't work on 25/12
* 6 bytes saved thanks to Toby Speight using %-j format to avoid 0 padding (and octal conversion) and shorter than %d%m compared to 2512
[Try it online](https://tio.run/##S0oszvj/Py2/SEMjxdbcOiElsSRVQVtVN0tBN0UlJSYlsTJB19A6RVtbU9O6WqFC2zZGwbUs1brWOjU5I1/BOaMos7gkN7FYpeL/fwA)
[Answer]
# VBA (Excel), 108 bytes
Copy in a blank module. Prints to the Immediate window:
```
Sub X:s="Christmas":d=Now:For t=1 To (DateSerial(Year(d+6),12,25)-d):s=s &" Eve":Next:Debug.Print s:End Sub
```
**Note:** Using `:` instead of line breaks saves two bytes per line.
Notice that the VBA editor will insert additional spaces between keywords, operators, etc... and parenthesis after the Sub definition, but if you copy and paste this code it will work (I couldn't get rid of that space before the `&`).
Not bad for VBA (for once).
[Answer]
# Python 2, 128 bytes / Python 3, 130 bytes
of course, two less bytes with Python 2
```
from datetime import date as D
T=D.today()
Y=T.year
a=(D(Y,12,25)-T).days
print("Christmas"+" Eve"*[a,(D(Y+1,12,25)-T).days][a<0])
```
[Answer]
## Python 3, 106 Bytes
```
from datetime import*
d=date.today()
print("Christmas"+" Eve"*(date((d+timedelta(6)).year,12,25)-d).days)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 157 bytes
I thought that I would be able to avoid including `time.h` but that just gave segment faults.
```
#include <time.h>
*t,u;f(){time(&u);t=localtime(&u);t[5]+=t[4]>10&t[3]>25;t[4]=11;t[3]=25;u-=mktime(t);printf("Christmas");for(u/=86400;u++;printf(" Eve"));}
```
[Try it online!](https://tio.run/##Tc5BDoIwEIXhvadoMCGtiIKCMRnLxngKwgILSGMLBqZsCGfH4kJdfn/mJSP8hxDzWjZCmaIklx4LJe@7OvlrKHVpy2qDWwMVZeMSqGsYIFetyNXPaZx5HNMoS8LAxfSYJYcYFvMwhMXc2vhcPz8bZPDqZIMVda51J3vUee8wqNqOmj0/n6IgAON53yNyG0qHMZhma6Jz2dChlQUjI7F/AZnmNw "C (gcc) ‚Äì Try It Online")
[Answer]
# [Groovy](http://groovy-lang.org/), 66 bytes
```
d=[]as Date
print'Christmas'+' Eve'*(new Date((d+6).year,11,25)-d)
```
[Try it online!](https://tio.run/##Sy/Kzy@r/P8/xTY6NrFYwSWxJJWroCgzr0TdOaMos7gkN7FYXVtdwbUsVV1LIy@1HKxCQyNF20xTrzI1sUjH0FDHyFRTN0Xz/38A "Groovy ‚Äì Try It Online")
Courtesy of @ASCII-only
[Answer]
# [Scala](http://www.scala-lang.org/), ~~116~~ 113 bytes
```
var d=new java.util.Date
print("Christmas")
while(!(""+d).contains("c 25")){print(" Eve");d.setDate(d.getDate+1)}
```
[Try it online!](https://tio.run/##XY7LasMwEEX3/gplVhIG5UFbCsGL0qQ7r9IfUKVJM0GSjTRxWoK/3Y1w6aKzmoE7555sjTdT93FGy6IV@MUYXRYvfX@bBpOEayJexdkMRl@YvN4ZxqpPFFnC6ylR5mAyqOp6Io9yIQFqp7TtIhuKWYIVm0dQ6vb7IvYDgto6nZELSjr9OW/1Wo3TWC2XpZWa1XYm/rXzXU0fKPQeS/ytS8HcgW3rHCh9nM/Dd2YM2l5SwsjvFLAl7ynXpBYNrDfF5Z8K1c3z08OqzDj9AA "Scala ‚Äì Try It Online")
Where `c 25` is short for `Dec 25`.
[Answer]
# JavaScript, ~~86~~ 77 bytes
Using REPL it would be
```
for(c='Christmas',d=new Date;!/c 25/.test(d);d=new Date(+d+864e5))c+=' Eve';c
```
Kudos to ASCII-only for **-9** bytes
[Answer]
# [Lua](https://www.lua.org), 137 118 bytes.
118 bytes
```
t,d,month,day=os.time,os.date,1,-6year=d"%Y"+(d"%D">"12/25"and 2or 1)print("Christmas",d" Eve":rep(d("%j",t(_G)-t())))
```
137 bytes (previous)
```
t,d=os.time,os.date a=d"*t"a.year,a.month,a.day=a.year+(d"%m%d">"1225"and 1 or 0),12,25 print("Christmas",("Eve "):rep((t(a)-t())/86400))
```
It's worth noting that it doesn't work in LuaJIT (syntax error)
[Answer]
# [Julia 1.0](http://julialang.org/), 91 bytes
```
using Dates
t=today()
print(:Christmas," Eve"^~-(tonext(==((12,26))‚àòmonthday,t)-t).value)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/v7Q4My9dwSWxJLWYq8S2JD8lsVJDk6ugKDOvRMPKOaMos7gkN7FYR0nBtSxVKa5OV6MkPy@1okTD1lZDw9BIx8hMU/NRx4zc/LySDKBWnRJN3RJNvbLEnNJUzf//AQ "Julia 1.0 ‚Äì Try It Online")
* -1 byte thanks to @MarcMush: Substitute `1>0` for `true`
* -5 bytes thanks to @MarcMush: Substitute `_.value` for `Dates.value(_)`
* -1 byte thanks to @amelies: print symbol `:Christmas` rather than string `"Christmas"`
* -1 byte thanks to @MarcMush: compose functions with `‚àò`
* -7 bytes thanks to @MarcMush: use Boxing Day as the end date and subtract one in order to eliminate the `same=true` parameter
[Answer]
# MySQL, 102 bytes
pretty much the same as [Neil¬¥s T-SQL answer](https://codegolf.stackexchange.com/a/178031/55735). There seems to be no shorter way in SQL.
```
select concat("Christmas",repeat(" Eve",datediff(concat(year(now()+interval 6 day),"-12-25"),now())));
```
[Try it online](https://sqltest.net/#403120).
[Answer]
# MATLAB, 91 bytes
```
n=datetime
x=datetime(year(n+6),12,25)
s='Christmas'
while days(x-n)>=1 n=n+1 s=[s,' Eve'] end
```
# MATLAB Non-looper, 100 bytes
```
x=datenum(datetime(floor((now+5)/365.2425),12,25))
d=x-now
['Christmas' repmat(' Eve',1,min(d(d>=0)))]
```
[Answer]
# [Scala](http://www.scala-lang.org/), 123 bytes
Thanks to ASCII-only's work.
```
print("Christmas")
var d=new java.util.Date
while(d.getMonth()<11||d.getDate()!=25){print(" Eve");d.setDate(d.getDate()+1)}
```
[Try it online!](https://tio.run/##TYyxCsIwFAD3fkXMlCAEIjhpB6mO/Yhn8zApNQ3JMxXafntE6eB6d1zqYIAy3nvsiLXgPMM3oTeJXUKYS4jOk@CNjS7RExKXVYbITO1xYj1kUC9yg7oCYTVZN6Aw6oHUjp6skGetl@UHvoGQu/pwlPP2ZLeMXJ6MSpv@C/darmUtHw "Scala ‚Äì Try It Online")
# [Scala](http://www.scala-lang.org/) + [Joda-Time](https://github.com/JodaOrg/joda-time), 140 bytes
```
import org.joda.time._
var s="Christmas"
var d=DateTime.now
while(d!=d.withDate(d.year().get(),12,25)){d=d.plusDays(1);s+=" Eve"};println(s)
```
Does not run in TIO since it requires Joda-Time library.
[Answer]
# [q](https://code.kx.com/home), 53 bytes
```
"Christmas",(4*(not 12 25~`mm`dd$.z.d+)(1+)/0)#" Eve"
```
# k, 50 bytes
```
"Christmas",(4*(~12 25~`mm`dd$.z.d+)(1+)/0)#" Eve"
```
Increment counter while the date is not Dec 25th, then take that number of copies of " Eve" and append to "Christmas".
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~93~~ ~~89~~ ~~87~~ 81 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'≈í√é≈æf≈æe¬´≈Ω9√ö.S¬©DŒò≈æg+—Ç‚Ä∞0KŒ∏4√ñUi390≈æe-X+√´¬Æ_i0√´‚Ä¢Œò√èF‚Ä¢¬∫11¬£¬Æ¬™‚ÇÇ+ƒÅ2QX*+13≈æf-.¬£O≈æe-]F√∞'¬ªÀÜ}J‚Ñ¢
```
[Try it online](https://tio.run/##AYMAfP9vc2FiaWX//yfFksOOxb5mxb5lwqvFvTnDmi5TwqlEzpjFvmcr0YLigLAwS864NMOWVWkzOTDFvmUtWCvDq8KuX2kww6vigKLOmMOPRuKAosK6MTHCo8KuwqrigoIrxIEyUVgqKzEzxb5mLS7Co0/FvmUtXUbDsCfCu8uGfUrihKL//w) or [Try it online with an emulated self-specified date of 'today'](https://tio.run/##yy9OTMpM/a8UUFqikKiQkliSqpCZp1CSkaqQll@Um1iikJKi6@urWwkECiX5CqXFqQqJxQqJOSWpRXmJJZllqQrFJYlFJZl56RDNGqm5pTlARgqEm5@moF6Sn5JYqa5ppRTDxaVkZKpraKRrZGBooaSue2hh2H/1o5MO90UeWhHkdXSv5eFZesGHVrqcmxF5bof2xaZHDRsMvM/tMDk8LTTT2NIg8sJe3Qjtw6sPrYvPNDi8@lHDonMzDve7AelDuwwNDy0@tO7QqkdNTdpHGo0CI7S0DY0jD7cW6@odWuwP0hnrdniD@qHdp9tqvR61LPr/HwA).
**Old ~~93~~ ~~89~~ 87 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) approach that loops over the days one by one:**
```
≈æe≈æf≈æg)V'≈í√é[Y¬®J≈Ω9√öQ#Y`—Ç‚Ä∞0KŒ∏4√ñUD<i\28X+√´<7%√â31Œ±}‚ÄπiY¬¨>0√´Y1¬æ«ùD√ÖsD12‚Äπi>1√´\1D«ù¬§>2}}«ùV√∞'¬ªÀÜ}J‚Ñ¢
```
[Try it online](https://tio.run/##AYMAfP9vc2FiaWX//8W@ZcW@ZsW@ZylWJ8WSw45bWcKoSsW9OcOaUSNZYNGC4oCwMEvOuDTDllVEPGlcMjhYK8OrPDclw4kzMc6xfeKAuWlZwqw@MMOrWTHCvsedRMOFc0QxMuKAuWk@McOrXDFEx53CpD4yfX3HnVbDsCfCu8uGfUrihKL//w) or [Try it online with an emulated self-specified date of 'today'](https://tio.run/##yy9OTMpM/a8UUFqikKiQkliSqpCZp1CSkaqQll@Um1iikJKi6@urWwkECiX5CqXFqQqJxQqJOSWpRXmJJZllqQrFJYlFJZl56RDNGqm5pTlARgqEm5@moF6Sn5JYqa5ppRTDxaVkZKpraKRrZGBooaSue2jh/zD1o5MO90VHHlrhdXSv5eFZgcqRCRebHjVsMPA@t8Pk8LRQF5vMGCOLCO3Dq23MVQ93Ghue21j7qGFnZuShNXYGh1dHGh7ad3yuy@HWYhdDI5C4neHh1TGGLsfnHlpiZ1Rbe3xu2OEN6od2n26r9XrUsuj/fwA).
**Explanation:**
05AB1E doesn't have any builtins for dates, except for receiving the current year/month/day/hours/minutes/seconds/microseconds, so most bytes are used for manual calculations.
```
'≈í√é           '# Push dictionary string "christmas"
≈æf≈æe¬´          # Append the current month and current day together
        .S     # Compare it with
     ≈Ω9√ö       # Compressed integer 1225
               # (1 if >1225; 0 if ==1225; -1 if <1225)
          ¬©    # Store this comparison in variable `¬Æ` (without popping)
D              # Duplicate it
 Œò             # Check if it's equal to 1 (1 if 1; 0 if 0 or -1)
  ≈æf+          # Add the current year to it
     —Ç‚Ä∞0KŒ∏4√ñ   # Check if this is a leap year:
     —Ç‚Ä∞        #  Divmod it by 100
       0K      #  Remove the 0s
         Œ∏     #  Only leave the last item
          4√ñ   #  Check if it's divisible by 4
            U  # Pop and store this is_leap_year in variable `X`
i              # If the comparison is 1:
 390≈æe-        #  Push 390 minus the current day
               #  (390 is 31 for days in December and 259 for days of Christmas Day)
 X+            #  Add the is_leap_year check from variable `X`
√´¬Æ_i           # Else if the comparison is 0:
    0          #  Push 0
√´              # Else (the comparison is -1):
 ‚Ä¢Œò√èF‚Ä¢         #  Push compressed integer 5254545
      ¬∫        #  Mirror it to 52545455454525
       11¬£     #  Only leave the first 11: 52545455454
          ¬Æ¬™   #  Convert it to a list of digits, and append the -1:
               #   [5,2,5,4,5,4,5,5,4,5,4,-1]
            ‚ÇÇ+ #  Add 26 to each: [31,28,31,30,31,30,31,31,30,31,30,25]
 ƒÅ             #  Push a list in the range [1,length] (without popping):
               #   [1,2,3,4,5,6,7,8,9,10,11,12]
  2Q           #  Check which is equal to 2: [0,1,0,0,0,0,0,0,0,0,0,0]
    X*         #  Multiply each by the is_leap_year check of variable `X`
      +        #  Add the values at the same positions in the lists together
 13≈æf-         #  Push 13 minus the current month
      .¬£       #  Only leave that many items from the end of the list
        O      #  Sum them together
 ≈æe-           #  Subtract the current day
]              # Close the if-else statements
 F             # Loop that many times:
  √∞            #  Push a space character " "
  '¬ªÀÜ         '#  Push dictionary string "eve"
 }J            # After the loop: join the entire stack together
   ‚Ñ¢           # Titlecase each word
               # (after which the result is output implicitly)
```
---
```
≈æe≈æf≈æg)V   # Get the current [day,month,year] and save it in variable `Y`
'≈í√é       '# Push dictionary string "christmas"
[          # Start an infinite loop:
 Y¬®J       #  Remove the year, and join the month and day together
       Q   #  Check if this is equal to
    ≈Ω9√ö    #  Compressed integer 1225
        #  #   If this is truthy (thus it's December 25th): stop the infinite loop
 Y`—Ç‚Ä∞0KŒ∏4√ñUD<i\28X+√´<7%√â31Œ±}‚ÄπiY¬¨>0√´Y1¬æ«ùD√ÖsD12‚Äπi>1√´\1D«ù¬§>2}}«ùV
           #  Go to the next day, and set `Y` to it
 √∞         #  Push a space " "
 '¬ªÀÜ      '#  Push dictionary string "eve"
}J         # After the infinite loop: join the entire stack together
  ‚Ñ¢        # Titlecase each word
           # (after which the result is output implicitly)
```
[See this 05AB1E answer of mine](https://codegolf.stackexchange.com/a/177019/52210) to understand the `is_leap_year` check.
[See this 05AB1E answer of mine](https://codegolf.stackexchange.com/a/173126/52210) to understand how we go to the next day (with the second longer approach).
[See this 05AB1E tip of mine (sections *How to use the dictionary?* and *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `'¬ªÀÜ` is `"eve"`; `'≈í√é` is `"christmas"`; `≈Ω9√ö` is `1225`; and `‚Ä¢Œò√èF‚Ä¢` is `5254545`.
[Answer]
# [Go](https://go.dev), 178 bytes
```
import(."time";."strings")
func f()string{n:=Now()
y:=n.Year()
if n.Month()>11&&n.Day()>25{y++}
return"Christmas"+Repeat(" Eve",int(Date(y,12,25,0,0,0,0,UTC).Sub(n).Hours())/24)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VZDBSsNAEIbveYphwDJL0zUJVqSyBWkrXizS1oPgZS277aLZlM1GCaUv4Ct4CYIv4M1H8W1Mk1xkDvPzD_x8_3x8brLqZyfXz3KjIJXGBibdZc5z1KnHr8LrwcXvd-sRR29ShZccc--M3eTIAl3YNWhirbO3IzHP3ogF5UhY_qCkq7XRYPltZv2W2DiOez3Lp7KsdTLcl_3-IXDKF87iZOtM7lOZY3-hdkp6Qpi9KgyN9TSVXlEZxkmYDMOom_vVhPFl8USW8ZuscDkxdpqcsUNH_t7gHXsRg32gM5dKDyMBmETR-SCKB1GCwV2N7l8soRAClqurxQpqVZdrDprwJH-0IMZw3BhC05BfN2HUZrLw-AT2Pwpm8yl0UR1RVbX7Dw)
And a variant that takes a `Time` as input, 175 bytes:
```
import(."time";."strings")
func f(n Time)string{y:=n.Year()
if n.Month()>11&&n.Day()>25{y++}
return"Christmas"+Repeat(" Eve",int(Date(y,12,25,0,0,0,0,UTC).Sub(n).Hours())/24)}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=fVFNSwMxEMVrfkUIWBKaxm3ailS2IG3Fi0Xa9SAqEku2XXSzJZlVlqW_xEsRPHv2p-ivcT96sUiZwwzzmHlv3ry9L5LN10rNn9RC41hFBkXxKrEgSBgD-UghbJ18f9Y9KghEsSangjiwkVk4wlCYmjkOqcFBAbG6n2d934gbrSxlKAqxEZeJgSVlg3a70TBipLKilr08azbXyGpIrSHDpY0cxMqR5lSvtAJK8PhFEx4ZoCMFmma8LbnscW8b18GQiVn6SA0TF0lqHWXsSHbZupb9c9CtxJVXUYZzBNqBw30f396XYnM0SV4p46haLj3Z-Wf_Ltrdi3b2osc76BqFiY0VlJKI9LzjltdueZKgq8JEeDaU-L6PZ8HZNMBFVZqdWPzAqwGrTPGx-qS8nggpOXR3BvsDXGbCMYjzioHWRIwXnwLGCuY_FHg8GeEtxda8zabOvw)
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 141 bytes
```
var g=DateTime.Now;Write("Christmas"+string.Concat(Enumerable.Repeat(" Eve",(new DateTime(g.Year+(g.Day>25&g.Month>11?1:0),12,25)-g).Days)));
```
[Try it online!](https://tio.run/##NYyxCsIwFAB/JWSQhKbBFLpYWoe2ow4iiOOzPNKASSSJLX59rIPTwXHcFMspmpwXCES3AyS8Govy7NfmFkxCRvs5mJgsRFrEFIzTsvdugsRG97YY4PFEecEXboaScUEqmMOV/FdMyztCKDYO8Omqeqflybs0d0od1WHPhapEVfNS818QOedNzl8 "C# (Visual C# Interactive Compiler) ‚Äì Try It Online")
]