String concatenation and << in Ruby - Time & Space Complexity

Time Complexity: String concatenation and <<

O(n²)

Understanding Time Complexity

We want to understand how the time it takes to join strings grows as we add more pieces.

How does using different ways to combine strings affect the work done?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

result = ""
strings = ["a", "b", "c", "d", "e"]

strings.each do |str|
  result += str
end

puts result

This code joins many small strings into one big string using the + operator inside a loop.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding strings together with += inside a loop.
• How many times: Once for each string in the array.

How Execution Grows With Input

Each time we add a string, the program copies the whole current result plus the new string.

Input Size (n)	Approx. Operations
10	About 55 copies (1+2+...+10)
100	About 5050 copies
1000	About 500,500 copies

Pattern observation: The work grows much faster than the number of strings; it grows roughly like the square of the input size.

Final Time Complexity

Time Complexity: O(n²)

This means the time to join strings grows much faster as you add more strings, because each addition copies all the previous data.

Common Mistake

[X] Wrong: "Adding strings with += inside a loop is always fast and grows linearly."

[OK] Correct: Each += creates a new string by copying the old one, so the work adds up more than just once per string.

Interview Connect

Knowing how string joining works helps you write faster code and explain your choices clearly in real projects and interviews.

Self-Check

"What if we used << instead of += to join strings? How would the time complexity change?"

Practice

1. What is the main difference between + and << when used with strings in Ruby?

easy

A. + creates a new string, << modifies the original string.

B. + modifies the original string, << creates a new string.

C. Both + and << create new strings without modifying the original.

D. Both + and << modify the original string in place.

Solution

1. Step 1: Understand + behavior

   The + operator joins two strings but returns a new string without changing the original.

2. Step 2: Understand << behavior

   The << operator appends text directly to the original string, modifying it in place.

3. Final Answer:

   + creates a new string, << modifies the original string. -> Option A

4. Quick Check:

   + new string, << modifies original [OK]

Hint: Remember: + new string, << changes original [OK]

Common Mistakes:

• Thinking + changes the original string
• Confusing << with creating a new string
• Assuming both operators behave the same

2. Which of the following is the correct syntax to append " world" to the string variable greeting using << in Ruby?

easy

A. greeting.add(" world")

B. greeting + " world"

C. greeting.append(" world")

D. greeting << " world"

Solution

1. Step 1: Identify the correct operator for appending

   In Ruby, << is used to append text to an existing string variable.

2. Step 2: Check syntax correctness

   greeting << " world" correctly appends " world" to greeting. Other options are either invalid methods or use + which does not modify in place.

3. Final Answer:

   greeting << " world" -> Option D

4. Quick Check:

   Use << to append text in place [OK]

Hint: Use << to add text directly to string [OK]

Common Mistakes:

• Using + which creates a new string
• Trying to use non-existent methods like add
• Confusing method names like append which is not standard

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

str = "Hi"
str << " there"
puts str

medium

A. Hi there

B. Hi

C. ereht iH

D. Error: undefined method << for String

Solution

1. Step 1: Analyze the initial string and operation

   The variable str starts as "Hi". The << operator appends " there" to it, modifying str to "Hi there".

2. Step 2: Understand the output of puts

   puts str prints the string with a newline, but the output shown is the string content without the newline character visible.

3. Final Answer:

   Hi there -> Option A

4. Quick Check:

   Appending with << changes string to "Hi there" [OK]

Hint: Remember << adds text inside original string [OK]

Common Mistakes:

• Expecting str to remain "Hi"
• Confusing puts output with return value
• Thinking << causes an error

4. Identify the error in the following Ruby code snippet:

text = "Hello"
text +<< " World"
puts text

medium

A. No error; output is "Hello World"

B. SyntaxError due to incorrect use of +<<

C. RuntimeError because text is immutable

D. Output is "Hello" because + does not modify original

Solution

1. Step 1: Check the operator usage

   The code uses +<< together, which is not a valid Ruby operator or syntax.

2. Step 2: Understand Ruby syntax rules

   Ruby does not allow chaining + and << without spaces or parentheses; this causes a syntax error.

3. Final Answer:

   SyntaxError due to incorrect use of +<< -> Option B

4. Quick Check:

   Invalid operator +<< causes syntax error [OK]

Hint: Operators + and << cannot be combined directly [OK]

Common Mistakes:

• Assuming +<< is valid syntax
• Expecting + to modify original string
• Ignoring syntax errors from invalid operators

5. You want to build a sentence step by step by appending words stored in an array words = ["I", "love", "Ruby"]. Which code snippet correctly uses << to create the sentence with spaces between words?

hard

A. sentence = ""; words.each { |w| sentence + w + " " }; sentence.strip!

B. sentence = ""; words.each { |w| sentence = w + " " }; sentence.strip!

C. sentence = ""; words.each { |w| sentence << w << " " }; sentence.strip!

D. sentence = ""; words.each { |w| sentence + w << " " }; sentence.strip!

Solution

1. Step 1: Understand how to append words with spaces

   We want to add each word and a space to the same string sentence using << which modifies in place.

2. Step 2: Analyze each option

   sentence = ""; words.each { |w| sentence + w + " " }; sentence.strip! computes a new concatenated string but doesn't assign it back.sentence = ""; words.each { |w| sentence = w + " " }; sentence.strip! overwrites sentence with the current word + space each time.sentence = ""; words.each { |w| sentence << w << " " }; sentence.strip! correctly chains << to append the word then the space in place.sentence = ""; words.each { |w| sentence + w << " " }; sentence.strip! creates and modifies a temporary string but discards the result.

3. Final Answer:

   sentence = ""; words.each { |w| sentence << w << " " }; sentence.strip! -> Option C

4. Quick Check:

   Use chained << to append multiple strings [OK]

Hint: Chain << to append multiple strings efficiently [OK]

Common Mistakes:

• Using + which creates new strings inside loop
• Mixing + and << incorrectly
• Forgetting to remove trailing space with strip!