Ce que vous devez faire pour gagner ce défi est d'écrire le script "timeago" le plus court qui génère le nombre de décennies, années, semaines, jours, heures, minutes et secondes entre un horodatage Unix donné et l'heure à laquelle le script est exécuté.

Vous devez donner la différence de temps en «termes les plus bas», par exemple 1 weeknon 7 days, 9 yearsnon 0 decades 9 years. Vous devez également utiliser correctement les formes plurielles, par exemple 1 daynon 1 days.

Votre script doit être précis à plus ou moins 1 seconde près (de sorte que la deuxième méthode d'arrondi exacte n'a pas d'importance).

Time Equivalency Table
1 decade = 10 years
1 year = 31536000 seconds (not technically correct but close enough)
1 week = 7 days
1 day = 24 hours
1 hour = 60 minutes
1 minute = 60 seconds

La sortie doit être de la forme

A decade(s) B year(s) C week(s) D day(s) E hour(s) F minute(s) G second(s)

où A...Gsont tous les entiers non négatifs et le sest uniquement là pour les pluriels.

Remarques

• L'horodatage sera toujours un temps du passé. Cela peut être négatif.
• L'entrée et la sortie peuvent être raisonnables: stdin / stdout, entrée de fonction et valeur de retour, etc.
• Vous ne pouvez pas utiliser d'outils qui le font déjà. c'est-à-dire que si votre langue a une timesince(timestamp)fonction intégrée, vous ne pouvez pas utiliser cette fonction.

J'ai énormément modifié cela pour le rendre plus clair dans l'espoir d'apaiser la bataille quelque peu idiote entre les nouveaux utilisateurs avec des questions peu claires et les anciens utilisateurs qui nécessitent la perfection. Ce n'était pas une question terrible (bien que maintenant elle puisse être trop similaire à cela ).

Étant donné que suffisamment de temps s'est écoulé depuis la dernière réponse, je déclare Three If By Whisky avec son implémentation Ruby de 177 octets le gagnant de ce contexte!

Rubis, 184 177

->n{x=Time.now.to_i-n;d=[3650*y=86400,365*y,7*y,y,3600,60,1];(0..6).map{|i|c=x/d[i];(x%=d[i]*c;"#{c} #{%w[decade year week day hour minute second][i]}#{c<2?'':'s'}")if c>0}*' '}

Il n'y a rien de particulièrement intelligent ici, mais je soupçonne que c'est toujours très proche de l'optimal.

Exemple d'exécution

p ->n{x=Time.now.to_i-n;d=[3650*y=86400,365*y,7*y,y,3600,60,1];(0..6).map{|i|c=x/d[i];(x%=d[i]*c;"#{c} #{%w[decade year week day hour minute second][i]}#{c<2?'':'s'}")if c>0}*' '}[0]
"4 decades 4 years 41 weeks 3 days 14 hours 20 minutes 48 seconds"

J, 165

;' '&,@":&.>@((#~([:*&>{."1))@((;:' decades years weeks days hours minutes seconds')(],.([}.~[:-1=])&.>)<"0@(_ 10 52 7 24 60 60&#:)@(-~([:".@}:[:2!:0'date +%s'"_))))

Peut probablement être joué au golf plus. Utilise un appel shell à ce jour pour obtenir l'heure actuelle d'Unix, car l'époque d'Unix n'est pas disponible dans J.

Exemple d'exécution:

;' '&,@":&.>@((#~([:*&>{."1))@((;:' decades years weeks days hours minutes seconds')(],.([}.~[:-1=])&.>)<"0@(_ 10 52 7 24 60 60&#:)@(-~([:".@}:[:2!:0'date +%s'"_)))) 0
4 decades 4 years 41 weeks 3 days 12 hours 54 minutes 1 second

Python - 183

import time;t=int(time.time()-input());d=86400
for f,u in zip((3650*d,365*d,7*d,d,3600,60,1),'decade year week day hour minute second'.split()):
 if t/f:print`t/f`,u+'s'*(t/f>1),;t%=f

Sortie pour un horodatage de 999996400 secondes dans le passé:

3 decades 1 year 37 weeks 46 minutes 39 seconds

JavaScript, 392

t=function(c){i=function(){var a=+new Date/1e3-c,b=document;29>a?b.write("just now"):60>a?b.write((a|0)+" seconds ago"):60<a&&120>a?b.write("1 minute ago"):60>a/60?b.write((a/60|0)+" minutes ago"):60<a/60&&120>a/60?b.write("1 hour ago"):24>a/3600?b.write((a/3600|0)+" hours ago"):24<a/3600&&48>a/3600?b.write("1 day ago"):1<=a/86400&&b.write((a/86400|0)+" days ago")};i();setInterval(i,3e4)};

Aussi le code non minimisé pour les curieux

t = function(timestamp){

i = function() {
var diff = (+new Date/1e3)-(timestamp),
d = document;

    if( (diff) < 29) {

        d.write( 'just now' )
    }
    else if( diff < 60) {

        d.write( ( (diff) |0 ) + ' seconds ago' )
    }
    else if( diff > 60 && diff < 120) {
        d.write(  '1 minute ago' )
    }
    else if( (diff)/60 < 60) {
        d.write( ( (diff)/60 |0 ) + ' minutes ago' )
    }
    else if( (diff)/60 > 60 && (diff)/60 < 120) {
        d.write( '1 hour ago' )
    }
    else if( (diff)/3600 < 24) {
        d.write( ( (diff)/3600 |0 ) + ' hours ago' )
    }
    else if( (diff)/3600 > 24 && (diff)/3600 < 48) {
        d.write( '1 day ago' )
    }
    else if( (diff)/86400 >= 1) {
        d.write( ( (diff)/86400 |0 ) + ' days ago' )
    }
  }

i()

setInterval(i, 3e4)

}

Il se met à jour toutes les 30 secondes et calcule à la fois le singulier et le pluriel.

Pour l'exécuter, utilisez t(unix_timestamp)

Javascript, 287

function p(e,n){return e>2?e+" "+n+"s ":e+" "+n+" "}function t(e){n=new Date/1e3,l=e-n,c=1,m=60,h=60*m,d=24*h,w=7*d,y=365*d,a=10*y,s="",v={a:"Decade",y:"Year",w:"Week",d:"Day",h:"Hour",m:"Minute",c:"Second"};for(i in v)k=v[i],i=window[i],(r=Math.floor(l/i))>0&&(s+=p(r,k)),l%=i;alert(s)}

pour exécuter l'utilisation t(secondsInFuture);

Javascript, 263

i=[315360000,31536000,604800,86400,3600,60,1];s=['decade','year','week','day','hour','minute','second'];function g(d){return p(parseInt((new Date().getTime()-d)/1000), 0);}function p(d,n){k=d-d%i[n];r=k/i[n];return (r>0?r+' '+s[n]+'(s) ':'')+(n<6?p(d-k,n+1):'');}

pour exécuter à partir de la console Javascript, appelez

g(unixTimestamp);