StringBuilder for performance in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using StringBuilder?

Consider the following Kotlin code snippet. What will it print?

Kotlin

fun main() {
    val sb = StringBuilder()
    for (i in 1..3) {
        sb.append(i)
        sb.append(",")
    }
    println(sb.toString())
}

A 1,2,3,

B 1, 2, 3,

C 1,2,3

D 123,

💡 Hint

Look carefully at what is appended inside the loop.

The loop appends the number and then a comma each time, so the output ends with a comma after the last number.

❓ Predict Output

intermediate

What is the final string length after these StringBuilder operations?

Given this Kotlin code, what is the length of the string in sb after execution?

Kotlin

fun main() {
    val sb = StringBuilder("Hello")
    sb.append(" World")
    sb.delete(5, 6)
    println(sb.length)
}

A 6

B 11

C 5

D 10

💡 Hint

Deleting one character reduces length by one.

Initial string "Hello" has length 5, appending " World" adds 6 characters (including space), total 11. Deleting one character reduces length to 10.

🔧 Debug

advanced

Why does this Kotlin code throw an exception?

This Kotlin code throws an exception. What is the cause?

Kotlin

fun main() {
    val sb = StringBuilder("abc")
    sb.delete(1, 5)
    println(sb.toString())
}

A No exception, output is "a"

B StringIndexOutOfBoundsException because end index is greater than string length

C NullPointerException because sb is null

D IllegalArgumentException because start index is greater than end index

💡 Hint

Check the valid range for delete method indices.

The delete method throws StringIndexOutOfBoundsException if the end index is greater than the current length of the StringBuilder.

🧠 Conceptual

advanced

Why is StringBuilder preferred over String concatenation in loops?

Which option best explains why using StringBuilder is better than using String concatenation inside loops in Kotlin?

A StringBuilder modifies the string in place, avoiding creating many temporary String objects

B String concatenation is faster because it uses immutable strings

C String concatenation uses less memory than StringBuilder

D StringBuilder automatically sorts the characters for better performance

💡 Hint

Think about how strings are stored and changed in memory.

Strings are immutable in Kotlin, so concatenation creates new objects each time. StringBuilder changes the string content without creating new objects, improving performance.

❓ Predict Output

expert

What is the output of this Kotlin code using StringBuilder and insert?

Analyze this Kotlin code and select the exact output it produces.

Kotlin

fun main() {
    val sb = StringBuilder("Kotlin")
    sb.insert(3, " is")
    sb.insert(0, "I think")
    println(sb.toString())
}

A I thinkK isotlin

B I thinkKotlin is

C I thinkKot islin

D si niltoKkniht I

💡 Hint

Remember insert shifts characters to the right.

First insert adds " is" at index 3: "Kot islin". Then insert "I think" at index 0 shifts everything right, resulting in "I thinkKot islin".

Practice

1. What is the main advantage of using StringBuilder in Kotlin when combining many strings?

easy

A. It automatically sorts the strings alphabetically.

B. It stores strings in a database for later use.

C. It converts strings to uppercase by default.

D. It improves performance by reducing the number of string copies.

Solution

1. Step 1: Understand string concatenation cost

   Regular string concatenation creates new strings each time, which is slow.

2. Step 2: Role of StringBuilder

   StringBuilder appends strings without creating new copies each time, improving speed.

3. Final Answer:

   It improves performance by reducing the number of string copies. -> Option D

4. Quick Check:

   StringBuilder reduces copies [OK]

Hint: StringBuilder avoids repeated copying for faster string joining [OK]

Common Mistakes:

• Thinking StringBuilder sorts strings
• Assuming it changes string case automatically
• Believing it stores strings externally

2. Which of the following is the correct way to create a StringBuilder and add text in Kotlin?

easy

A. val sb = StringBuilder(); sb.add("Hello")

B. val sb = StringBuilder(); sb.append("Hello")

C. val sb = StringBuilder("Hello"); sb.add("World")

D. val sb = StringBuilder(); sb.insert("Hello")

Solution

1. Step 1: Check StringBuilder creation

   Creating with StringBuilder() is correct syntax.

2. Step 2: Identify correct method to add text

   The method to add text is append(), not add() or insert() with a string argument.

3. Final Answer:

   val sb = StringBuilder(); sb.append("Hello") -> Option B

4. Quick Check:

   Use append() to add text [OK]

Hint: Use append() method to add text to StringBuilder [OK]

Common Mistakes:

• Using add() instead of append()
• Using insert() incorrectly
• Passing strings to insert() without index

3. What will be the output of the following Kotlin code?

val sb = StringBuilder()
sb.append("Hi")
sb.append(", ")
sb.append("there!")
println(sb.toString())

medium

A. Hi, there!

B. Hi there!

C. Hi,there!

D. Hi, there

Solution

1. Step 1: Trace each append call

   First append adds "Hi", second adds ", ", third adds "there!".

2. Step 2: Combine all appended strings

   Combined string is "Hi, there!" exactly as appended.

3. Final Answer:

   Hi, there! -> Option A

4. Quick Check:

   Appended strings combined [OK]

Hint: Append strings in order, then call toString() [OK]

Common Mistakes:

• Missing spaces in appended strings
• Forgetting to call toString()
• Assuming append adds spaces automatically

4. Identify the error in the following Kotlin code using StringBuilder:

val sb = StringBuilder()
sb.append("Hello")
sb.append(123)
println(sb)

medium

A. Cannot append an integer directly to StringBuilder.

B. append() method requires two arguments.

C. There is no error in the code.

D. StringBuilder must be initialized with a string.

Solution

1. Step 1: Check append usage

   append can accept integers and converts them to string automatically, so no error here.

2. Step 2: Check printing StringBuilder directly

   Printing StringBuilder object directly calls its toString() method, so it prints the content correctly; no error here either.

3. Step 3: Re-examine options

   Actually, printing sb directly works fine in Kotlin, so no error. The code is correct.

4. Final Answer:

   No error; code runs and prints Hello123 -> Option C

5. Quick Check:

   Printing StringBuilder directly works [OK]

Hint: StringBuilder prints content directly without toString() [OK]

Common Mistakes:

• Thinking append can't take integers
• Assuming toString() is mandatory for printing
• Believing append needs two arguments

5. You want to build a comma-separated list of numbers from 1 to 5 using StringBuilder efficiently. Which code snippet correctly avoids adding an extra comma at the end?

hard

A. val sb = StringBuilder()
for (i in 1..5) {
sb.append(i)
if (i != 5) sb.append(",")
}
sb.toString()

B. val sb = StringBuilder()
for (i in 1..5) {
if (i > 0) sb.append(i).append(",") else sb.append(i)
}
sb.toString()

C. val sb = StringBuilder()
for (i in 1..5) {
sb.append(i).append(",")
}
sb.toString()

D. val sb = StringBuilder()
for (i in 1..5) {
sb.append(i)
sb.append(",")
}
sb.toString().removePrefix(",")

Solution

1. Step 1: Analyze each option for trailing comma

   val sb = StringBuilder() for (i in 1..5) { sb.append(i).append(",") } sb.toString() adds comma after every number, including last, causing extra comma.

2. Step 2: Check conditional comma addition

   val sb = StringBuilder() for (i in 1..5) { if (i > 0) sb.append(i).append(",") else sb.append(i) } sb.toString() tries to avoid comma on last number by if-else, but condition i > 0 is always true, so always appends comma after each number, causing trailing comma.

3. Step 3: Verify correct conditional append

   val sb = StringBuilder() for (i in 1..5) { sb.append(i) if (i != 5) sb.append(",") } sb.toString() appends number first, then adds comma only if not last number, correctly avoiding trailing comma.

4. Step 4: Check the remove prefix method

   val sb = StringBuilder() for (i in 1..5) { sb.append(i) sb.append(",") } sb.toString().removePrefix(",") appends comma always, then removes prefix "," from start (which doesn't exist), leaving trailing comma.

5. Final Answer:

   val sb = StringBuilder() for (i in 1..5) { sb.append(i) if (i != 5) sb.append(",") } sb.toString() -> Option A

6. Quick Check:

   Append comma only if not last [OK]

Hint: Add comma only if not last item in loop [OK]

Common Mistakes:

• Adding comma after every item including last
• Appending number twice in conditional branches
• Removing suffix after building string instead of conditional append