Einen Bericht erstellen

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

Aufgabe

Einfach

Vervollständige dein Bestandsverwaltungssystem, indem du eine umfassende Berichtsfunktion implementierst, die detaillierte Einblicke in deinen aktuellen Bestand liefert. Diese Herausforderung baut auf allen bisherigen Funktionen auf und ergänzt die Möglichkeit, formatierte Berichte mit Statistiken, Kategorisierung und Analysen zu erstellen.

Du erhältst zwei Eingaben:

Eine Zeichenfolge mit vorhandenen Bestandsdaten im Format "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" (z. B. "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Eine Zeichenfolge mit der Berichtskonfiguration im Format "report_type,threshold_value", wobei report_type "full", "low_stock" oder "high_value" sein kann und threshold_value eine Zahl ist (z. B. "low_stock,10")

Deine Aufgabe ist:

Verwende dieselbe Product-Struktur aus den vorherigen Lektionen mit den Feldern Price (float64) und Quantity (int)
Analysiere die erste Eingabe, indem du sie an Kommas trennst, um die einzelnen vorhandenen Produkteinträge zu erhalten
Trenne jeden vorhandenen Produkteintrag an den Doppelpunkten, um Produktname, Preis und Menge zu erhalten
Wandle die Preiszeichenfolge in float64 und die Mengenzeichenfolge in int um
Erstelle und fülle die Map inventory mit den vorhandenen Produktdaten
Erstelle eine Funktion namens generateReport, die die Bestands-Map, den Berichtstyp und den Schwellenwert als Parameter übernimmt
Analysiere die zweite Eingabe, indem du sie an Kommas trennst, um Berichtstyp und Schwellenwert zu erhalten
Wandle die Schwellenwertzeichenfolge in float64 um
Gib die Berichtskopfzeile abhängig vom Berichtstyp aus:
- Für "full": "=== FULL INVENTORY REPORT ==="
- Für "low_stock": "=== LOW STOCK REPORT ==="
- Für "high_value": "=== HIGH VALUE REPORT ==="
Gib allgemeine Bestandsstatistiken aus:
- "Total Products: [total_number_of_products]"
- "Total Items in Stock: [sum_of_all_quantities]"
- "Total Inventory Value: $[sum_of_price_times_quantity_for_all_products]"
- "Average Product Price: $[total_inventory_value_divided_by_total_items]"
Filtere Produkte abhängig vom Berichtstyp und gib sie aus:
- Für "full": Alle Produkte anzeigen
- Für "low_stock": Nur Produkte anzeigen, deren Menge kleiner oder gleich dem Schwellenwert ist
- Für "high_value": Nur Produkte anzeigen, deren Gesamtwert (Preis × Menge) größer oder gleich dem Schwellenwert ist
Gib den Abschnitt mit den gefilterten Produkten aus:
- Für "full": "All Products:"
- Für "low_stock": "Products with stock ≤ [threshold_value]:"
- Für "high_value": "Products with value ≥ $[threshold_value]:"
Für jedes gefilterte Produkt (alphabetisch nach Produktname sortiert):
- "- [product_name]: $[price] × [quantity] = $[total_value]"
Gib die gefilterten Statistiken aus:
- "Filtered Results:"
- "Products shown: [number_of_products_in_filtered_results]"
- "Items in filtered products: [sum_of_quantities_for_filtered_products]"
- "Value of filtered products: $[sum_of_values_for_filtered_products]"
Ermittle und gib das teuerste und das günstigste Produkt aus:
- "Price Analysis:"
- "Most expensive: [product_name] at $[price]"
- "Least expensive: [product_name] at $[price]"
Ermittle und gib die Produkte mit dem höchsten und niedrigsten Bestand aus:
- "Stock Analysis:"
- "Highest stock: [product_name] with [quantity] units"
- "Lowest stock: [product_name] with [quantity] units"
Gib die Bestandsbewertung aus:
- Zähle Produkte mit einer Menge ≤ 5: "Low stock items (≤5): [count]"
- Zähle Produkte mit einer Menge > 20: "High stock items (>20): [count]"
- Zähle Produkte mit einem Wert ≥ $500: "High value items (≥$500): [count]"
Gib den Abschluss des Berichts aus:
- "Report generated successfully"
- "Threshold applied: [threshold_value]"

Verwende das Paket strings, um die Eingabezeichenfolgen zu teilen, das Paket strconv, um Zeichenfolgen in Zahlen umzuwandeln, das Paket fmt für die formatierte Ausgabe und das Paket sort, um die Produktnamen alphabetisch zu sortieren. Formatiere alle Preise und Werte mit 2 Dezimalstellen. Wenn du das teuerste/günstigste oder das Produkt mit dem höchsten/niedrigsten Bestand ermittelst und es Gleichstände gibt, verwende den alphabetisch zuerst kommenden Produktnamen. Diese Herausforderung zeigt, wie umfassende Berichtssysteme erstellt werden, die durch Datenanalyse und formatierte Darstellung wertvolle geschäftliche Erkenntnisse liefern.

Probier es selbst

package main

import (
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type Product struct {
	Price    float64
	Quantity int
}

func updateStock(inventory map[string]Product, productName string, change int) error {
	product, exists := inventory[productName]
	if !exists {
		return errors.New("product not found: " + productName)
	}
	
	newQuantity := product.Quantity + change
	if newQuantity < 0 {
		return fmt.Errorf("insufficient stock: cannot reduce %s by %d, only %d available", productName, -change, product.Quantity)
	}
	
	product.Quantity = newQuantity
	inventory[productName] = product
	return nil
}

func main() {
	var inventoryData string
	var updateRequests string
	fmt.Scanln(&inventoryData)
	fmt.Scanln(&updateRequests)
	
	// Parse existing inventory
	inventory := make(map[string]Product)
	inventoryEntries := strings.Split(inventoryData, ",")
	
	for _, entry := range inventoryEntries {
		parts := strings.Split(entry, ":")
		name := parts[0]
		price, _ := strconv.ParseFloat(parts[1], 64)
		quantity, _ := strconv.Atoi(parts[2])
		
		inventory[name] = Product{
			Price:    price,
			Quantity: quantity,
		}
	}
	
	// Parse update requests
	updateEntries := strings.Split(updateRequests, ",")
	
	fmt.Println("Processing Stock Updates:")
	
	totalUpdates := len(updateEntries)
	successfulUpdates := 0
	failedUpdates := 0
	var failedProducts []string
	
	for _, update := range updateEntries {
		parts := strings.Split(update, ":")
		productName := parts[0]
		change, _ := strconv.Atoi(parts[1])
		
		err := updateStock(inventory, productName, change)
		if err != nil {
			fmt.Printf("%s: Update failed - %s\n", productName, err.Error())
			failedUpdates++
			failedProducts = append(failedProducts, productName)
		} else {
			newQuantity := inventory[productName].Quantity
			if change > 0 {
				fmt.Printf("%s: Added %d units - New stock: %d\n", productName, change, newQuantity)
			} else if change < 0 {
				fmt.Printf("%s: Removed %d units - New stock: %d\n", productName, -change, newQuantity)
			} else {
				fmt.Printf("%s: No change - Current stock: %d\n", productName, newQuantity)
			}
			successfulUpdates++
		}
	}
	
	// Update summary
	fmt.Println("Update Summary:")
	fmt.Printf("Updates processed: %d\n", totalUpdates)
	fmt.Printf("Updates successful: %d\n", successfulUpdates)
	fmt.Printf("Updates failed: %d\n", failedUpdates)
	
	// Display updated inventory in alphabetical order
	fmt.Println("Updated Inventory:")
	var productNames []string
	for name := range inventory {
		productNames = append(productNames, name)
	}
	sort.Strings(productNames)
	
	for _, name := range productNames {
		product := inventory[name]
		fmt.Printf("- %s: $%.2f (Stock: %d)\n", name, product.Price, product.Quantity)
	}
	
	// Calculate final statistics
	totalProducts := len(inventory)
	totalItems := 0
	totalValue := 0.0
	
	for _, product := range inventory {
		totalItems += product.Quantity
		totalValue += product.Price * float64(product.Quantity)
	}
	
	fmt.Println("Final Inventory Statistics:")
	fmt.Printf("Total Products: %d\n", totalProducts)
	fmt.Printf("Total Items in Stock: %d\n", totalItems)
	fmt.Printf("Total Inventory Value: $%.2f\n", totalValue)
	
	// List failed updates
	if len(failedProducts) > 0 {
		fmt.Printf("Failed updates: %s\n", strings.Join(failedProducts, ","))
	} else {
		fmt.Println("All stock updates were processed successfully")
	}
}