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.

Défi

Facile

Créez un calculateur de délais de projet qui utilise l'arithmétique temporelle pour déterminer les étapes et les échéances d'un projet. Ce défi mettra à l'épreuve votre capacité à utiliser les méthodes Add et Sub sur des objets time.Time afin de calculer des dates futures et les différences de temps entre les é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 divisant au niveau des deux-points afin d'extraire les valeurs de l'année, du mois, du jour, de l'heure et des minutes
Convertir ces valeurs de chaîne en entiers et créer une heure de début de projet à l'aide de time.Date (utiliser time.UTC pour l'emplacement, 0 pour les secondes et les nanosecondes)
Analyser la deuxième entrée en la divisant au niveau des virgules pour obtenir les entrées individuelles des tâches
Pour chaque entrée de tâche, la diviser au niveau des deux-points afin d'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 à l'aide des 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 le calendrier du projet :
- "=== PROJECT TIMELINE ==="
- "Project start: [start_time_object]"
- "Project end: [final_task_end_time]"
- "Total project duration: [total_duration_object]" (calculée à 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 intervalles :
- "=== TASK TRANSITIONS ==="
- Pour chaque paire de tâches consécutives : "[first_task_name] to [second_task_name]: [time_difference_object]" (devrait être égal à 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 diviser les chaînes d'entrée, le package strconv pour convertir les chaînes en entiers et le package fmt pour produire une 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 un time.Duration représentant la différence entre deux heures. Ce défi montre comment construire un calendrier complet de projet à l'aide d'opérations d'arithmétique temporelle.

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
}