Zeitarithmetik

Teil des Abschnitts Logik & Ablauf der GO-Journey von Coddy. Lektion 63 von 68.

Da Sie nun time.Time-Objekte und time.Duration-Werte verstehen, können Sie arithmetische Operationen durchführen, um vergangene oder zukünftige Zeiten zu berechnen. Go bietet zwei wesentliche Methoden für die Zeitarithmetik: Add und Sub.

Die Add-Methode nimmt eine time.Duration entgegen und gibt ein neues time.Time zurück, das die ursprüngliche Zeit plus die Dauer darstellt:

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

Die Sub-Methode funktioniert auf zwei Arten. Wenn Sie eine time.Time von einer anderen subtrahieren, gibt sie eine time.Duration zurück, die die Differenz zwischen ihnen darstellt:

start := time.Now()
end := start.Add(2 * time.Hour)
difference := end.Sub(start) // Gibt 2h0m0s zurück

Diese Methoden machen es einfach, Fristen zu berechnen, verstrichene Zeit zu messen oder zukünftige Ereignisse zu planen. Das ursprüngliche time.Time-Objekt bleibt unverändert – beide Methoden geben neue Werte zurück, was der Vorliebe von Go für unveränderliche Operationen entspricht.

Aufgabe

Einfach

Erstelle einen Projektfrist-Rechner, der Zeitberechnungen verwendet, um Projektmeilensteine und Fristen zu bestimmen. Diese Herausforderung testet deine Fähigkeit, die Methoden Add und Sub für time.Time-Objekte zu verwenden, um zukünftige Daten und Zeitunterschiede zwischen Ereignissen zu berechnen.

Du erhältst zwei Eingaben:

Eine Zeichenfolge mit Informationen zum Projektstart im Format "year:month:day:hour:minute" (z. B. "2024:1:15:9:0")
Eine Zeichenfolge mit Aufgabendauern im Format "task1:duration_value:duration_unit,task2:duration_value:duration_unit" (z. B. "Planning:5:Day,Development:3:Week,Testing:10:Day")

Deine Aufgabe ist es:

Die erste Eingabe durch Aufteilen an Doppelpunkten zu verarbeiten, um Werte für Jahr, Monat, Tag, Stunde und Minute zu extrahieren
Diese Zeichenfolgenwerte in Ganzzahlen umzuwandeln und mithilfe von time.Date eine Projektstartzeit zu erstellen (verwende time.UTC als Ort sowie 0 für Sekunden und Nanosekunden)
Die zweite Eingabe durch Aufteilen an Kommas zu verarbeiten, um einzelne Aufgabeneinträge zu erhalten
Für jeden Aufgabeneintrag an Doppelpunkten aufzuteilen, um Aufgabennamen, Dauerwert und Zeiteinheit zu extrahieren
Dauerwerte in Ganzzahlen umzuwandeln und mithilfe geeigneter Konstanten time.Duration-Objekte zu erstellen:
- Für "Day": mit 24 * time.Hour multiplizieren
- Für "Week": mit 7 * 24 * time.Hour multiplizieren
- Für "Hour": mit time.Hour multiplizieren
Den Anwendungskopf "=== PROJECT DEADLINE CALCULATOR ===" auszugeben
Den Projektstart "Project start time: [start_time_object]" auszugeben
Aufgabenfristen zu berechnen, indem jede Aufgabendauer zur Endzeit der vorherigen Aufgabe addiert wird (die erste Aufgabe beginnt zur Projektstartzeit):
Für jede Aufgabe Folgendes auszugeben:
- "Task: [task_name]"
- " Duration: [duration_object]"
- " Start: [task_start_time]"
- " End: [task_end_time]" (berechnet mithilfe der Methode Add)
Die Projektzeitachse zu berechnen und auszugeben:
- "=== PROJECT TIMELINE ==="
- "Project start: [start_time_object]"
- "Project end: [final_task_end_time]"
- "Total project duration: [total_duration_object]" (berechnet mithilfe der Methode Sub zwischen Projektende und -beginn)
Die Aufgabenanalyse auszugeben:
- "=== TASK ANALYSIS ==="
- "Number of tasks: [number_of_tasks]"
- "Longest task: [longest_task_name] ([longest_duration_object])"
- "Shortest task: [shortest_task_name] ([shortest_duration_object])"
Die Zeit zwischen aufeinanderfolgenden Aufgaben zu berechnen und Lücken auszugeben:
- "=== TASK TRANSITIONS ==="
- Für jedes Paar aufeinanderfolgender Aufgaben: "[first_task_name] to [second_task_name]: [time_difference_object]" (sollte 0 sein, da die Aufgaben aufeinanderfolgen)
Die Projektstatistiken auszugeben:
- "=== 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"
Die Abschlussnachricht auszugeben: "Project timeline calculation completed successfully"

Verwende das Paket time für Zeitoperationen, das Paket strings, um Eingabezeichenfolgen aufzuteilen, das Paket strconv, um Zeichenfolgen in Ganzzahlen umzuwandeln, und das Paket fmt für formatierte Ausgaben. Denke daran, dass die Methode Add ein neues time.Time-Objekt zurückgibt, das die ursprüngliche Zeit plus die Dauer darstellt, und dass die Methode Sub ein time.Duration-Objekt zurückgibt, das die Differenz zwischen zwei Zeiten darstellt. Diese Herausforderung zeigt, wie man mithilfe von Zeitberechnungen eine vollständige Projektzeitachse erstellt.

Probier es selbst

package main

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

func main() {
	// Eingabe lesen
	var startInfo string
	var taskInfo string
	fmt.Scanln(&startInfo)
	fmt.Scanln(&taskInfo)
	
	// Startzeit-Informationen parsen
	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])
	
	// Projektstartzeit erstellen
	startTime := time.Date(year, time.Month(month), day, hour, minute, 0, 0, time.UTC)
	
	// Aufgabeninformationen parsen
	taskEntries := strings.Split(taskInfo, ",")
	
	// TODO: Schreiben Sie Ihren Code unten
	// - Verarbeiten Sie jeden Aufgabeneintrag, um Name, Dauerwert und Einheit zu extrahieren
	// - Erstellen Sie Dauer-Objekte für jede Aufgabe
	// - Berechnen Sie Start- und Endzeiten der Aufgaben
	// - Finden Sie die längsten und kürzesten Aufgaben
	// - Projektstatistiken berechnen
	// - Alle erforderlichen Ausgabeabschnitte anzeigen
	
	// Die Ausgabe wird durch Ihre obige Implementierung generiert
}