String slicing and indexing in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does string indexing mean in Ruby?

String indexing means accessing a single character in a string by its position number, starting from 0 for the first character.

beginner

How do you get the first 5 characters of a string in Ruby?

You can use slicing like this: str[0, 5] which means start at index 0 and take 5 characters.

intermediate

What does negative indexing do in Ruby strings?

Negative indexing counts from the end of the string. For example, str[-1] gives the last character.

beginner

How to slice a string from index 2 to index 6 in Ruby?

Use str[2..6] which includes characters from index 2 up to 6, inclusive.

intermediate

What happens if you try to slice beyond the string length in Ruby?

Ruby returns as many characters as possible without error. For example, str[0, 100] returns the whole string if it is shorter than 100 characters.

What does str[3] return in Ruby?

A The first 3 characters

B The last 3 characters

C The character at index 3

D An error

str[3] returns the single character at position 3 (fourth character) in the string.

How do you get the last character of a string str in Ruby?

A str[-1]

B str[0]

C str[1]

D str[last]

Negative index -1 accesses the last character in Ruby strings.

What does str[1..4] return?

A An error

B Characters from index 1 to 3

C Characters from index 0 to 4

D Characters from index 1 to 4 inclusive

The range 1..4 includes both ends, so characters at indexes 1, 2, 3, and 4 are returned.

What happens if you do str[5, 10] but the string length is 8?

A Returns characters from index 5 to the end

B Returns an error

C Returns nil

D Returns the whole string

Ruby returns characters from index 5 to the end without error, even if 10 characters are requested.

Which of these is NOT a valid way to slice a string in Ruby?

A str[0, 3]

B str(1..4)

C str[-3..-1]

D str[2..5]

str(1..4) is not valid syntax for slicing strings in Ruby.

Explain how to access a single character and a substring in Ruby strings using indexing and slicing.

Think about how you get one letter vs. a group of letters.

Describe how negative indexing works in Ruby strings and give an example.

Negative numbers start counting backwards from the last character.

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