O desafio

Saída uma lista de anos que começa com o ano atual e termina 120 anos atrás. O ano de nascimento de todo ser humano vivo seria incluído nesta lista.

Detalhes

A lista deve estar em ordem decrescente.

Todas as funções internas para manipular matrizes e / ou listas são permitidas.

O menor código em bytes vence.

Quando executado este ano, a produção seria

2016, 2015, ..., 1897, 1896

Quando executado no próximo ano, a produção será

2017, 2016, ..., 1898, 1897

Etc.

Atualizar

• Alguns perguntaram sobre o formato da lista. Como a maioria adivinhou, isso não importa. Insira qualquer separador entre os números. Intuitivamente, a maioria inseriu uma vírgula ou espaço ou ambos, nova linha ou produz uma matriz.
• Quase sobre-humanos como Jeanne Calment são uma exceção à regra estabelecida na minha pergunta.

Pyke, 6 bytes

wC7m-

Experimente aqui!

w     - 121
   m- - for i in range(^):
 C7   -  current_year-i

(Depois w, o ponto de código para 153 está presente, mas não é imprimível)

Pitão, 11 9 8 bytes

-L.d3C\y

Funciona mapeando sobre o intervalo [0...120]e subtraindo todos os números do ano atual. O intervalo é construído implicitamente usando 121como argumento do mapa. Para evitar um espaço em branco de separação entre .d3e 121obtemos esse número convertendo yem seu ponto de código.
Agradecemos a @FryAmTheEggman por apresentar essa abordagem!

Experimente aqui!

Solução antiga de 9 bytes:

_>121S.d3

Experimente aqui!

Cria o intervalo [1...<current year>]e leva apenas os últimos 121 elementos dele.

R, 34 bytes

(format(Sys.Date(),"%Y"):0)[1:121]

Veja aqui em um intérprete online.

Editar Pode ser reduzido para 33 bytes usando substr.

(substr(Sys.Date(),1,4):0)[1:121]

mas tecnicamente essa solução funcionará apenas até o 9999-12-31.

AngularJS + Lodash , 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}}

Saída

BASH + coreutils, 35 33 bytes

x=`date +%Y`;seq $x -1 $((x-120))

CJam, 14 12 11 bytes

Economizou 2 bytes graças ao Sp3000 e 1 byte graças a Martin Ender

et0=121,f-p

Experimente online!

Explicação

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

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.

Mostrando uma lista de 2016 até 1896:

05AB1E , 8 7 bytes

Código:

žg120Ý-

Explicação:

žg         # Get the current year.
  120Ý     # Create the list [0, 1, ..., 119, 120].
      -    # Substract, which leaves [year - 0, year - 1, ..., year - 120].

Usa a codificação CP-1252 . Experimente online! .

PowerShell, 26 24 bytes

@TimmyD versão melhorada:

0..120|%{(date).Year-$_}

Estava:

($d=(date).year)..($d-120)

onde datecorreGet-Date

Dyalog APL , 11 10 bytes

120↑⌽⍳⊃⎕ts

120↑ pegue 120 elementos

⌽ do reverso

⍳ índices até

⊃ o primeiro elemento de

⎕TS TimeStamp no formato [AAAA, M, D, h, m, s, t]

TryAPL online!

Versão antiga:

(⊃⎕TS)-⍳120

⊃⎕TS primeiro elemento de [AAAA, M, D, h, m, s, t]

- menos

⍳120 [0, 1, 2, ..., 118, 119]

Requer ⎕IO←0, que é padrão em muitos sistemas.

TryAPL online!

Vitsy + * sh + JavaScript , 33 26 21 18 bytes

O Vitsy não possui recuperação de data / hora nativa, então tive que usar shell e avaliação para este.

Obrigado a @Caleb por me ajudar a cortar outros 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.

Você não pode tentar este online, porque ele usa shell e eval.

A saída é como códigos de caracteres.

Linguagem Mathematica / Wolfram, 28 bytes

Date[][[1]]-#&/@Range[0,120]

R, 47 39 bytes

as.double(substr(Sys.Date(),1,4))-0:120

Se apenas alguém inventasse uma implementação UTF-8 de R com funções do sistema frequentemente abreviadas convenientemente ...

UPD: eliminou 7 (!) Bytes devido ao plannapus , que sugeriu a sub-ação de um 0:120vetor em vez de contar de aaté (a-120)1 byte para o usuário5957401 , que notou que isso doubletambém funcionaria numeric. Versão antiga:

a=as.numeric(format(Sys.Date(),"%Y"));a:(a-120)

MATL , 10 bytes

1&Z'0:120-

Experimente online!

1&Z'      % Push first component of "clock" vector, which is year
0:120     % Literal vector [0, 1, 2, ..., 120]
-         % Subtract element-wise. Implicitly display

05AB1E, 9 bytes

121FžgN-=

Experimente on-line

php, 73 66 58 42 bytes

<?=implode(', ',range($j=date(Y),$j-120));

Saída:

2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006, 2005, 2004, 2003, 2002, 2001, 2000, 1999, 1998, 1997, 1996, 1995, 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, 1948, 1947, 1946, 1945, 1944, 1943, 1942, 1941, 1940, 1939, 1938, 1937, 1936, 1935, 1934, 1933, 1932, 1931, 1930, 1929, 1928, 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, 1902, 1901, 1900, 1899, 1898, 1897, 1896

Se não precisarmos nos separar ,, 58 57 41 bytes:

<?=implode(' ',range($j=date(Y),$j-120));

Obrigado a insertusernamehere por salvar 16 bytes

Python 2, 64 62 54 bytes

import time
n=time.gmtime()[0]
exec'print n;n-=1;'*121

@KarlKastor obrigado por 8 bytes!

PostgreSQL, 57 bytes

Quem precisa de FROM:-). Provavelmente não deve funcionar, mas funciona, tente no sqlfiddle

select date_part('y',current_date)-generate_series(0,120)

Bash no OS X, 23

jot 121 `date +%Y` - -1

Isso também irá trabalhar em Linux, se você tem BSD jotinstalada (por exemplo sudo apt-get install athena-jot.

Python 2, 62 bytes

import time
for n in range(121):print int(time.ctime()[-4:])-n

E a 64 bytes:

for n in range(121):print int(__import__("time").ctime()[-4:])-n

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;

Processando, 51 42 41 bytes

for(int i=0;i<121;)print(year()-i+++" ");

Ungolfed

for(int i = 0; i < 121;)
    print(year() - i++ + " ");

O processamento é apenas um invólucro para Java, se você não soubesse, e retira a maior parte do clichê, portanto a solução óbvia também é super curta em comparação com uma versão Java. Também abre uma janela para desenhar gráficos, mas isso não parece me desqualificar :)

MATLAB, 18 bytes

Assumindo que o formato de saída não importa (além da ordem decrescente), o programa a seguir imprime os últimos 121 anos começando com o atual.

year(date)-(0:120)

Requer MATLAB versão r2014a ou superior. As versões anteriores não incluíam a yearfunção.

JavaScript, 55 52 50 49 bytes

for(a=d=s=Date().substr(11,4);d-->s-120;)a+=" "+d

+9 bytes alertnos dados (não é necessário se você o executar em um console).

for(a=d=s=Date().substr(11,4);d-->s-120;)a+=" "+d;alert(a)

-4 bytes se o delimitador não for necessário.

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);

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++));
}

Meu primeiro código de golfe - Qualquer ponteiro seria bem recebido. Seria bom se eu pudesse cortar o argc / argv lixo, mas não tenho que qualificados um programador C. Melhorias são bem-vindas.

EDIT : O ano atual é obtido a partir da linha de comando - especificamente por um grupo de bebedouros automatizados e bem treinados.

EDIT 2 : 85 bytes Graças a Easterly Irk (espaços removidos em torno dos parâmetros de função arg)

EDIT 3 : 76 bytes Agradecimentos a anatolyg por apontar o óbvio (nomes de parâmetros detalhados removidos argc / argv)

EDIT 4 : 74 bytes Graças a Yay295 (char ** v, delimitador de ano alterado)

EDIT 5 : 65 bytes graças a Yay295 e matt (reutilizou a variável i, removeu a variável x, alterou while para for loop, printf atualizado para incluir atoi () read e i ++)

JavaScript, 60 53 48 bytes

f=x=>x>Date().split` `[3]-121&&(alert(x),f(x-1))

Eu usei uma solução recursiva.

Perl, 33 bytes

say+(gmtime)[5]-$_+1900for 0..120

Executar com -M5.010ou -E:

perl -E 'say+(gmtime)[5]-$_+1900for 0..120'

k, 27 bytes

Saída conforme especificado

1@", "/:$(`year$.z.d)-!121;

Exemplo:

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

Ele pode ser encurtado ainda mais, não formatando a saída e retornando apenas a lista de números inteiros:

(`year$.z.d)-!121

jq, 46 caracteres

(Código de 45 caracteres + opção de linha de comando de 1 caractere)

now|strftime("%Y")|tonumber|range(.;.-121;-1)

Exemplo de execução:

bash-4.3$ jq -n 'now|strftime("%Y")|tonumber|range(.;.-121;-1)' | head
2016
2015
2014
2013
2012
2011
2010
2009
2008
2007

Teste on-line

Vim, 32 29 pressionamentos de tecla

Agradecemos a @daniero por alguma ajuda para salvar algumas teclas e tornar a saída um pouco melhor.

"=strftime('%Y')<Enter>pqqYp<Ctrl-x>q118@q

• <Enter> é Enter
• <Ctrl-x>é Ctrl+X

Explicação:

"                                          # Put into the register {
 =strftime('%Y')                           #   This year in YYYY form
                <Enter>                    # }
                       p                   # Paste the register
                        qq                 # Record macro q {
                          Y                #   Yank (copy) the current line
                           p               #   Paste
                            <Ctrl-x>       #   Decrment number at cursor
                                    q      # }
                                     118@q # Do macro q 118 times

Formato de saída:

Cada número está em uma linha separada, como abaixo.

2016
2015
.
.
.
1898
1897