Parsing and Updating Nested Dictionaries in C#

Introduction

Hello, and welcome back! Are you ready for a new challenge? In this unit, we're stepping up to tackle a complex yet intriguing task. It involves parsing complex strings into a C# Dictionary<string, object> and then updating them, which is a common requirement in many real-world tasks. So yes, this unit's session is going to be pretty pragmatic — just the way you like it!

Task Statement

This task involves transforming a given string into a nested Dictionary<string, object> and updating a specific key-value pair within that dictionary. The input string will take the form "Key1=Value1,Key2=Value2,..." . When a part of the value is another key-value string, we create a nested dictionary. For example, the string "A1=B1,C1={D1=E1,F1=G1},I1=J1" should be transformed into the following dictionary: C# Dictionary<string, object> dictionary = new Dictionary<string, object> {{"A1", "B1"}, {"C1", new Dictionary<string, string> {{"D1", "E1"}, {"F1", "G1"}}}, {"I1", "J1"}}; Dictionary<string, object> dictionary = new Dictionary<string, object> {{"A1", "B1"}, {"C1", new Dictionary<string, string> {{"D1", "E1"}, {"F1", "G1"}}}, {"I1", "J1"}}; Your C# function should parse this string into the above dictionary, then update the value of the nested key F1 from G1 to some other value, say'NewValue' . The function should ultimately return the updated dictionary.

Step 1 - Setting Up the Function and Variables

First, set up the function and necessary variables: C# using System; using System.Collections.Generic; public class StringParser {public static Dictionary<string, object> ParseString(string inputString) {Dictionary<string, object> resultMap = new Dictionary<string, object>(); string key = ""; // to store the current dictionary key Dictionary<string, string> innerMap = new Dictionary<string, string>(); // to store the inner dictionary bool inInnerMap = false; // flag to check if we are inside an inner map int i = 0; // to iterate through the string using System; using System.Collections.Generic; public class StringParser {public static Dictionary<string, object> ParseString(string inputString) {Dictionary<string, object> resultMap = new Dictionary<string, object>(); string key = ""; // to store the current dictionary key Dictionary<string, string> innerMap = new Dictionary<string, string>(); // to store the inner dictionary bool inInnerMap = false; // flag to check if we are inside an inner map int i = 0; // to iterate through the string

Step 2 - Handling the Opening and Closing Braces

Next, handle the opening and closing braces. If an inner map is encountered, set the flag and prepare to parse it: C# while (i < inputString.Length) {if (inputString[i] == '{') {// Entering an inner map inInnerMap = true; i++; // Skip the '{'} else if (inputString[i] == '}') {// Exiting an inner map resultMap[key] = new Dictionary<string, string>(innerMap); innerMap.Clear(); inInnerMap = false; i++; // Skip the '}' if (i < inputString.Length && inputString[i] == ',') {i++; // Skip the ',' after '}'}} while (i < inputString.Length) {if (inputString[i] == '{') {// Entering an inner map inInnerMap = true; i++; // Skip the '{'} else if (inputString[i] == '}') {// Exiting an inner map resultMap[key] = new Dictionary<string, string>(innerMap); innerMap.Clear(); inInnerMap = false; i++; // Skip the '}' if (i < inputString.Length && inputString[i] == ',') {i++; // Skip the ',' after '}'}}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Dictionary<string, object> dictionary = new Dictionary<string, object>
{
    {"A1", "B1"},
    {"C1", new Dictionary<string, string> {
        {"D1", "E1"},
        {"F1", "G1"}
    }},
    {"I1", "J1"}
};

using System;
using System.Collections.Generic;

public class StringParser
{
    public static Dictionary<string, object> ParseString(string inputString)
    {
        Dictionary<string, object> resultMap = new Dictionary<string, object>();

        string key = "";  // to store the current dictionary key
        Dictionary<string, string> innerMap = new Dictionary<string, string>();  // to store the inner dictionary
        bool inInnerMap = false;  // flag to check if we are inside an inner map
        int i = 0;  // to iterate through the string

        while (i < inputString.Length)
        {
            if (inputString[i] == '{')
            {
                // Entering an inner map
                inInnerMap = true;
                i++; // Skip the '{'
            }
            else if (inputString[i] == '}')
            {
                // Exiting an inner map
                resultMap[key] = new Dictionary<string, string>(innerMap);
                innerMap.Clear();
                inInnerMap = false;
                i++; // Skip the '}'
                if (i < inputString.Length && inputString[i] == ',')
                {
                    i++; // Skip the ',' after '}'
                }
            }

            else if (!inInnerMap)
            {
                // Parsing key-value pairs in the outer map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                if (commaPos == -1) commaPos = inputString.Length;

                key = inputString.Substring(i, equalPos - i);
                string value = inputString.Substring(equalPos + 1, commaPos - equalPos - 1);

                if (value.Contains("{"))
                {
                    // Value is a nested map, will be processed separately
                    key = inputString.Substring(i, equalPos - i);
                    i = equalPos + 1; // Move forward to process the nested part
                }
                else
                {
                    // Directly add to result map
                    resultMap[key] = value;
                    i = commaPos + 1; // Move past the comma
                }
            }

            else if (!inInnerMap)
            {
                // Parsing key-value pairs in the outer map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                if (commaPos == -1) commaPos = inputString.Length;

                key = inputString.Substring(i, equalPos - i);
                string value = inputString.Substring(equalPos + 1, commaPos - equalPos - 1);

                if (value.Contains("{"))
                {
                    // Value is a nested map, will be processed separately
                    key = inputString.Substring(i, equalPos - i);
                    i = equalPos + 1; // Move forward to process the nested part
                }
                else
                {
                    // Directly add to result map
                    resultMap[key] = value;
                    i = commaPos + 1; // Move past the comma
                }
            }

            else if (inInnerMap)
            {
                // Parsing key-value pairs inside the inner map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                int bracePos = inputString.IndexOf('}', equalPos);

                // Determine the next delimiter that ends the current key-value pair
                int endPos = Math.Min((commaPos < bracePos ? commaPos : int.MaxValue), bracePos);
                if (endPos == -1) endPos = Math.Max(commaPos, bracePos);

                string innerKey = inputString.Substring(i, equalPos - i);
                string innerValue = inputString.Substring(equalPos + 1, endPos - equalPos - 1);
                innerMap[innerKey] = innerValue;

                i = endPos;
                if (i < inputString.Length && inputString[i] == ',')
                {
                    i++; // Skip the comma
                }
            }
        }

        return resultMap;
    }

            else if (inInnerMap)
            {
                // Parsing key-value pairs inside the inner map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                int bracePos = inputString.IndexOf('}', equalPos);

                // Determine the next delimiter that ends the current key-value pair
                int endPos = Math.Min((commaPos < bracePos ? commaPos : int.MaxValue), bracePos);
                if (endPos == -1) endPos = Math.Max(commaPos, bracePos);

                string innerKey = inputString.Substring(i, equalPos - i);
                string innerValue = inputString.Substring(equalPos + 1, endPos - equalPos - 1);
                innerMap[innerKey] = innerValue;

                i = endPos;
                if (i < inputString.Length && inputString[i] == ',')
                {
                    i++; // Skip the comma
                }
            }
        }

        return resultMap;
    }

    public static void UpdateDictionary(Dictionary<string, object> map, string key, string value)
    {
        if (map.ContainsKey(key))
        {
            // Update directly if it's a top-level key
            if (map[key] is string)
            {
                map[key] = value;
            }
            else if (map[key] is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
            }
            return;
        }

        // Update nested values if applicable
        foreach (var pair in map)
        {
            if (pair.Value is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
                return;
            }
        }
    }

    public static void UpdateDictionary(Dictionary<string, object> map, string key, string value)
    {
        if (map.ContainsKey(key))
        {
            // Update directly if it's a top-level key
            if (map[key] is string)
            {
                map[key] = value;
            }
            else if (map[key] is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
            }
            return;
        }

        // Update nested values if applicable
        foreach (var pair in map)
        {
            if (pair.Value is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
                return;
            }
        }
    }

    public static Dictionary<string, object> ParseStringAndUpdateValue(string inputString, string updateKey, string newValue)
    {
        // Parse the input string into a dictionary
        Dictionary<string, object> map = ParseString(inputString);
        // Update the specific key-value pair
        UpdateDictionary(map, updateKey, newValue);
        return map;
    }
}

    public static Dictionary<string, object> ParseStringAndUpdateValue(string inputString, string updateKey, string newValue)
    {
        // Parse the input string into a dictionary
        Dictionary<string, object> map = ParseString(inputString);
        // Update the specific key-value pair
        UpdateDictionary(map, updateKey, newValue);
        return map;
    }
}

            else if (!inInnerMap)
            {
                // Parsing key-value pairs in the outer map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                if (commaPos == -1) commaPos = inputString.Length;

                key = inputString.Substring(i, equalPos - i);
                string value = inputString.Substring(equalPos + 1, commaPos - equalPos - 1);

                if (value.Contains("{"))
                {
                    // Value is a nested map, will be processed separately
                    key = inputString.Substring(i, equalPos - i);
                    i = equalPos + 1; // Move forward to process the nested part
                }
                else
                {
                    // Directly add to result map
                    resultMap[key] = value;
                    i = commaPos + 1; // Move past the comma
                }
            }

            else if (inInnerMap)
            {
                // Parsing key-value pairs inside the inner map
                int equalPos = inputString.IndexOf('=', i);
                int commaPos = inputString.IndexOf(',', equalPos);
                int bracePos = inputString.IndexOf('}', equalPos);

                // Determine the next delimiter that ends the current key-value pair
                int endPos = Math.Min((commaPos < bracePos ? commaPos : int.MaxValue), bracePos);
                if (endPos == -1) endPos = Math.Max(commaPos, bracePos);

                string innerKey = inputString.Substring(i, equalPos - i);
                string innerValue = inputString.Substring(equalPos + 1, endPos - equalPos - 1);
                innerMap[innerKey] = innerValue;

                i = endPos;
                if (i < inputString.Length && inputString[i] == ',')
                {
                    i++; // Skip the comma
                }
            }
        }

        return resultMap;
    }

    public static void UpdateDictionary(Dictionary<string, object> map, string key, string value)
    {
        if (map.ContainsKey(key))
        {
            // Update directly if it's a top-level key
            if (map[key] is string)
            {
                map[key] = value;
            }
            else if (map[key] is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
            }
            return;
        }

        // Update nested values if applicable
        foreach (var pair in map)
        {
            if (pair.Value is Dictionary<string, string> innerMap && innerMap.ContainsKey(key))
            {
                innerMap[key] = value;
                return;
            }
        }
    }

    public static Dictionary<string, object> ParseStringAndUpdateValue(string inputString, string updateKey, string newValue)
    {
        // Parse the input string into a dictionary
        Dictionary<string, object> map = ParseString(inputString);
        // Update the specific key-value pair
        UpdateDictionary(map, updateKey, newValue);
        return map;
    }
}

Introduction

Task Statement

Step 1 - Setting Up the Function and Variables

Step 2 - Handling the Opening and Closing Braces

Join the 1M+ learners on CodeSignal

Step 3 - Parsing Outer Map Key-Value Pairs

Step 4 - Parsing Inner Map Key-Value Pairs

Step 5 - Updating the Value in the Dictionary

Step 6 - Putting It All Together

Lesson Summary