String Basics and Memory Representation in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of String Slicing and Memory Sharing

What is the output of this Go code snippet that slices a string and prints the original and sliced strings?

DSA Go

package main
import "fmt"
func main() {
    s := "golang"
    slice := s[1:4]
    fmt.Println(s)
    fmt.Println(slice)
}

A

golang
gol

B

golang
ola

C

golang
lan

D

golang
olang

💡 Hint

Remember that slicing a string in Go uses zero-based indexing and the end index is exclusive.

The slice s[1:4] takes characters from index 1 up to but not including index 4. So it extracts characters at positions 1, 2, and 3 which are 'o', 'l', and 'a'.

The original string remains unchanged and prints as "golang".

❓ Predict Output

intermediate

String Immutability and Modification Attempt

What error or output does this Go code produce when trying to modify a string character?

DSA Go

package main
func main() {
    s := "hello"
    s[0] = 'H'
}

A No error, string modified successfully

B Output: "Hello"

C Runtime panic: index out of range

D Compilation error: cannot assign to s[0]

💡 Hint

Strings in Go are immutable, meaning you cannot change their characters directly.

In Go, strings are immutable byte sequences. Trying to assign a value to an index of a string causes a compilation error.

❓ Predict Output

advanced

Memory Sharing Between Strings and Byte Slices

What is the output of this Go program that converts a string to a byte slice and modifies the slice?

DSA Go

package main
import "fmt"
func main() {
    s := "hello"
    b := []byte(s)
    b[0] = 'H'
    fmt.Println(s)
    fmt.Println(string(b))
}

A

hello
Hello

B

Hello
Hello

C

hello
hello

D Compilation error

💡 Hint

Converting a string to a byte slice creates a copy, so modifying the slice does not change the original string.

The byte slice b is a copy of the string s's bytes. Changing b does not affect s.

So s prints as "hello" and b prints as "Hello" after modification.

🧠 Conceptual

advanced

Understanding String Header and Data Pointer

In Go, a string is represented internally by a header containing a pointer and a length. What does the pointer in the string header point to?

A The first byte of the string data in memory

B The last byte of the string data in memory

C The memory address of the string header itself

D The length of the string

💡 Hint

Think about how the string header allows access to the actual characters.

The pointer in the string header points to the first byte of the string data in memory, allowing the string to access its bytes.

🔧 Debug

expert

Diagnose Unexpected Output from String Conversion

Consider this Go code snippet. What is the output and why? package main import "fmt" func main() { s := "你好吗" b := []byte(s) fmt.Println(len(s)) fmt.Println(len(b)) }

DSA Go

package main
import "fmt"
func main() {
    s := "你好吗"
    b := []byte(s)
    fmt.Println(len(s))
    fmt.Println(len(b))
}

A

3
3

B

6
6

C

9
9

D

6
9

💡 Hint

Remember that Go strings are sequences of bytes, but len(s) counts bytes, not characters. Unicode characters may use multiple bytes.

The string "你好吗" has 3 characters (runes) but each Chinese character uses 3 bytes in UTF-8 encoding, totaling 9 bytes.

In Go, len(s) returns the number of bytes, not the number of runes. len(b) for the byte slice also returns 9.

Practice

1. What does a string represent in Go language?
var s string = "hello"

easy

A. A sequence of bytes representing characters

B. A mutable array of characters

C. A pointer to an integer

D. A floating-point number

Solution

1. Step 1: Understand Go string type

   In Go, a string is a sequence of bytes that represent characters, usually UTF-8 encoded.

2. Step 2: Check mutability and type

   Strings in Go are immutable, so they cannot be changed after creation. They are not arrays or pointers to integers.

3. Final Answer:

   A sequence of bytes representing characters -> Option A

4. Quick Check:

   Go strings = immutable byte sequences [OK]

Hint: Remember: Go strings are immutable byte sequences [OK]

Common Mistakes:

• Thinking strings are mutable arrays
• Confusing strings with pointers
• Assuming strings store integers

2. Which of the following is the correct way to declare and initialize a string in Go?

easy

A. var s string = 'hello'

B. var s string = "hello"

C. var s = hello

D. string s = "hello"

Solution

1. Step 1: Check string literal syntax in Go

   Go uses double quotes "" for string literals, single quotes '' are for rune (character) literals.

2. Step 2: Validate declaration syntax

   Correct declaration uses var keyword, type string, and double quotes for value.

3. Final Answer:

   var s string = "hello" -> Option B

4. Quick Check:

   Use double quotes for strings in Go [OK]

Hint: Use double quotes "" for strings, single quotes '' for runes [OK]

Common Mistakes:

• Using single quotes for strings
• Omitting quotes around string value
• Using incorrect variable declaration syntax

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

package main
import "fmt"
func main() {
    s := "GoLang"
    fmt.Println(len(s))
}

medium

A. 6

B. 7

C. 5

D. Error

Solution

1. Step 1: Understand the string value

   The string "GoLang" has 6 characters: G, o, L, a, n, g.

2. Step 2: Use len function on string

   len(s) returns the number of bytes in the string. Since all characters are ASCII, length is 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   len("GoLang") = 6 [OK]

Hint: len() returns byte count for ASCII strings [OK]

Common Mistakes:

• Counting characters incorrectly
• Expecting len() to count runes instead of bytes
• Assuming error due to missing imports

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

package main
import "fmt"
func main() {
    s := "hello"
    s[0] = 'H'
    fmt.Println(s)
}

medium

A. No error; code runs fine

B. Missing import for fmt package

C. Incorrect string declaration syntax

D. Strings are immutable; cannot assign to s[0]

Solution

1. Step 1: Check string mutability in Go

   Strings in Go are immutable, so you cannot change individual bytes like s[0].

2. Step 2: Analyze the assignment statement

   Attempting s[0] = 'H' causes a compile-time error because strings cannot be modified.

3. Final Answer:

   Strings are immutable; cannot assign to s[0] -> Option D

4. Quick Check:

   Strings immutable = no s[0] assignment [OK]

Hint: Remember: Go strings cannot be changed after creation [OK]

Common Mistakes:

• Trying to modify string bytes directly
• Ignoring immutability errors
• Confusing strings with byte slices

5. Given the string s := "Go😊Lang", what will len(s) return and why?

hard

A. 7, because len counts characters

B. 8, because emoji counts as two bytes

C. 10, because emoji is 4 bytes plus other characters

D. 6, because emoji is ignored

Solution

1. Step 1: Analyze string content and encoding

   The string "Go😊Lang" has 7 characters: G, o, 😊, L, a, n, g. The emoji 😊 is a Unicode character encoded in UTF-8 using 4 bytes.

2. Step 2: Calculate total byte length

   Characters G, o, L, a, n, g are 1 byte each (6 bytes). The emoji is 4 bytes. Total bytes = 6 + 4 = 10 bytes.

3. Step 3: Verify len(s) output

   len(s) returns the number of bytes, so it returns 10, not the number of characters.

4. Final Answer:

   10, because emoji is 4 bytes plus other characters -> Option C

5. Quick Check:

   len counts bytes, emoji uses multiple bytes [OK]

Hint: len() counts bytes, not characters; emojis use multiple bytes [OK]

Common Mistakes:

• Assuming len counts characters, not bytes
• Ignoring multi-byte encoding of emojis
• Thinking emoji counts as one byte