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.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Aufgabe

Einfach

Erstellen Sie einen Projekt-Deadline-Rechner, der Zeitarithmetik verwendet, um Projektmeilensteine und Fristen zu bestimmen. Diese Herausforderung testet Ihre Fähigkeit, die Methoden Add und Sub auf time.Time-Objekten zu verwenden, um zukünftige Daten und Zeitdifferenzen zwischen Ereignissen zu berechnen.

Sie erhalten zwei Eingaben:

Einen String mit Informationen zum Projektstart im Format "year:month:day:hour:minute" (z. B. "2024:1:15:9:0")
Einen String 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")

Ihre Aufgabe ist es:

Die erste Eingabe zu parsen, indem Sie sie an den Doppelpunkten trennen, um die Werte für Jahr, Monat, Tag, Stunde und Minute zu extrahieren
Diese String-Werte in Ganzzahlen umzuwandeln und eine Projektstartzeit mit time.Date zu erstellen (verwenden Sie time.UTC für den Standort, 0 für Sekunden und Nanosekunden)
Die zweite Eingabe zu parsen, indem Sie sie an den Kommas trennen, um die einzelnen Aufgabeneinträge zu erhalten
Für jeden Aufgabeneintrag an den Doppelpunkten zu trennen, um den Aufgabennamen, den Dauer-Wert und die Dauer-Einheit zu extrahieren
Dauer-Werte in Ganzzahlen umzuwandeln und time.Duration-Objekte unter Verwendung der entsprechenden Konstanten zu erstellen:
- Für "Day": Multiplizieren mit 24 * time.Hour
- Für "Week": Multiplizieren mit 7 * 24 * time.Hour
- Für "Hour": Multiplizieren mit time.Hour
Den Anwendungs-Header anzuzeigen: "=== PROJECT DEADLINE CALCULATOR ==="
Den Projektstart anzuzeigen: "Project start time: [start_time_object]"
Aufgaben-Deadlines zu berechnen, indem jede Aufgabendauer zur Endzeit der vorherigen Aufgabe addiert wird (die erste Aufgabe beginnt zur Projektstartzeit):
Für jede Aufgabe folgendes anzuzeigen:
- "Task: [task_name]"
- " Duration: [duration_object]"
- " Start: [task_start_time]"
- " End: [task_end_time]" (berechnet mit der Methode Add)
Den Projektzeitplan zu berechnen und anzuzeigen:
- "=== PROJECT TIMELINE ==="
- "Project start: [start_time_object]"
- "Project end: [final_task_end_time]"
- "Total project duration: [total_duration_object]" (berechnet mit der Methode Sub zwischen Projektende und -start)
Die Aufgabenanalyse anzuzeigen:
- "=== 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 anzuzeigen:
- "=== TASK TRANSITIONS ==="
- Für jedes Paar aufeinanderfolgender Aufgaben: "[first_task_name] to [second_task_name]: [time_difference_object]" (sollte 0 sein, da die Aufgaben aufeinanderfolgend sind)
Projektstatistiken anzuzeigen:
- "=== 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 Abschlussmeldung anzuzeigen: "Project timeline calculation completed successfully"

Verwenden Sie das Paket time für Zeitoperationen, das Paket strings zum Trennen von Eingabestrings, das Paket strconv zum Umwandeln von Strings in Ganzzahlen und das Paket fmt für die formatierte Ausgabe. Denken Sie daran, dass die Methode Add ein neues time.Time-Objekt zurückgibt, das die ursprüngliche Zeit plus die Dauer darstellt, und die Methode Sub eine time.Duration zurückgibt, die die Differenz zwischen zwei Zeiten darstellt. Diese Herausforderung zeigt, wie man einen vollständigen Projektzeitplan mithilfe von Zeitarithmetik-Operationen erstellt.

Spickzettel

Go bietet zwei wesentliche Methoden für die Zeitberechnung: Add und Sub.

Die Methode Add nimmt eine time.Duration entgegen und gibt ein neues time.Time-Objekt zurück:

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

Die Methode Sub subtrahiert ein time.Time-Objekt von einem anderen und gibt eine time.Duration zurück:

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

Beide Methoden geben neue Werte zurück, ohne das ursprüngliche time.Time-Objekt zu verändern.

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
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.