La sfida

Stampa un elenco di anni che inizia con l'anno in corso e termina 120 anni fa. L'anno di nascita di ogni essere umano vivente sarebbe incluso in questo elenco.

Dettagli

L'elenco dovrebbe essere in ordine decrescente.

È consentita ogni funzione integrata per manipolare matrici e / o elenchi.

Vince il codice più breve in byte.

Se eseguito quest'anno, l'output sarebbe

2016, 2015, ..., 1897, 1896

Quando eseguito il prossimo anno l'output sarebbe

2017, 2016, ..., 1898, 1897

Eccetera.

Aggiornare

• Alcuni hanno chiesto informazioni sul formato dell'elenco. Come molti hanno intuito, non importa. Inserisci un separatore tra i numeri. Intuitivamente la maggior parte ha inserito una virgola o uno spazio o entrambi, newline o output un array.
• Quasi i superumani come Jeanne Calment sono un'eccezione alla regola dichiarata nella mia domanda.

Pyke, 6 byte

wC7m-

Provalo qui!

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

(Dopo w, il punto di codice per 153 è presente ma non è stampabile)

Pyth, 11 9 8 byte

-L.d3C\y

Funziona mappando sull'intervallo [0...120]e sottraendo ogni numero dall'anno corrente. L'intervallo viene creato implicitamente utilizzando 121come argomento della mappa. Per evitare uno spazio bianco di separazione tra .d3e 121otteniamo questo numero convertendolo ynel suo punto di codice.
Grazie a @FryAmTheEggman per aver escogitato questo approccio!

Provalo qui!

Vecchia soluzione a 9 byte:

_>121S.d3

Provalo qui!

Costruisce la gamma [1...<current year>]e ne prende solo gli ultimi 121 elementi.

R, 34 byte

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

Vedi qui su un interprete online.

Modifica Potrebbe essere ridotto a 33 byte utilizzando substr.

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

ma tecnicamente questa soluzione funzionerà solo fino al 9999-12-31.

AngularJS + Lodash , 274 byte

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}}

Produzione

BASH + coreutils, 35 33 byte

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

CJam, 14 12 11 byte

Salvato 2 byte grazie a Sp3000 e 1 byte grazie a Martin Ender

et0=121,f-p

Provalo online!

Spiegazione

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 byte

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.

Mostra un elenco del 2016 fino al 1896:

05AB1E , 8 7 byte

Codice:

žg120Ý-

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

PowerShell, 26 24 byte

@TimmyD versione migliorata:

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

Era:

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

dove datecorreGet-Date

Dyalog APL , 11 10 byte

120↑⌽⍳⊃⎕ts

120↑ prendi 120 elementi

⌽ del rovesciato

⍳ indici fino al

⊃ il primo elemento di

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

ProvaAPL online!

Vecchia versione:

(⊃⎕TS)-⍳120

⊃⎕TS primo elemento di [AAAA, M, D, h, m, s, t]

- meno

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

Richiede ⎕IO←0 , che è predefinito su molti sistemi.

ProvaAPL online!

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

Vitsy non ha il recupero nativo di data / ora, quindi ho dovuto usare shell ed eval per questo.

Grazie a @Caleb per avermi aiutato a eliminare altri 3 byte!

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

Non puoi provarlo online, perché usa sia shell che eval.

L'output è come codici carattere.

Mathematica / Wolfram Language, 28 byte

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

R, 47 39 byte

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

Se solo qualcuno inventasse un'implementazione UTF-8 di R con funzioni di sistema usate frequentemente abbreviate ...

UPD: rasato 7 (!) Byte a causa del plannapus , che ha suggerito di sottrarre un 0:120vettore piuttosto che contare da aa (a-120)e 1 byte con un utente5957401 , che ha notato che doubleavrebbe funzionato bene numeric. Vecchia versione:

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

MATL , 10 byte

1&Z'0:120-

Provalo 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 byte

121FžgN-=

Prova online

php, 73 66 58 42 byte

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

Produzione:

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

Se non abbiamo bisogno di separarci con ,, quindi 58 57 41 byte:

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

Grazie a insertusernamehere per il salvataggio di 16 byte

Python 2, 64 62 54 byte

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

@KarlKastor grazie per 8 byte!

PostgreSQL, 57 byte

Chi ha bisogno di un FROM:-). Probabilmente non dovrebbe funzionare, ma lo fa, provalo su sqlfiddle

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

Bash su OS X, 23

jot 121 `date +%Y` - -1

Funzionerà anche su Linux se hai jotinstallato BSD (es sudo apt-get install athena-jot.

Python 2, 62 byte

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

E a 64 byte:

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

Oracle SQL 11.2, 111 byte

SELECT LISTAGG(TO_CHAR(SYSDATE,'YYYY')-LEVEL+1,', ')WITHIN GROUP(ORDER BY LEVEL)FROM DUAL CONNECT BY LEVEL<122;

Elaborazione, 51 42 41 byte

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

Ungolfed

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

L'elaborazione è solo un wrapper per Java se non lo sapevi, e porta via la maggior parte della piastra di caldaia, quindi la soluzione ovvia è anche super breve rispetto a una versione Java. Apre anche una finestra per il disegno di grafica, ma avere ciò non sembra squalificarmi :)

MATLAB, 18 byte

Supponendo che il formato di output non abbia importanza (a parte l'ordine discendente), il seguente programma stampa gli ultimi 121 anni a partire da quello corrente.

year(date)-(0:120)

Richiede la versione MATLAB r2014a o successiva. Le versioni precedenti non includevano la yearfunzione.

JavaScript, 55 52 50 49 byte

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

+9 byte ai alertdati (non necessario se si esegue questo in una console).

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

-4 byte se il delimitatore non è necessario.

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 byte

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

Il mio primo codice golf - Eventuali indicazioni sarebbero ben accette. Sarebbe bello se potessi tagliare la spazzatura argc / argv, ma io non sono che abile programmatore C. Miglioramenti benvenuti.

EDIT : l'anno in corso è ottenuto dalla riga di comando, in particolare da un gruppo di uccelli potatori automatizzati e ben addestrati.

MODIFICA 2 : 85 byte Grazie a Easterly Irk (rimossi gli spazi attorno ai parametri della funzione arg)

MODIFICA 3 : 76 byte Grazie ad anatolyg per aver sottolineato l'ovvio (rimossi i nomi dei parametri argc / argv dettagliati)

MODIFICA 4 : 74 byte Grazie a Yay295 (carattere ** v, delimitatore anno modificato)

EDIT 5 : 65 byte grazie a Yay295 e matt (riutilizzato la variabile i, rimossa la variabile x, modificata mentre in per il ciclo, aggiornato printf per includere atoi () read e i ++)

JavaScript, 60 53 48 byte

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

Ho usato una soluzione ricorsiva.

Perl, 33 byte

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

Esegui con -M5.010o -E:

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

k, 27 byte

Uscita come specificato

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

Esempio:

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

Può essere abbreviato maggiormente non formattando l'output e semplicemente restituendo l'elenco di numeri interi:

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

jq, 46 caratteri

(Codice 45 caratteri + opzione riga comandi 1 carattere)

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

Esecuzione di esempio:

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

Test online

Vim, 32 29 sequenze di tasti

Grazie a @daniero per l'aiuto nel salvare alcuni tasti e rendere l'output un po 'più ordinato.

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

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

Spiegazione:

"                                          # 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 di output:

Ogni numero è su una riga separata come di seguito.

2016
2015
.
.
.
1898
1897