Arithmétique temporelle

Fait partie de la section Logique & Flux du Journey GO de Coddy — leçon 63 sur 68.

Maintenant que vous comprenez les objets time.Time et les valeurs time.Duration, vous pouvez effectuer des opérations arithmétiques pour calculer des moments passés ou futurs. Go fournit deux méthodes essentielles pour l'arithmétique temporelle : Add et Sub.

La méthode Add prend un time.Duration et retourne un nouveau time.Time qui représente l'heure d'origine plus la durée :

now := time.Now()
tomorrow := now.Add(24 * time.Hour)
fmt.Println(tomorrow)

La méthode Sub fonctionne de deux manières. Lorsque vous soustrayez un time.Time d'un autre, elle renvoie un time.Duration représentant la différence entre les deux :

start := time.Now()
end := start.Add(2 * time.Hour)
difference := end.Sub(start) // Returns 2h0m0s

Ces méthodes facilitent le calcul des échéances, la mesure du temps écoulé ou la planification d'événements futurs. L'objet time.Time original reste inchangé - les deux méthodes retournent de nouvelles valeurs, conformément à la préférence de Go pour les opérations immuables.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Défi

Facile

Créez un calculateur de date limite de projet qui utilise l'arithmétique temporelle pour déterminer les jalons et les échéances d'un projet. Ce défi testera votre capacité à utiliser les méthodes Add et Sub sur des objets time.Time pour calculer des dates futures et des différences de temps entre des événements.

Vous recevrez deux entrées :

Une chaîne contenant les informations de début du projet au format "year:month:day:hour:minute" (par exemple, "2024:1:15:9:0")
Une chaîne contenant les durées des tâches au format "task1:duration_value:duration_unit,task2:duration_value:duration_unit" (par exemple, "Planning:5:Day,Development:3:Week,Testing:10:Day")

Votre tâche consiste à :

Analyser la première entrée en la découpant selon les deux-points pour extraire les valeurs de l'année, du mois, du jour, de l'heure et de la minute
Convertir ces valeurs de chaîne en entiers et créer une heure de début de projet en utilisant time.Date (utilisez time.UTC pour la localisation, 0 pour les secondes et les nanosecondes)
Analyser la deuxième entrée en la découpant selon les virgules pour obtenir les entrées de tâches individuelles
Pour chaque entrée de tâche, découper selon les deux-points pour extraire le nom de la tâche, la valeur de la durée et l'unité de durée
Convertir les valeurs de durée en entiers et créer des objets time.Duration en utilisant les constantes appropriées :
- Pour "Day" : multiplier par 24 * time.Hour
- Pour "Week" : multiplier par 7 * 24 * time.Hour
- Pour "Hour" : multiplier par time.Hour
Afficher l'en-tête de l'application : "=== PROJECT DEADLINE CALCULATOR ==="
Afficher le début du projet : "Project start time: [start_time_object]"
Calculer les échéances des tâches en ajoutant la durée de chaque tâche à l'heure de fin de la tâche précédente (la première tâche commence à l'heure de début du projet) :
Pour chaque tâche, afficher :
- "Task: [task_name]"
- " Duration: [duration_object]"
- " Start: [task_start_time]"
- " End: [task_end_time]" (calculé à l'aide de la méthode Add)
Calculer et afficher la chronologie du projet :
- "=== PROJECT TIMELINE ==="
- "Project start: [start_time_object]"
- "Project end: [final_task_end_time]"
- "Total project duration: [total_duration_object]" (calculé à l'aide de la méthode Sub entre la fin et le début du projet)
Afficher l'analyse des tâches :
- "=== TASK ANALYSIS ==="
- "Number of tasks: [number_of_tasks]"
- "Longest task: [longest_task_name] ([longest_duration_object])"
- "Shortest task: [shortest_task_name] ([shortest_duration_object])"
Calculer le temps entre les tâches consécutives et afficher les écarts :
- "=== TASK TRANSITIONS ==="
- Pour chaque paire de tâches consécutives : "[first_task_name] to [second_task_name]: [time_difference_object]" (devrait être 0 puisque les tâches sont consécutives)
Afficher les statistiques du projet :
- "=== PROJECT STATISTICS ==="
- "Total working days: [total_duration_in_hours_divided_by_24]"
- "Total working hours: [total_duration_in_hours]"
- "Project spans [number_of_calendar_days] calendar days"
Afficher le message de fin : "Project timeline calculation completed successfully"

Utilisez le package time pour les opérations temporelles, le package strings pour découper les chaînes d'entrée, le package strconv pour convertir les chaînes en entiers, et le package fmt pour la sortie formatée. N'oubliez pas que la méthode Add renvoie un nouvel objet time.Time représentant l'heure d'origine plus la durée, et que la méthode Sub renvoie une time.Duration représentant la différence entre deux heures. Ce défi démontre comment construire une chronologie de projet complète en utilisant des opérations d'arithmétique temporelle.

Aide-mémoire

Go fournit deux méthodes essentielles pour l'arithmétique temporelle : Add et Sub.

La méthode Add prend un time.Duration et retourne un nouveau time.Time :

now := time.Now()
tomorrow := now.Add(24 * time.Hour)

La méthode Sub soustrait un time.Time d'un autre et retourne un time.Duration :

start := time.Now()
end := start.Add(2 * time.Hour)
difference := end.Sub(start) // Retourne 2h0m0s

Les deux méthodes retournent de nouvelles valeurs sans modifier l'objet time.Time original.

Essayez vous-même

package main

import (
	"fmt"
	"strconv"
	"strings"
	"time"
)

func main() {
	// Lire l'entrée
	var startInfo string
	var taskInfo string
	fmt.Scanln(&startInfo)
	fmt.Scanln(&taskInfo)
	
	// Analyser les informations sur l'heure de début
	startParts := strings.Split(startInfo, ":")
	year, _ := strconv.Atoi(startParts[0])
	month, _ := strconv.Atoi(startParts[1])
	day, _ := strconv.Atoi(startParts[2])
	hour, _ := strconv.Atoi(startParts[3])
	minute, _ := strconv.Atoi(startParts[4])
	
	// Créer l'heure de début du projet
	startTime := time.Date(year, time.Month(month), day, hour, minute, 0, 0, time.UTC)
	
	// Analyser les informations sur les tâches
	taskEntries := strings.Split(taskInfo, ",")
	
	// TODO : Écrivez votre code ci-dessous
	// - Traiter chaque entrée de tâche pour extraire le nom, la valeur de la durée et l'unité
	// - Créer des objets de durée pour chaque tâche
	// - Calculer les heures de début et de fin des tâches
	// - Trouver les tâches les plus longues et les plus courtes
	// - Calculer les statistiques du projet
	// - Afficher toutes les sections de sortie requises
	
	// La sortie sera générée par votre implémentation ci-dessus
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.