Format de temps de jeu incrémentiel

Objectif

Les jeux incrémentiels ont souvent un compte à rebours exprimant les jours, les heures, les minutes et les secondes jusqu'à ce qu'une tâche soit terminée. Selon l'espace disponible, ils peuvent être formatés comme:

2d 13h
23h 59m 48s
14m
3h 0m 0s

Le but de ce code golf est d'écrire une fonction ou un programme qui effectue ce formatage.

Contributions

• Le nombre total de secondes.
• Le nombre maximum de segments à sortir.

Production

• Les segments comprennent:
  • 0 semaines
  • 0 jours
  • 0h heures
  • 0m minutes
  • 0 s secondes
• Chaque segment est séparé par un seul espace.
• Les segments affichés doivent être contigus. Par exemple, vous n'afficherez pas les heures et les secondes sans afficher les minutes, même s'il n'y a aucune minute.
• Les valeurs à un chiffre n'ont pas de zéros en tête, bien qu'une valeur de zéro doive être indiquée comme 0.
• Les valeurs sont arrondies vers le bas.
• Le premier segment affiché est la première valeur non nulle.

Cas de test

seconds  segments  output
     0      1      0s
   123      1      2m
   123      2      2m 3s
   123      3      2m 3s
 82815      3      23h 0m 15s
307891      2      3d 13h
307891      4      3d 13h 31m 31s
604800      1      1w
604800      6      1w 0d 0h 0m 0s

Gagnant

La solution de comptage d'octets la plus basse en une semaine gagnera "l'acceptation".

Modifications

• Clarifié quel segment est le premier, comme indiqué dans les exemples.
• Cas de test 4 ajouté selon la demande.

CJam (instantané), 41 38 octets

q~"<<^X^G"{imd\}%W%"wdhms":s.+_{0=}#><S*

Ce qui précède utilise la notation caret, car deux des caractères ne sont pas imprimables.

Merci à @ Sp3000 pour avoir joué au golf sur 2 octets.

Essai

La dernière version stable (0.6.5) a un bogue qui peut provoquer {}#le retour d'entiers au lieu de Longs. Paradoxalement, cela peut être contourné en effectuant un transtypage en entier ( i).

Pour exécuter cela avec du code avec l'interpréteur en ligne, cliquez sur ce permalien ou copiez le code de cette pâte .

Vous pouvez également télécharger et créer le dernier instantané en exécutant les commandes suivantes:

hg clone http://hg.code.sf.net/p/cjam/code cjam-code
cd cjam-code/
ant

Vous pouvez créer le fichier CJam comme ceci:

base64 -d > game-time.cjam <<< cX4iPDwYByJ7aW1kXH0lVyUid2RobXMiOnMuK197MD19Iz48Uyo=

Comment ça fonctionne

q~        e# Read an evaluate the input.
"<<^X^G"  e# Push the string corresponding to the array [60 60 24 7
{         e# For each character:
  i       e#   Replace it by its code point.
  md      e#   Push divisor and residue of the division by that code point.
  \       e#   Swap their order.
}%
W%        e# Reverse the resulting array.
"wdhms":s e# Push ["w" "d" "h" "m" "s"].
.+        e# Perform vectorized concatenation.
_         e# Push a copy.
{0=}#     e# Find the index of the first pair with positive integer.
>         e# Remove the preceding pairs.
<         e# Truncate to the number of pairs specified in the input.
S*        e# Join, separating by spaces.

Java, 197 191 octets

String p(int s,int m){String a[]={s%60+"s",(s/=60)%60+"m",(s/=60)%24+"h",(s/=24)%7+"d",(s/7)+"w"},b="",z="";for(s=5;s>0&&a[--s].charAt(0)=='0';);for(;s>=0&&--m>=0;z=" ")b+=z+a[s--];return b;}

Je viens de remarquer que Java prend en charge la déclaration comme String a[]. Cela m'a permis de tirer la déclaration de bet zdans la même ligne, ce qui m'a évité d'écrire à Stringnouveau.

C, 134 127 110 104 103 103 octets

Nouvelle version:

a,e=5;f(n,x){for(;e;n%=a)a=(int[]){1,60,3600,86400,604800}[--e],x>e?printf("%u%c ",n/a,"smhdw"[e]):0;}

La version précédente:

#define p(a) x>--e?printf("%u%c ",n/a,"smhdw"[e]):0;n%=a;
e=5;f(n,x){p(604800)p(86400)p(3600)p(60)p(1)}

Pyth, 39 43 octets

jd_>vz+V?u?GeGPG+m%~/QddCM"<<"Q)Q]0"smhdw

edit: +4 caractères, car j'ai oublié le 0scas de test.

Cela comprend 2 caractères non imprimables. Obtenez le code réel et essayez-le en ligne: Démonstration

Explication:

                                         z = 1st input line (segments, as string)
                                         Q = 2nd input line (time, as int)
                         "<<.."          string with 4 chars
                       CM                convert to ASCCI-values => [60,60,24,7]
                m                        map each d of ^ to:
                   /Qd                     Q / d 
                  ~                        update Q, but use the old value for
                 %  Q d                    Q mod d
                                         this gives [sec, min, hour, day]
               +               Q         add Q (week)
        u                       )        apply the following expression to G, 
                                         starting with G = [s,m,h,d,w], until
                                         G stops changing:
         ? eG                              if eG != 0:
          G                                  update G with G (stop changing)
                                           else:
             PG                              update G with G[-1]
                                         this gets rid of trailing zeros
      +V                         "smhdw  vectorized add with "smhdw"
   >vz                                   only use the last eval(z) items
  _                                      reverse order
jd                                       join by spaces and print

Python 2.7 - 181 178 174 octets

Ma première tentative de jouer au golf.

def I(s,M):
 z=[0]*5;j=0
 for i in [604800,86400,3600,60,1]:z[j],s=s/i,s%i;j+=1
 l=[z.index(n)for n in z if n][0]
 return" ".join([str(i)+n for n,i in zip('wdhms',z)][l:l+M])

Julia, 158 octets

Je suis sûr que cela pourrait être plus court avec une approche plus intelligente, mais c'est ce que j'ai pour l'instant.

(s,g)->(j=0;p=cell(5,1);for i=[604800,86400,3600,60,1] p[j+=1],s=s÷i,s%i end;z=findfirst(p);z>0?join([string(p[i],"wdhms"[i])for i=z:min(z+g-1,5)]," "):"0s")

Cela crée une fonction sans nom qui accepte deux entiers en entrée et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=(s,g)->....

Non golfé + explication:

function f(s, g)
    # Initialize an array and an index
    p = cell(5, 1)
    j = 0

    # Loop over the number of seconds in a week, day, hour,
    # minute, and second
    for i in [604800, 86400, 3600, 60, 1]
        # Set the jth element in p to be the quotient and s
        # to be the remainder of i into s
        p[j+=1], s = s ÷ i, s % i
    end

    # Get the index of the first nonzero value in p
    z = findfirst(p)

    if z > 0
        # We start the string at the first nonzero value
        # and continue until we hit the desired number of
        # units (z+g-1) or the maximum number of units (5),
        # whichever comes first. The appropriate unit is
        # appended to each value and the values are then
        # joined with a space.
        join([string(p[i], "wdhms"[i]) for i in z:min(z+g-1,5)], " ")
    else
        # If there are no nonzero values in p, we just
        # have 0 seconds
        "0s"
    end
end

Exemples:

julia> f(82815, 6)
"23h 0m 15s"

julia> f(604800, 4)
"1w 0d 0h 0m"

Scala, 147 octets

def p(s:Int,i:Int)=List(s/604800+"w",s/86400%7+"d",s/3600%24+"h",s/60%60+"m",s%60+"s").dropWhile(k=>k.head=='0'&&k.tail!="s").take(i).mkString(" ")

rs , 367 octets

^(\d+)/(_)^^(\1)
(_*) (\d)/\1!\2
_{60}/#
#{60}/@
@{24}/:
:{7}/;
(_+)/(^^\1)s
(#+)/(^^\1)m
(@+)/(^^\1)h
(:+)/(^^\1)d
(;+)/(^^\1)w
([a-z])/\1 
w ((\d+[^\dd])|!)/w 0d \1
d ((\d+[^\dh])|!)/d 0h \1
h ((\d+[^\dm])|!)/h 0m \1
(m|^) ?!/\1 0s!
!(\d+)/!(_)^^(\1)
#
+#(\d+)([a-z]) ?(.*)!(_*)/\1\2 #\3!\4@
#/
(@+)/ (_)^^((^^\1))
!(_+) \1(_*)/!\2
_+ _+/
+\d+[a-z] ?!_/!
 *!/
^$/0s

Démo en direct et tous les cas de test.

Désordre, désordre, désordre ...

Prend environ 3 à 7 secondes pour exécuter les cas de test sur Chrome pour Android. N'utilisez pas le mode débogage, qui peut geler votre navigateur dans ce cas en raison de toute la sortie qui serait imprimée.

C #, 239 237 170 164 octets

Ce n'est pas aussi compact que d'autres solutions, mais je ne peux pas poser ce défi sans m'y attaquer moi-même.

Cette dernière itération a été inspirée par la réponse de ESC .

En retrait pour plus de clarté:

string G(int s,int n){
    int[]x={s%60,(s/=60)%60,(s/=60)%24,(s/=24)%7,s/7};
    for(s=5;x[--s]==0&s>0;);
    var o="";
    while(n-->0&s>=0)
        o+=" "+x[s]+"smhdw"[s--];
    return o.Trim();
}