[Question]
  [
**The Challenge**
Output a list of years that starts with the current year and ends 120 years ago. The birth year of every living human would be included in this list.
**Details**
The list should be in descending order.
Every built-in function to manipulate arrays and/or lists is allowed.
Shortest code in bytes wins.
When run this year `2016`, the output would be
`2016, 2015, ..., 1897, 1896`
When run next year `2017`, the output would be
`2017, 2016, ..., 1898, 1897`
Etc.
**Update**
* Some have asked about the format of the list. As most have guessed, it doesn't matter. Insert any separator between the numbers. Intuitively most inserted a comma or space or both, newline or output an array.
* Quasi superhumans like [Jeanne Calment](https://en.wikipedia.org/wiki/Jeanne_Calment) are an exception to the rule stated in my question.
  
[Answer]
## Pyke, 6 bytes
```
wC7m-
```
[Try it here!](http://pyke.catbus.co.uk/?code=w%C2%99C7m-)
```
w     - 121
   m- - for i in range(^):
 C7   -  current_year-i
```
(After `w`, the codepoint for 153 is present but it isn't printable)
[Answer]
# Pyth, ~~11~~ ~~9~~ 8 bytes
```
-L.d3C\y
```
Works by mapping over the range `[0...120]` and subtracting every number from the current year. The range is built implicitly by using `121` as the map argument. To avoid a separating whitespace between `.d3` and `121` we get this number by converting `y` to it's codepoint.  
Thanks to @FryAmTheEggman for coming up with this approach!
[Try it here!](http://pyth.herokuapp.com/?code=-L.d3C%5Cy&debug=0)
***Old 9-byte solution:***
```
_>121S.d3
```
[Try it here!](http://pyth.herokuapp.com/?code=_%3E121S.d3&debug=0)
Builds the range `[1...<current year>]` and only takes the last 121 elements of it.
[Answer]
# R, 34 bytes
```
(format(Sys.Date(),"%Y"):0)[1:121]
```
See [here](http://www.r-fiddle.org/#/fiddle?id=oVuj9wYz&version=1) on an online interpreter.
**Edit** Could be reduced to 33 bytes by using `substr`.
```
(substr(Sys.Date(),1,4):0)[1:121]
```
but technically this solution will only work until the 9999-12-31.
[Answer]
# [AngularJS](https://angularjs.org/) + [Lodash](https://lodash.com/), 274 bytes
```
angular.module('x',[]).controller('x',['$scope',function(x){x.x=_.range(9,new Date().getFullYear()+1).slice(-121).reverse()}])
```
```
<script src=//goo.gl/M5LvGe></script><script src=//goo.gl/opljJl></script><select ng-app=x ng-controller=x multiple><option ng-repeat="x in x">{{x}}
```
Output
[![enter image description here](https://i.stack.imgur.com/JXRPu.png)](https://i.stack.imgur.com/JXRPu.png)
[Answer]
# BASH + coreutils, ~~35~~ 33 bytes
```
x=`date +%Y`;seq $x -1 $((x-120))
```
[Answer]
# CJam, ~~14~~ ~~12~~ 11 bytes
*Saved 2 bytes thanks to Sp3000 and 1 byte thanks to Martin Ender*
```
et0=121,f-p
```
[Try it online!](http://cjam.aditsu.net/#code=et0%3D%20%20%20%20%20%20%20%20%20e%23%20Push%20the%20current%20year%0A%20%20%20%20121%2C%20%20%20%20%20e%23%20Push%20the%20range%200%2C%201%2C%20...%2C%20120%0A%20%20%20%20%20%20%20%20f-%20%20%20e%23%20For%20each%20item%20in%20the%20range%2C%20subtract%20it%20from%20current%20year%0A%20%20%20%20%20%20%20%20%20%20p%20%20e%23%20Print%20the%20array)
**Explanation**
```
et0=         e# Push the current year
    121,     e# Push the range 0, 1, ..., 120
        f-   e# For each item in the range, subtract it from current year
          p  e# Print the array
```
[Answer]
# HP50g RPL, 97 bytes
```
120 'S' STO DATE ->STR 6 9 SUB OBJ-> 'Y' STO {} S WHILE 0 >= REPEAT Y S - + 'S' DECR END REVLIST
```
Ungolfed:
```
120
'span' STO     @ Store the span of years to cover.
DATE           @ Get the date as number 11.082016. 
→STR           @ Convert to string "11.082016".
               @ (Number format must allow all these decimal places.)
6 9 SUB        @ "11.082016" Substring for the year.
               @       ^  ^
               @  123456789
OBJ→           @ Convert string to number.
'year' STO     @ Store as the year to start at.
{} span        @ Start empty list to collect the years.
               @ Leave loop counter on the stack.
WHILE 0 ≥      @ Loop until the counter goes negative.
REPEAT
  year span -  @ E.g. on first iteration: 2016 - 120 = 1896.
  +            @ Append the year to the list on the stack.
  'span' DECR  @ Decrement loop counter and leave on stack.
END
REVLIST        @ Put list in reverse chronological order.
```
Showing a list of 2016 down to 1896:
[![2016 to 1896](https://i.stack.imgur.com/IGhgJ.png)](https://i.stack.imgur.com/IGhgJ.png)
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~8~~ 7 bytes
Code:
```
žg120Ý-
```
Explanation:
```
žg         # Get the current year.
  120Ý     # Create the list [0, 1, ..., 119, 120].
      -    # Substract, which leaves [year - 0, year - 1, ..., year - 120].
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=xb5nMTIww50t&input=).
[Answer]
# PowerShell, 26 24 bytes
@TimmyD improved version:
```
0..120|%{(date).Year-$_}
```
Was:
```
($d=(date).year)..($d-120)
```
where `date` runs `Get-Date`
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), ~~11~~ 10 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319)
```
120↑⌽⍳⊃⎕ts
```
`120↑` take 120 elements
`⌽` of the reversed
`⍳` indices until
`⊃` the first element of
`⎕TS` TimeStamp in the format [YYYY, M, D, h, m, s, t]
[TryAPL online!](http://tryapl.org/?a=120%u2191%u233D%u2373%u2283%u2395ts&run)
---
Old version:
```
(⊃⎕TS)-⍳120
```
`⊃⎕TS` first element of [YYYY, M, D, h, m, s, t]
`-` minus
`⍳120` [0, 1, 2, ..., 118, 119]
Requires `⎕IO←0`, which is default on many systems.
[TryAPL online!](http://tryapl.org/?a=%u2395IO%u21900%20%u22C4%20%28%u2283%u2395TS%29-%u2373120&run)
[Answer]
# [Vitsy](http://github.com/VTCAKAVSMoACE/Vitsy) + \*sh ~~+ JavaScript~~, ~~33~~ ~~26~~ ~~21~~ 18 bytes
Vitsy doesn't have native time/date retrieval, so I had to use shell and eval for this one.
Thanks to @Caleb for helping me shear off another 3 bytes!
```
'Y%+ etad',Dca*-HZ
'Y%+ etad'               Push the string 'date +"%Y"' to the stack.
          ,              Execute through shell. 
           Dca*-         Dupe n, push n - 120.
                H        Pop x, y, push range(x, y) to the stack.
                 Z       Output all stack as characters.
```
You can't try this one online, because it uses both shell AND eval.
Output is as character codes.
[Answer]
**Mathematica/Wolfram Language, 28 bytes** 
```
Date[][[1]]-#&/@Range[0,120]
```
[Answer]
## R, ~~47~~ 39 bytes
```
as.double(substr(Sys.Date(),1,4))-0:120
```
If only someone invented a UTF-8 implementation of R with conveniently abbreviated frequently used system functions...
UPD: shaved off 7 (!) bytes owing to [plannapus](https://codegolf.stackexchange.com/users/6741/plannapus), who suggested subrtacting a `0:120` vector rather than counting from `a` to `(a-120)` and 1 byte grâce à [user5957401](https://codegolf.stackexchange.com/users/58162/user5957401), who noticed that `double` would work as well as `numeric`. Old version:
```
a=as.numeric(format(Sys.Date(),"%Y"));a:(a-120)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 10 bytes
```
1&Z'0:120-
```
[**Try it online!**](http://matl.tryitonline.net/#code=MSZaJzA6MTIwLQ&input=)
```
1&Z'      % Push first component of "clock" vector, which is year
0:120     % Literal vector [0, 1, 2, ..., 120]
-         % Subtract element-wise. Implicitly display
```
[Answer]
# 05AB1E, 9 bytes
`121FžgN-=`
[Try online](https://tio.run/nexus/05ab1e#@29oZOh2dF@6n67t//8A)
[Answer]
# php, 73 66 58 42 bytes
```
<?=implode(', ',range($j=date(Y),$j-120));
```
## Output:
> 
> 2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006,
>  2005, 2004, 2003, 2002, 2001, 2000, 1999, 1998, 1997, 1996, 1995,
>  1994, 1993, 1992, 1991, 1990, 1989, 1988, 1987, 1986, 1985, 1984,
>  1983, 1982, 1981, 1980, 1979, 1978, 1977, 1976, 1975, 1974, 1973,
>  1972, 1971, 1970, 1969, 1968, 1967, 1966, 1965, 1964, 1963, 1962,
>  1961, 1960, 1959, 1958, 1957, 1956, 1955, 1954, 1953, 1952, 1951,
>  1950, 1949, 1948, 1947, 1946, 1945, 1944, 1943, 1942, 1941, 1940,
>  1939, 1938, 1937, 1936, 1935, 1934, 1933, 1932, 1931, 1930, 1929,
>  1928, 1927, 1926, 1925, 1924, 1923, 1922, 1921, 1920, 1919, 1918,
>  1917, 1916, 1915, 1914, 1913, 1912, 1911, 1910, 1909, 1908, 1907,
>  1906, 1905, 1904, 1903, 1902, 1901, 1900, 1899, 1898, 1897, 1896
> 
> 
> 
If we don't need to separate with `,`, then 58 57 41 bytes:
```
<?=implode(' ',range($j=date(Y),$j-120));
```
Thanks to insertusernamehere for saving 16 bytes
[Answer]
## Python 2, ~~64 62~~ 54 bytes
```
import time
n=time.gmtime()[0]
exec'print n;n-=1;'*121
```
@KarlKastor thanks for 8 bytes!
[Answer]
# PostgreSQL, 57 bytes
Who needs a `FROM` :-). Probably shouldn't work, but it does, try it at [sqlfiddle](http://sqlfiddle.com/#!15/9eecb7db59d16c80417c72d1e1f4fbf1/10620/0) 
```
select date_part('y',current_date)-generate_series(0,120)
```
[Answer]
# Bash on OS X, 23
```
jot 121 `date +%Y` - -1
```
This will also work on Linux if you have BSD `jot` installed (e.g. `sudo apt-get install athena-jot`.
[Answer]
## Python 2, 62 bytes
```
import time
for n in range(121):print int(time.ctime()[-4:])-n
```
And at 64 bytes:
```
for n in range(121):print int(__import__("time").ctime()[-4:])-n
```
[Answer]
# Oracle SQL 11.2, 111 bytes
```
SELECT LISTAGG(TO_CHAR(SYSDATE,'YYYY')-LEVEL+1,', ')WITHIN GROUP(ORDER BY LEVEL)FROM DUAL CONNECT BY LEVEL<122;
```
[Answer]
# Processing, ~~51~~ ~~42~~ 41 bytes
```
for(int i=0;i<121;)print(year()-i+++" ");
```
# Ungolfed
```
for(int i = 0; i < 121;)
    print(year() - i++ + " ");
```
Processing is just a wrapper for Java if you didn't know, and takes most of the boilerplate away, so the obvious solution is also super short compared to a Java version. Also opens a window for drawing graphics, but having that doesn't appear to disqualify me :)
[Answer]
# MATLAB, 18 bytes
Assuming the output format doesn't matter (aside form descending order), the following program prints the last 121 years starting with the current one.
```
year(date)-(0:120)
```
It requires MATLAB version r2014a or higher. Earlier versions didn't include the `year` function.
[Answer]
## JavaScript, ~~55~~ ~~52~~ ~~50~~ 49 bytes
```
for(a=d=s=Date().substr(11,4);d-->s-120;)a+=" "+d
```
+9 bytes to `alert` the data (not necessary if you run this in a console).
```
for(a=d=s=Date().substr(11,4);d-->s-120;)a+=" "+d;alert(a)
```
-4 bytes if the delimiter isn't necessary.
```
for(a=d=s=Date().substr(11,4);d-->s-120;)a+=d
```
```
for (a = d = s = Date().substr(11, 4); d --> s - 120; )
    a += " " + d;
console.log(a);
```
[Answer]
## C, ~~87~~ ~~85~~ ~~76~~ ~~74~~ 65 bytes
```
main(int i,char**v){for(i=0;i<121;printf("%d,",atoi(v[1])-i++));}
```
Ungolfed:
```
main(int i,char**v){
    for(i = 0; i < 121; printf("%d,", atoi(v[1])-i++));
}
```
My first code golf - Any pointers would be well received. Would be nice if I could cut out the argc/argv junk, but I'm not *that* skilled a C programmer. Improvements welcome.
**EDIT**: The current year is obtained from the commandline - specifically by a group of automated, well trained drinking birds.
**EDIT 2**: 85 bytes Thanks to Easterly Irk (removed spaces around arg function parameters)
**EDIT 3**: 76 bytes Thanks to anatolyg for pointing out the obvious (removed verbose argc/argv param names)
**EDIT 4**: 74 bytes Thanks to Yay295 (char\*\*v, changed year delimiter)
**EDIT 5**: 65 bytes thanks to Yay295 and matt (re-used the variable i, removed variable x, changed while to for loop, updated printf to include atoi() read and i++)
[Answer]
# **JavaScript, ~~60~~ ~~53~~ 48 Bytes**
```
f=x=>x>Date().split` `[3]-121&&(alert(x),f(x-1))
```
I used a recursive solution.
[Answer]
# [Go](https://go.dev), 71 bytes
```
import."time"
func f(){for t,i:=Now().Year(),0;i<120;i++{println(t-i)}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BmoLE5OzE9FSF3MTMvKWlJWm6FjfdM3ML8otK9JRKMnNTlbjSSvOSFdI0NKvT8osUSnQyrWz98ss1NPUiUxOLNDR1DKwzbQyNgKS2dnVBUWZeSU6eRolupmZtLcS4TWD9IOOBRnABzeGCSixYAKEB)
Prints to STDERR.
[Answer]
## Perl, 33 bytes
```
say+(gmtime)[5]-$_+1900for 0..120
```
Run with `-M5.010` or `-E` : 
```
perl -E 'say+(gmtime)[5]-$_+1900for 0..120'
```
[Answer]
# k, 27 bytes
Output as specified
```
1@", "/:$(`year$.z.d)-!121;
```
Example:
```
k)1@", "/:$(`year$.z.d)-!121;
2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006, 2005, 2004, 2003, 2002, 2001, 2000, 1999, 1998, 1997, 1996, 1995, 1994, 1993, 1992, 1991, 1990, 1989, 1988, 1987, 1986, 1985, 1984, 1983, 1982, 1981, 1980, 1979, 1978, 1977, 1976, 1975, 1974, 1973, 1972, 1971, 1970, 1969, 1968, 1967, 1966, 1965, 1964, 1963, 1962, 1961, 1960, 1959, 1958, 1957, 1956, 1955, 1954, 1953, 1952, 1951, 1950, 1949, 1948, 1947, 1946, 1945, 1944, 1943, 1942, 1941, 1940, 1939, 1938, 1937, 1936, 1935, 1934, 1933, 1932, 1931, 1930, 1929, 1928, 1927, 1926, 1925, 1924, 1923, 1922, 1921, 1920, 1919, 1918, 1917, 1916, 1915, 1914, 1913, 1912, 1911, 1910, 1909, 1908, 1907, 1906, 1905, 1904, 1903, 1902, 1901, 1900, 1899, 1898, 1897, 1896
```
It can be shortened more by not formatting the output and merely returning the list of integers:
```
(`year$.z.d)-!121
```
[Answer]
# jq, 46 characters
(45 characters code + 1 character command line option)
```
now|strftime("%Y")|tonumber|range(.;.-121;-1)
```
Sample run:
```
bash-4.3$ jq -n 'now|strftime("%Y")|tonumber|range(.;.-121;-1)' | head
2016
2015
2014
2013
2012
2011
2010
2009
2008
2007
```
[On-line test](https://jqplay.org/jq?q=now|strftime(%22%25Y%22)|tonumber|range(.%3b.-121%3b-1)&j=null)
]