Le défi

Affiche une liste d'années commençant par l'année en cours et se terminant il y a 120 ans. L'année de naissance de chaque être humain vivant serait incluse dans cette liste.

Détails

La liste devrait être dans l'ordre décroissant.

Toute fonction intégrée permettant de manipuler des tableaux et / ou des listes est autorisée.

Le code le plus court en octets gagne.

Quand exécuté cette année, la sortie serait

2016, 2015, ..., 1897, 1896

Lorsqu'il sera exécuté l'année prochaine, le résultat sera

2017, 2016, ..., 1898, 1897

Etc.

Mise à jour

• Certains ont posé des questions sur le format de la liste. Comme la plupart l'ont deviné, cela n'a pas d'importance. Insérez n'importe quel séparateur entre les nombres. Intuitivement, la plupart ont inséré une virgule ou un espace ou les deux, une nouvelle ligne ou un tableau.
• Les quasi-surhumains comme Jeanne Calment sont une exception à la règle énoncée dans ma question.

Pyke, 6 octets

wC7m-

Essayez-le ici!

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

(Après w, le point de code pour 153 est présent mais il n'est pas imprimable)

Pyth, 11 9 8 octets

-L.d3C\y

Fonctionne en mappant sur la plage [0...120]et en soustrayant chaque nombre de l'année en cours. La plage est construite de manière implicite en utilisant 121comme argument map. Pour éviter un espace blanc séparant entre .d3et 121nous obtenons ce nombre en le convertissant yen son code.
Merci à @FryAmTheEggman d'avoir proposé cette approche!

Essayez-le ici!

Ancienne solution à 9 octets:

_>121S.d3

Essayez-le ici!

Construit la plage [1...<current year>]et n'en prend que les 121 derniers éléments.

R, 34 octets

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

Voir ici sur un interprète en ligne.

Modifier Peut être réduit à 33 octets en utilisant substr.

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

mais techniquement, cette solution ne fonctionnera que jusqu'au 9999-12-31.

AngularJS + Lodash , 274 octets

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

Sortie

BASH + coreutils, 35 33 octets

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

CJam, 14 12 11 octets

2 octets sauvés grâce à Sp3000 et 1 octet grâce à Martin Ender

et0=121,f-p

Essayez-le en ligne!

Explication

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 octets

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.

Liste des années 2016 à 1896:

05AB1E , 8 7 octets

Code:

žg120Ý-

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne! .

PowerShell, 26 à 24 octets

@TimmyD version améliorée:

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

Était:

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

où datecourtGet-Date

Dyalog APL , 11 à 10 octets

120↑⌽⍳⊃⎕ts

120↑ prendre 120 éléments

⌽ de l'inverse

⍳ indices jusqu'à

⊃ le premier élément de

⎕TS Horodatage au format [AAAA, M, D, h, m, s, t]

TryAPL en ligne!

Ancienne version:

(⊃⎕TS)-⍳120

⊃⎕TS premier élément de [AAAA, M, D, h, m, s, t]

- moins

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

Requiert ⎕IO←0, qui est la valeur par défaut sur de nombreux systèmes.

TryAPL en ligne!

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

Vitsy n'a pas de récupération native de l'heure et de la date, j'ai donc dû utiliser shell et eval pour celui-ci.

Merci à @Caleb de m'avoir aidé à supprimer 3 octets de plus!

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

Vous ne pouvez pas essayer celui-ci en ligne, car il utilise à la fois shell ET eval.

La sortie est sous forme de codes de caractères.

Mathematica / Wolfram Language, 28 octets

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

R, 47 39 octets

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

Si seulement quelqu'un inventait une implémentation de R de UTF-8 avec des fonctions système fréquemment utilisées, abrégées de manière commode ...

UPD: (!) Rasé 7 octets en raison de plannapus , qui suggéraient subrtacting un 0:120vecteur plutôt que de compter à partir ade (a-120)et 1 octet grace à user5957401 , qui a remarqué que doublecela fonctionnerait aussi bien que numeric. Ancienne version:

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

MATL , 10 octets

1&Z'0:120-

Essayez-le en ligne!

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 octets

121FžgN-=

Essayer en ligne

php, 73 66 58 42 octets

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

Sortie:

2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006, 2006, 2005, 2004, 2003, 2002, 2001, 2000, 1999, 1998, 1997, 1996, 1996, 1995, 1994, 1993, 1992, 1991, 1990, 1989, 1988, 1987, 1986, 1985, 1984, 1983, 1982, 1981, 1980, 1979, 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, 1949, 1949, 1946, 1944, 1944, 1943, 1942, 1941, 1940, 1939, 1938, 1937, 1936, 1935, 1934, 1933, 1932, 1931, 1930, 1929, 1928, 1927, 1926, 1925, 1925, 1924, 1922, 1921, 1920, 1919, 1918, 1919, 1918, 1917, 1916, 1915, 1914, 1913, 1912, 1911, 1910, 1909, 1908, 1907, 1906, 1905, 1904, 1903, 1902, 1901, 1900, 1899, 1898, 1897, 1896

Si nous n'avons pas besoin de séparer avec ,, alors 58 57 41 octets:

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

Merci à insertusernamehere pour la sauvegarde de 16 octets

Python 2, 64 62 54 octets

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

@KarlKastor merci pour 8 octets!

PostgreSQL, 57 octets

Qui a besoin d'un FROM:-). Cela ne devrait probablement pas marcher, mais ça marche, essayez-le à sqlfiddle

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

Bash sur OS X, 23

jot 121 `date +%Y` - -1

Cela fonctionnera également sous Linux si BSD est jotinstallé (par exemple sudo apt-get install athena-jot.

Python 2, 62 octets

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

Et à 64 octets:

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

Oracle SQL 11.2, 111 octets

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

Traitement, 51 42 41 octets

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

Ungolfed

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

Le traitement est juste un wrapper pour Java si vous ne le saviez pas, et enlève la plupart des choses, donc la solution évidente est également très courte comparée à la version Java. Ouvre également une fenêtre pour dessiner des graphiques, mais cela ne semble pas me disqualifier :)

MATLAB, 18 octets

En supposant que le format de sortie n’importe pas (ordre décroissant du formulaire), le programme suivant imprime les 121 dernières années en commençant par celui en cours.

year(date)-(0:120)

Il nécessite MATLAB version r2014a ou supérieure. Les versions précédentes n'incluaient pas la yearfonction.

JavaScript, 55 52 50 49 octets

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

+9 octets aux alertdonnées (non nécessaire si vous l'exécutez dans une console).

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

-4 octets si le délimiteur n'est pas nécessaire.

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 octets

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

Mon premier code de golf - Tous les pointeurs seraient bien reçus. Ce serait bien si je pouvais découper la argc / argv indésirable, mais je ne suis pas que d' un habile programmeur C. Les améliorations sont les bienvenues.

EDIT : L’année en cours est obtenue à partir de la ligne de commande - en particulier par un groupe de voleurs à boire automatisés et bien entraînés.

EDIT 2 : 85 octets grâce à Easterly Irk (espaces supprimés autour des paramètres de la fonction arg)

EDIT 3 : 76 bytes Merci à anatolyg d’avoir signalé l’évident (noms de paramètres argc / argv verbose supprimés)

EDIT 4 : 74 octets Merci à Yay295 (caractère ** v, délimiteur changé d’année)

EDIT 5 : 65 octets avec Yay295 et matt

JavaScript, 60 53 48 octets

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

J'ai utilisé une solution récursive.

Perl, 33 octets

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

Courir avec -M5.010ou -E:

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

k, 27 octets

Sortie comme spécifié

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

Exemple:

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

Il peut être raccourci davantage en ne formatant pas la sortie et en renvoyant simplement la liste des entiers:

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

jq, 46 caractères

(Code de 45 caractères + option de ligne de commande de 1 caractère)

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

Échantillon échantillon:

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

Test en ligne

Vim, 32 29 frappes

Merci à @daniero pour son aide sur la sauvegarde des frappes au clavier et l’ optimisation de la sortie.

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

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

Explication:

"                                          # 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

Format de sortie:

Chaque numéro est sur une ligne séparée, comme ci-dessous.

2016
2015
.
.
.
1898
1897