Recap - HashMap Operations

Teil des Abschnitts Logik & Ablauf der C#-Journey von Coddy — Lektion 55 von 66.

Aufgabe

Mittel

Erstellen Sie eine Methode namens ProcessDictionary, die erweiterte Operationen an einem Dictionary<string, int> inventory durchführt. Die Methode sollte:

Verarbeiten Sie Befehle aus einer Liste von Operationen:
- COUNT: Geben Sie Total items: {count} aus (wobei {count} die Anzahl der unterschiedlichen Schlüssel ist), dann geben Sie die Erfolgsmeldung aus
- ADD item quantity: Fügen Sie ein neues Element mit der angegebenen Menge hinzu (falls das Element existiert, erhöhen Sie seine Menge), dann geben Sie die Erfolgsmeldung aus
- REMOVE item: Entfernen Sie das angegebene Element aus dem Inventar, dann geben Sie die Erfolgs- oder Fehlermeldung aus
- UPDATE item quantity: Setzen Sie die Menge des Elements auf den angegebenen Wert, dann geben Sie die Erfolgs- oder Fehlermeldung aus
- FIND item: Falls gefunden, geben Sie {item}: {quantity} aus, dann die Erfolgsmeldung; falls nicht gefunden, geben Sie Not found aus, dann die Fehlermeldung
Für jede Operation geben Sie eine Statusmeldung in genau diesem Format aus:
- Operation {command} performed successfully
- Operation {command} failed: {reason} — wobei {reason} Item not found ist, wenn das Element nicht im Inventar vorhanden ist
Geben Sie das aktualisierte Inventar-Dictionary zurück

Zum Beispiel sollte die Verarbeitung von FIND orange in einem Inventar, das orange: 3 enthält, Folgendes ausgeben:
orange: 3
Operation FIND performed successfully

Und die Verarbeitung von REMOVE shoes, wenn shoes nicht im Inventar ist, sollte Folgendes ausgeben:
Operation REMOVE failed: Item not found

Probier es selbst

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

class Program
{
    public static Dictionary<string, int> ProcessDictionary(Dictionary<string, int> inventory, List<string> operations)
    {
        // Dein Code hier
        
        return inventory;
    }
    
    static void Main(string[] args)
    {
        Dictionary<string, int> inventory = new Dictionary<string, int>();
        List<string> operations = new List<string>();
        
        // Erste Zeile lesen, um zu prüfen, ob sie im JSON-Format für das Inventar ist
        string firstLine = Console.ReadLine();
        
        // Prüfen, ob die Eingabe im JSON-Format für das Inventar vorliegt
        if (firstLine != null && firstLine.StartsWith("{") && firstLine.EndsWith("}"))
        {
            try
            {
                // JSON-Eingabe für das Inventar verarbeiten
                string jsonContent = firstLine.Substring(1, firstLine.Length - 2);
                
                // Nach Kommas trennen, die nicht innerhalb von Anführungszeichen stehen
                string pattern = @",(?=(?:[^""]*""[^""]*"")*[^""]*$)";
                string[] entries = Regex.Split(jsonContent, pattern);
                
                foreach (string entry in entries)
                {
                    // Schlüssel und Wert mittels Regex extrahieren
                    Match match = Regex.Match(entry, @"""([^""]+)""\s*:\s*(\d+)");
                    if (match.Success)
                    {
                        string keyMatch = match.Groups[1].Value;
                        int valueMatch = int.Parse(match.Groups[2].Value);
                        inventory.Add(keyMatch, valueMatch);
                    }
                }
                
                // Read second line for operations
                string secondLine = Console.ReadLine();
                
                // Check if operations are in JSON array format
                if (secondLine != null && secondLine.StartsWith("[") && secondLine.EndsWith("]"))
                {
                    try
                    {
                        // Extract content between square brackets
                        string arrayContent = secondLine.Substring(1, secondLine.Length - 2);
                        
                        // Use regex to match all quoted strings - this is more robust
                        MatchCollection matches = Regex.Matches(arrayContent, @"""([^""]*)""");
                        
                        foreach (Match match in matches)
                        {
                            // Add the captured group (without quotes)
                            if (match.Groups.Count > 1)
                            {
                                operations.Add(match.Groups[1].Value);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error parsing operations array: {ex.Message}");
                        return;
                    }
                }
                else
                {
                    // Process operations in traditional format
                    int m = int.Parse(secondLine);
                    for (int i = 0; i < m; i++)
                    {
                        operations.Add(Console.ReadLine());
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing JSON input: {ex.Message}");
                return;
            }
        }
        else
        {
            // Process traditional input format
            int n = int.Parse(firstLine);
            for (int i = 0; i < n; i++)
            {
                string[] parts = Console.ReadLine().Split(':');
                inventory.Add(parts[0], int.Parse(parts[1]));
            }
            
            // Read operations
            int m = int.Parse(Console.ReadLine());
            for (int i = 0; i < m; i++)
            {
                operations.Add(Console.ReadLine());
            }
        }
        
        Dictionary<string, int> result = ProcessDictionary(inventory, operations);
        
        // Print updated inventory
        Console.WriteLine("Final Inventory:");
        foreach (var item in result)
        {
            Console.WriteLine($"{item.Key}: {item.Value}");
        }
    }
}

Alle Lektionen in Logik & Ablauf

1Multi-dimensional Arrays

2D Arrays Basics Declaring and Initializing 2D Accessing 2D Array Elements Nested Loops with 2D Arrays Jagged Arrays Common Matrix Operations Recap - Multi-dimensional

4Flow Control Techniques

Early Returns Guard Clauses Jump Statements (goto)Break and Continue Flatten Nested Conditionals

7Logical Operators Advanced

Short-Circuit Evaluation Conditional Logical Operators Operator Precedence Recap - Advanced Operators

10HashMap Part 2

HashMap Methods Nested HashMap Recap - Manage WarehouseRecap - HashMap Operations