Parsing and Manipulating Nested Maps in Kotlin

Introduction

Hello, and welcome back! Are you ready for a new challenge? In this unit, we're exploring an interesting task using Kotlin's powerful map capabilities. We'll be focusing on parsing complex strings into nested maps and updating them. This is a common requirement in many real-world tasks, making our session particularly practical — just the way you like it!

Task Statement

This task involves transforming a given string into a nested map and updating a specific key-value pair within that map using Kotlin . 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 map. For example, the string "A1=B1,C1={D1=E1,F1=G1},I1=J1" should be transformed into the following nested map: Kotlin val dictionary: MutableMap<String, Any> = mutableMapOf("A1" to mutableMapOf("" to "B1"), "C1" to mutableMapOf("D1" to "E1", "F1" to "G1"), "I1" to mutableMapOf("" to "J1")) val dictionary: MutableMap<String, Any> = mutableMapOf("A1" to mutableMapOf("" to "B1"), "C1" to mutableMapOf("D1" to "E1", "F1" to "G1"), "I1" to mutableMapOf("" to "J1")) Your function should parse this string into the above nested map, then update the value of the nested key F1 from G1 to another value, say NewValue . The function should ultimately return the updated map.

Step 1 - Setting Up the Function and Variables

First, set up the function and necessary variables in Kotlin: Kotlin fun parseString(inputString: String): MutableMap<String, Any> {val result = mutableMapOf<String, Any>() // Stores the final nested map structure with parsed key-value pairs. var key = "" // Temporarily holds the current key being parsed from the input string. var innerMap = mutableMapOf<String, String>() // Temporarily holds key-value pairs for any detected inner map. var inInnerMap = false // Flag to indicate whether the parsing process is currently inside an inner map. var i = 0 // Index used to iterate through each character of the input string. fun parseString(inputString: String): MutableMap<String, Any> {val result = mutableMapOf<String, Any>() // Stores the final nested map structure with parsed key-value pairs. var key = "" // Temporarily holds the current key being parsed from the input string. var innerMap = mutableMapOf<String, String>() // Temporarily holds key-value pairs for any detected inner map. var inInnerMap = false // Flag to indicate whether the parsing process is currently inside an inner map. var i = 0 // Index used to iterate through each character of the input 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: Kotlin while (i < inputString.length) {when (inputString[i]) {'{' -> {// Entering an inner map inInnerMap = true i++ // Skip the '{'}'}' -> {// Exiting an inner map result[key] = innerMap innerMap = mutableMapOf() inInnerMap = false i++ // Skip the '}' if (i < inputString.length && inputString[i] == ',') {i++ // Skip the ',' after '}'}} while (i < inputString.length) {when (inputString[i]) {'{' -> {// Entering an inner map inInnerMap = true i++ // Skip the '{'}'}' -> {// Exiting an inner map result[key] = innerMap innerMap = mutableMapOf() 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

Kotlin

val dictionary: MutableMap<String, Any> = mutableMapOf(
    "A1" to mutableMapOf("" to "B1"),
    "C1" to mutableMapOf("D1" to "E1", "F1" to "G1"),
    "I1" to mutableMapOf("" to "J1")
)

Kotlin

fun parseString(inputString: String): MutableMap<String, Any> {
    val result = mutableMapOf<String, Any>() // Stores the final nested map structure with parsed key-value pairs.
    var key = "" // Temporarily holds the current key being parsed from the input string.
    var innerMap = mutableMapOf<String, String>() // Temporarily holds key-value pairs for any detected inner map.
    var inInnerMap = false // Flag to indicate whether the parsing process is currently inside an inner map.
    var i = 0 // Index used to iterate through each character of the input string.

Kotlin

    while (i < inputString.length) {
        when (inputString[i]) {
            '{' -> {
                // Entering an inner map
                inInnerMap = true
                i++ // Skip the '{'
            }
            '}' -> {
                // Exiting an inner map
                result[key] = innerMap
                innerMap = mutableMapOf()
                inInnerMap = false
                i++ // Skip the '}'
                if (i < inputString.length && inputString[i] == ',') {
                    i++ // Skip the ',' after '}'
                }
            }

Kotlin

            else -> if (!inInnerMap) {
                // Parsing key-value pairs in the outer map
                val equalPos = inputString.indexOf('=', i)
                val commaPos = inputString.indexOf(',', equalPos).takeIf { it != -1 } ?: inputString.length

                key = inputString.substring(i, equalPos)
                val value = inputString.substring(equalPos + 1, commaPos)

                if ('{' in value) {
                    // Value is a nested map, will be processed separately
                    i = equalPos + 1
                } else {
                    // Value is a simple string, add to result map
                    result[key] = mutableMapOf("" to value)
                    i = commaPos + 1 // Move past the comma
                }
            }

            else -> if (!inInnerMap) {
                // Parsing key-value pairs in the outer map
                val equalPos = inputString.indexOf('=', i)
                val commaPos = inputString.indexOf(',', equalPos).takeIf { it != -1 } ?: inputString.length

                key = inputString.substring(i, equalPos)
                val value = inputString.substring(equalPos + 1, commaPos)

                if ('{' in value) {
                    // Value is a nested map, will be processed separately
                    i = equalPos + 1
                } else {
                    // Value is a simple string, add to result map
                    result[key] = mutableMapOf("" to value)
                    i = commaPos + 1 // Move past the comma
                }
            }

Kotlin

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

                // Determine the next delimiter that ends the current key-value pair
                val endPos = listOf(commaPos, bracePos).filter { it != -1 }.minOrNull() ?: inputString.length

                val innerKey = inputString.substring(i, equalPos)
                val innerValue = inputString.substring(equalPos + 1, endPos)
                innerMap[innerKey] = innerValue

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

    return result
}

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

                // Determine the next delimiter that ends the current key-value pair
                val endPos = listOf(commaPos, bracePos).filter { it != -1 }.minOrNull() ?: inputString.length

                val innerKey = inputString.substring(i, equalPos)
                val innerValue = inputString.substring(equalPos + 1, endPos)
                innerMap[innerKey] = innerValue

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

    return result
}

Kotlin

fun updateMap(map: MutableMap<String, Any>, key: String, value: String) {
    map.values.forEach {
        when (it) {
            is MutableMap<*, *> -> if (it.containsKey(key)) {
                (it as MutableMap<String, String>)[key] = value
                return
            }
        }
    }
}

fun updateMap(map: MutableMap<String, Any>, key: String, value: String) {
    map.values.forEach {
        when (it) {
            is MutableMap<*, *> -> if (it.containsKey(key)) {
                (it as MutableMap<String, String>)[key] = value
                return
            }
        }
    }
}

Kotlin

fun parseStringAndUpdateValue(inputString: String, updateKey: String, newValue: String): MutableMap<String, Any> {
    // Parse the input string into a nested map
    val map = parseString(inputString)
    // Update the specific key-value pair
    updateMap(map, updateKey, newValue)
    return map
}

fun main() {
    val input = "A1=B1,C1={D1=E1,F1=G1},I1=J1"
    val updateKey = "F1"
    val newValue = "NewValue"
    
    val updatedMap = parseStringAndUpdateValue(input, updateKey, newValue)
    println(updatedMap) // Outputs {A1={=B1}, C1={D1=E1, F1=NewValue}, I1={=J1}}
}

fun parseStringAndUpdateValue(inputString: String, updateKey: String, newValue: String): MutableMap<String, Any> {
    // Parse the input string into a nested map
    val map = parseString(inputString)
    // Update the specific key-value pair
    updateMap(map, updateKey, newValue)
    return map
}

fun main() {
    val input = "A1=B1,C1={D1=E1,F1=G1},I1=J1"
    val updateKey = "F1"
    val newValue = "NewValue"
    
    val updatedMap = parseStringAndUpdateValue(input, updateKey, newValue)
    println(updatedMap) // Outputs {A1={=B1}, C1={D1=E1, F1=NewValue}, I1={=J1}}
}

Kotlin

            else -> if (!inInnerMap) {
                // Parsing key-value pairs in the outer map
                val equalPos = inputString.indexOf('=', i)
                val commaPos = inputString.indexOf(',', equalPos).takeIf { it != -1 } ?: inputString.length

                key = inputString.substring(i, equalPos)
                val value = inputString.substring(equalPos + 1, commaPos)

                if ('{' in value) {
                    // Value is a nested map, will be processed separately
                    i = equalPos + 1
                } else {
                    // Value is a simple string, add to result map
                    result[key] = mutableMapOf("" to value)
                    i = commaPos + 1 // Move past the comma
                }
            }

Kotlin

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

                // Determine the next delimiter that ends the current key-value pair
                val endPos = listOf(commaPos, bracePos).filter { it != -1 }.minOrNull() ?: inputString.length

                val innerKey = inputString.substring(i, equalPos)
                val innerValue = inputString.substring(equalPos + 1, endPos)
                innerMap[innerKey] = innerValue

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

    return result
}

Kotlin

fun updateMap(map: MutableMap<String, Any>, key: String, value: String) {
    map.values.forEach {
        when (it) {
            is MutableMap<*, *> -> if (it.containsKey(key)) {
                (it as MutableMap<String, String>)[key] = value
                return
            }
        }
    }
}

Kotlin

fun parseStringAndUpdateValue(inputString: String, updateKey: String, newValue: String): MutableMap<String, Any> {
    // Parse the input string into a nested map
    val map = parseString(inputString)
    // Update the specific key-value pair
    updateMap(map, updateKey, newValue)
    return map
}

fun main() {
    val input = "A1=B1,C1={D1=E1,F1=G1},I1=J1"
    val updateKey = "F1"
    val newValue = "NewValue"
    
    val updatedMap = parseStringAndUpdateValue(input, updateKey, newValue)
    println(updatedMap) // Outputs {A1={=B1}, C1={D1=E1, F1=NewValue}, I1={=J1}}
}

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 Map

Step 6 - Putting It All Together

Lesson Summary