String slicing and indexing in Ruby - Time & Space Complexity

Time Complexity: String slicing and indexing

O(k)

Understanding Time Complexity

We want to understand how the time it takes to get parts of a string changes as the string gets bigger.

How does slicing or picking characters from a string grow with the string size?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

str = "hello world"
slice = str[2..5]
char = str[4]

This code takes a part of the string from index 2 to 5 and also picks a single character at index 4.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Extracting a substring by copying characters from the original string.
• How many times: The number of characters copied equals the length of the slice requested.

How Execution Grows With Input

When you ask for a slice of length k, the program copies k characters. So the time depends on how big the slice is, not the whole string.

Input Size (n)	Approx. Operations for slice length k
10	Copy k characters (e.g., 4)
100	Copy k characters (still 4 if slice length same)
1000	Copy k characters (still 4 if slice length same)

Pattern observation: Time grows with the slice length, not the total string length.

Final Time Complexity

Time Complexity: O(k)

This means the time depends on how many characters you want to get, not how long the whole string is.

Common Mistake

[X] Wrong: "Getting a single character from a string takes time proportional to the whole string length."

[OK] Correct: Accessing one character by index is very fast and does not depend on string size; it is a direct lookup.

Interview Connect

Knowing how string slicing works helps you write efficient code when working with text, which is common in many programming tasks.

Self-Check

"What if we sliced the entire string instead of a small part? How would the time complexity change?"

Practice

1. In Ruby, what does str[0] return when str = "hello"?

easy

A. The first character of the string, 'h'

B. The entire string 'hello'

C. The last character of the string, 'o'

D. An error because indexing starts at 1

Solution

1. Step 1: Understand Ruby string indexing

   Ruby strings are indexed starting at 0, so the first character is at index 0.

2. Step 2: Apply indexing to the string 'hello'

   Accessing str[0] returns the first character 'h'.

3. Final Answer:

   The first character of the string, 'h' -> Option A

4. Quick Check:

   Index 0 = 'h' [OK]

Hint: Remember Ruby indexes start at zero for strings [OK]

Common Mistakes:

• Thinking indexing starts at 1
• Expecting the whole string instead of one character
• Confusing last character with first

2. Which of the following is the correct way to get the substring 'ell' from str = "hello" using slicing?

easy

A. str[1,3]

B. str[0,3]

C. str[2..4]

D. str[1...3]

Solution

1. Step 1: Understand slicing syntax

   In Ruby, str[start, length] extracts a substring starting at start with length characters.

2. Step 2: Extract 'ell' from 'hello'

   'ell' starts at index 1 and has length 3, so str[1,3] returns 'ell'.

3. Final Answer:

   str[1,3] -> Option A

4. Quick Check:

   Substring from index 1, length 3 = 'ell' [OK]

Hint: Use [start, length] to slice substrings easily [OK]

Common Mistakes:

• Using range with wrong end index
• Confusing start and length parameters
• Using negative indices incorrectly

3. What is the output of this Ruby code?

str = "programming"
puts str[-4, 3]

medium

A. ing

B. ram

C. amm

D. min

Solution

1. Step 1: Understand negative indexing and slicing

   Negative index -4 means counting from the end: 'g'( -1), 'n'( -2), 'i'( -3), 'm'( -4). So index -4 points to 'm'.

2. Step 2: Extract substring starting at 'm' with length 3

   From 'm' take 3 characters: 'm', 'i', 'n' forming 'min'.

3. Final Answer:

   min -> Option D

4. Quick Check:

   str[-4,3] = 'min' [OK]

Hint: Negative index counts from end; length slices forward [OK]

Common Mistakes:

• Confusing negative index position
• Using range instead of start,length
• Off-by-one errors in slicing length

4. Identify the error in this Ruby code snippet:

str = "example"
puts str[2..5, 2]

medium

A. Returns nil because of invalid range

B. Returns 'am' as expected

C. SyntaxError due to wrong slicing syntax

D. Returns 'amp' substring

Solution

1. Step 1: Analyze slicing syntax used

   The code uses str[2..5, 2] which mixes range and length parameters incorrectly. Ruby does not support this syntax.

2. Step 2: Understand correct slicing methods

   Use either str[2..5] for range or str[2, 2] for start and length. Mixing both causes a syntax error.

3. Final Answer:

   SyntaxError due to wrong slicing syntax -> Option C

4. Quick Check:

   Invalid slice syntax = SyntaxError [OK]

Hint: Use either range or start,length, not both together [OK]

Common Mistakes:

• Mixing range and length in one slice
• Expecting multiple parameters in range slice
• Ignoring Ruby's slice method rules

5. Given str = "abracadabra", which code extracts every second character starting from index 0 to index 8 (inclusive)?

hard

A. str[0..8][::2]

B. str[0..8].chars.select.with_index { |_, i| i.even? }.join

C. str[0, 8, 2]

D. str[0..8].chars.each_slice(2).map(&:first).join

Solution

1. Step 1: Understand Ruby slicing limitations

   Ruby's slice method does not support step values like Python. So str[0, 8, 2] or str[0..8][::2] are invalid.

2. Step 2: Use chars with index filtering to pick every second character

   str[0..8] gets substring 'abracadab'. Then chars.select.with_index { |_, i| i.even? } picks characters at even indices: a (0), r (2), c (4), d (6), b (8). Joining gives 'ar cdb' without spaces: 'arcdb'.

3. Final Answer:

   str[0..8].chars.select.with_index { |_, i| i.even? }.join -> Option B

4. Quick Check:

   Use chars and select.with_index for stepping [OK]

Hint: Ruby slice has no step; use chars with index filtering [OK]

Common Mistakes:

• Trying Python-style slicing with step
• Using invalid slice parameters
• Not converting string to chars before filtering