Manual String Manipulation

Welcome to the first lesson of this course, where we will practice the fundamentals of string manipulation in Kotlin. In this module, we will specifically focus on scenarios where we refrain from using high-level built-in string methods. Navigating through complex character strings is an integral part of a software developer's toolkit, and Kotlin provides a comprehensive set of built-in functionalities that simplify this process. Nevertheless, to truly master your craft, it is critical to peel back the layers and understand the core principles that power these built-in methods.

This understanding will not only establish a stronger foundation in the language but also equip you to handle situations where you might not have the luxury of using high-level functions or where custom solutions would be more efficient for specific performance needs.

In Kotlin, you can think of a string as a sequence of individual characters, each with its unique index starting from 0. This structure allows us to access and manipulate each character independently.

For instance, consider a simple operation such as reversing a string manually. To do this, you would start from the last character (at an index equal to the length of the string - 1), move towards the front, and append each character in reverse order to a new string.

In Kotlin, strings are immutable, meaning every time you concatenate a string using +, a new string object is created in memory. For better performance (especially in interview settings), we use StringBuilder, which allows us to efficiently build a string without creating unnecessary intermediate objects.

Here is how the solution looks in Kotlin:

fun main() {
    // Reversing a string manually
    val originalString = "hello"
    val reversedBuilder = StringBuilder()

    // We start from the last index and go down to 0
    for (i in originalString.length - 1 downTo 0) {
        reversedBuilder.append(originalString[i])
    }

    val reversedString = reversedBuilder.toString()
    println(reversedString)  // Output: "olleh"
}

In this example:

• val originalString is an immutable reference, as the input source does not change.
• StringBuilder() is used to efficiently collect characters. Unlike standard string concatenation, this doesn't create a new object on every iteration, leading to $O(N)$ time complexity.
• originalString.length - 1 downTo 0 creates a decreasing progression that traverses the string from the last index back to the first.
• originalString[i] retrieves the character at the current index i using the indexing operator.
• .toString() converts the completed buffer back into a standard String.

Take your time to digest this concept, as it forms the basis of more elaborate tasks that we will encounter later. Once you are ready, let's dive into some hands-on programming exercises that will give you a practical feel for these concepts. Remember, our goal isn't simply to memorize algorithms, but to develop an understanding of how to systematically break down and address problems — a skill that is at the heart of programming. As always, practice is your best friend, so let's get coding!