Desde los milisegundos de la hora, minutos, segundos y milisegundos

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 Kommentare

  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

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea