Tengo que ir de milisegundos a una tupla de (horas, minutos, segundos, milisegundos) que representan la misma cantidad de tiempo. E. g.:

10799999ms = 2h 59m 59s 999ms

El siguiente pseudo-código es la única cosa que se me ocurrió:

# The division operator below returns the result as a rounded down integer
function to_tuple(x):
    h = x /(60*60*1000)
    x = x - h*(60*60*1000)
    m = x /(60*1000)
    x = x - m*(60*1000)
    s = x /1000
    x = x - s*1000
    return (h,m,s,x)

Estoy seguro de que debe ser posible hacerlo de forma más inteligente, más elegante y más rápido/más compacto.

  • usted puede utilizar el operador de módulo ( % en C y amigos ) a ligeramente simplificar los cálculos de x ( por ejemplo, x = x % (60*60*1000) )
  • Asegúrese de que usted no tiene esa funcionalidad ya en la biblioteca estándar del lenguaje que usted utiliza.
InformationsquelleAutor Mads Skjern | 2012-06-03

9 Comentarios

  1. 111

    Aquí es cómo iba a hacerlo en Java:

    int seconds = (int) (milliseconds /1000) % 60 ;
    int minutes = (int) ((milliseconds /(1000*60)) % 60);
    int hours   = (int) ((milliseconds /(1000*60*60)) % 24);
    
    • vale la pena utilizar TimeUnit en java para hacer el código más legible.
    • long millis = 12884983; System.out.println(((millis / (1000 * 60)) % 60)); System.out.println(java.util.concurrent.TimeUnit.MILLISECONDS.toMinutes(millis)); de salida: 34 | 214
  2. 7

    Buena pregunta. Sí, se puede hacer esto de manera más eficiente. La CPU puede extraer tanto el cociente y el resto de la razón de dos números enteros en una sola operación. En <stdlib.h>, la función que expone esta CPU operación se llama div(). En su psuedocode, tendría que utilizar algo como esto:

    function to_tuple(x):
        qr = div(x, 1000)
        ms = qr.rem
        qr = div(qr.quot, 60)
        s  = qr.rem
        qr = div(qr.quot, 60)
        m  = qr.rem
        h  = qr.quot
    

    Una menor respuesta eficiente sería utilizar la / y % operadores por separado. Sin embargo, si usted necesita el cociente y el resto, de todos modos, entonces bien podría llamarse el más eficiente div().

  3. 5

    Tal vez puede ser más corto y más elegante. Pero yo lo hice.

    public String getHumanTimeFormatFromMilliseconds(String millisecondS){
        String message = "";
        long milliseconds = Long.valueOf(millisecondS);
        if (milliseconds >= 1000){
            int seconds = (int) (milliseconds /1000) % 60;
            int minutes = (int) ((milliseconds /(1000 * 60)) % 60);
            int hours = (int) ((milliseconds /(1000 * 60 * 60)) % 24);
            int days = (int) (milliseconds /(1000 * 60 * 60 * 24));
            if((days == 0) && (hours != 0)){
                message = String.format("%d hours %d minutes %d seconds ago", hours, minutes, seconds);
            }else if((hours == 0) && (minutes != 0)){
                message = String.format("%d minutes %d seconds ago", minutes, seconds);
            }else if((days == 0) && (hours == 0) && (minutes == 0)){
                message = String.format("%d seconds ago", seconds);
            }else{
                message = String.format("%d days %d hours %d minutes %d seconds ago", days, hours, minutes, seconds);
            }
        } else{
            message = "Less than a second ago.";
        }
        return message;
    }
    
  4. 3

    realmente no eleganter, pero un poco más corto sería

    function to_tuple(x):
       y = 60*60*1000
       h = x/y
       m = (x-(h*y))/(y/60)
       s = (x-(h*y)-(m*(y/60)))/1000
       mi = x-(h*y)-(m*(y/60))-(s*1000)
    
       return (h,m,s,mi)
    
  5. 0
    milliseconds = x
    total = 0
    while (milliseconds >= 1000) {
      milliseconds = (milliseconds - 1000)
      total = total + 1
    }
    hr = 0
    min = 0
    while (total >= 60) {
      total = total - 60
      min = min + 1
      if (min >= 60) hr = hr + 1
      if (min == 60) min = 0
    }
    sec = total
    

    Esto es genial, pero yo lo que este no es problema para usted. Método de trabajo perfecto.

  6. 0
    milliseconds = 12884983  //or x milliseconds
    hr = 0
    min = 0
    sec = 0 
    day = 0
    while (milliseconds >= 1000) {
      milliseconds = (milliseconds - 1000)
      sec = sec + 1
      if (sec >= 60) min = min + 1
      if (sec == 60) sec = 0
      if (min >= 60) hr = hr + 1
      if (min == 60) min = 0
      if (hr >= 24) {
        hr = (hr - 24)
        day = day + 1
      }
    }
    

    Espero que mi corta método le ayudará a

  7. 0
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.TimeUnit;
    
    public class MyTest {
    
        public static void main(String[] args) {
            long seconds = 360000;
    
            long days = TimeUnit.SECONDS.toDays(seconds);
            long hours = TimeUnit.SECONDS.toHours(seconds - TimeUnit.DAYS.toSeconds(days));
    
            System.out.println("days: " + days);
            System.out.println("hours: " + hours);
        }
    }
    
  8. 0

    Arduino (c++) versión basada en Valentinos respuesta

    unsigned long timeNow = 0;
    unsigned long mSecInHour = 3600000;
    unsigned long TimeNow =0;
    int millisecs =0;  
    int seconds = 0;
    byte minutes = 0;
    byte hours = 0;
    
    void setup() {
    Serial.begin(9600);
    Serial.println (""); //because arduino monitor gets confused with line 1
    Serial.println ("hours:minutes:seconds.milliseconds:");
    }
    
    void loop() {
    TimeNow = millis(); 
    hours = TimeNow/mSecInHour;
    minutes = (TimeNow-(hours*mSecInHour))/(mSecInHour/60);
    seconds = (TimeNow-(hours*mSecInHour)-(minutes*(mSecInHour/60)))/1000;
    millisecs = TimeNow-(hours*mSecInHour)-(minutes*(mSecInHour/60))-       (seconds*1000);
    
    Serial.print(hours);  
    Serial.print(":");
    Serial.print(minutes);
    Serial.print(":"); 
    Serial.print(seconds); 
    Serial.print("."); 
    Serial.println(millisecs); 
    }
    
  9. 0

    Sólo otro ejemplo en java:

    long dayLength = 1000 * 60 * 60 * 24;
    long dayMs = System.currentTimeMillis() % dayLength;
    double percentOfDay = (double) dayMs /dayLength;
    int hour = (int) (percentOfDay * 24);
    int minute = (int) (percentOfDay * 24 * 60) % 60;
    int second = (int) (percentOfDay * 24 * 60 * 60) % 60;
    

    una ventaja es que puede simular los días más cortos, si usted ajusta dayLength

Dejar respuesta

Please enter your comment!
Please enter your name here