Calculer les minutes jusqu'à une heure précise? (C)

Question

Quel est le moyen le plus simple de calculer le nombre de minutes jusqu'à 21 heures (aujourd'hui ou demain)?

Étudie mktime() mais semblait un tracas pour obtenir le jour et le mois, traitant de tout cela.

Answer 1

Calculez simplement le delta à 21h aujourd'hui. Si c'est négatif, ajoutez 24hrs pour obtenir le delta à demain 21pm.

#include <stdio.h> 
#include <time.h> 

int main(int argc, char* argv[]) { 
    struct tm* tm; 
    time_t ts=time(NULL); 
    if(tm=localtime(&ts)) { 
      long int delta; 
      tm->tm_hour = 21; 
      tm->tm_min = 0; 
      tm->tm_sec = 0; 
      delta = mktime(tm) - ts; 
      if(delta<0) { 
        delta+=24*60*60; 
      } 
      printf("%d minutes til (next)9pm\n",delta/60); 
    } 
    return 0; 
} 

Answer 2

Cela vous donnera les minutes jusqu'à 21 heures .:

time_t currenttime; 
time_t ninePM; 
struct tm * timeinfo; 
int minutesUntilNine; 

// Fill currenttime + convert to struct tm 
time (&currenttime); 
timeinfo = localtime (&rawtime); 

// Check for after 9pm... 
if (timeinfo->tm_hour >= 21) // Are we after 9pm? 
    timeinfo->tm_day++; // increment our day 

// Set timeinfo to the time you want... 
timeinfo->tm_sec = 0; 
timeinfo->tm_min = 0; 
timeinfo->tm_hour = 21; // 9pm 
ninePM = mktime(timeinfo); 

minutesUntilNine = (ninePM - currenttime)/60; 

Answer 3

Une façon simple est de calculer le nombre d'heures et minutes (étant donné que le temps est maintenant, en plus du fait qu'il ya des 24 heures par jour), et multipliez le nombre d'heures par 60 pour obtenir un nombre de minutes. Alternativement, au lieu d'utiliser une horloge de 24 heures pour exprimer l'heure, utilisez une horloge de 1440 minutes: il est facile de soustraire une heure d'une autre, pour obtenir un décalage horaire.

Answer 4

Ici, il est (sortie en quelques secondes ...)

#include <stdio.h> 
#include <time.h> 

int main(void) 
{ 
    double dt = 0.0f; 
    time_t ti = time(NULL); 
    time_t tf; 
    struct tm *pt_actual = localtime(&ti); 

    struct tm t_actual = *pt_actual; 
    struct tm t_target = *pt_actual; 

    t_target.tm_hour = 21; // 09:00 pm 
    t_target.tm_min = 0; 

    tf = mktime(&t_target); 

    dt = difftime(tf, ti); 
    if (dt < 0) 
    dt += (24*60*60); // if negative, just consider **next** 9pm target, add a day 

    printf("difftime = %f seconds\n", dt); 
    return 0; 
} 

Answer 5

demandant la façon la plus simple Le gars. Toutes vos manières sont inutilement complexes. Il suffit d'utiliser l'arithmétique modulaire:

#include <stdio.h> 
#include <time.h> 

#define TARGET_TIME 21*60 // 9:00 PM, in format HH * 60 + MM 

int main(int argc, char* argv[]) 
{ 
    struct tm* tm; 
    time_t ts = time(NULL); 
    int minutes_until_9pm; 
    tm = localtime(&ts); 
    minutes_until_9pm = 24*60 - (tm->tm_min + tm->tm_hour * 60 + TARGET_TIME)%(24*60); 

    //alternatively, the following is slightly faster 
    //minutes_until_9pm = 24*60 - (tm->tm_min + tm->tm_hour * 60 + TARGET_TIME) + (tm->tm_min+tm->tm_hour*60+TARGET_TIME>24*60?24*60:0); 

    printf("%d minutes til (next)9pm\n", minutes_until_9pm); 
    return 0; 
} 

Si vous connaissez votre fuseau horaire, tout devient encore plus simple:

#include <stdio.h> 
#include <time.h> 

#define TARGET_TIME 21*60 // 9:00 PM, in format HH * 60 + MM 
#define TIMEZONE (-6) // This is CST; replace with your own timezone 

int main(int argc, char* argv[]) 
{ 
    int minutes_until_9pm = 24*60 - (time(NULL)/60 + TARGET_TIME + (24+TIMEZONE)*60)%(24*60); 
    printf("%d minutes til (next)9pm\n", minutes_until_9pm); 
    return 0; 
} 

Qu'est-ce qui se passe ici est que, modulo un jour, nous obtenons nombre de minutes depuis minuit. Ensuite, nous ajoutons 21:00 pour obtenir le nombre de minutes depuis 21:00. Ensuite, nous soustrayons cela de 24 heures pour obtenir le nombre de minutes jusqu'au 21 heures suivantes.

Si vous avez besoin d'une plus grande précision (par exemple arrondi au nombre de minutes le plus proche, plutôt que de simplement nombre de minutes), il suffit de soustraire (tm->tm_sec>=30?0:1) de minutes_until_9pm, ou remplacer time(NULL)/60 avec (time(NULL)+30)/60, respectivement.

Answer 6

Version C99:

#include <math.h> 
#include <stdio.h> 
#include <time.h> 

int main(void) 
{ 
    struct tm now = *localtime(&(time_t){ time(NULL) }); 
    struct tm then = now; 
    then.tm_hour = 21; 
    then.tm_min = 0; 
    then.tm_sec = 0; 
    int dt = ((int)round(
     difftime(mktime(&then), mktime(&now))/60) + 24 * 60) % (24 * 60); 
    printf("time till 9pm: %i minutes\n", dt); 
} 

Answer 7

Plus profond, si moins utile, la réponse est qu'il n'y a pas de réponse simple.

Comment savez-vous même qu'aujourd'hui aura un 21h? OK, bien sûr, je suis sûr que tous les fuseaux horaires qui existent n'excèdent jamais 21h00, mais ils passent des heures au milieu de la nuit une fois par an.

Les calendriers sont une catastrophe de complexité. Il faut se méfier.