How Strings Work Differently Across Languages in DSA Go - Visual Walkthrough

Concept Flow - How Strings Work Differently Across Languages

Input String

↓

Language String Type

↓

Memory Representation

↓

Operations: Access, Modify, Length

↓

Output or Error

Shows how input strings are handled differently by each language's string type, affecting memory and operations.

Execution Sample

DSA Go

package main
import "fmt"

func main() {
    s := "hello"
    fmt.Println(len(s))
    s = "world"
    fmt.Println(s)
}

Creates a string, prints its length, changes it, and prints the new string.

Execution Table

Step	Operation	String Value	Memory Representation	Notes
1	Create string s = "hello"	"hello"	Immutable byte array with UTF-8 encoding	String stored as bytes, immutable
2	Print length len(s)	5	N/A	Length counts bytes, 5 characters
3	Assign s = "world"	"world"	Immutable byte array with UTF-8 encoding	New string assigned, old string unchanged
4	Print s	"world"	N/A	Prints new string value
5	End	N/A	N/A	Execution complete

💡 All operations complete; strings are immutable and reassigned by value.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
s	undefined	"hello"	"world"	"world"

Key Moments - 3 Insights

Why can't we change a character inside the string s directly?

Because strings in Go are immutable byte arrays, so modifying a character directly is not allowed (see Step 1 and Step 3 in execution_table).

Why does len(s) return 5 for "hello"?

Because len counts the number of bytes in the UTF-8 encoded string, which equals the number of characters here (Step 2).

What happens to the old string when s is assigned a new value?

The old string remains unchanged in memory until garbage collected; s points to the new string (Step 3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of s after Step 1?

A "hello"

B "world"

C undefined

D empty string

💡 Hint

Check the 'String Value' column at Step 1 in execution_table.

At which step does s change from "hello" to "world"?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Operation' and 'String Value' columns in execution_table.

If Go strings were mutable, which step would be different?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Consider the assignment operation and memory representation in execution_table Step 3.

Concept Snapshot

Go strings are immutable sequences of bytes encoded in UTF-8.
Length counts bytes, not characters.
Strings cannot be changed in place; reassignment creates new strings.
Operations like indexing return bytes, not runes.
Understanding immutability helps avoid errors when modifying strings.

Full Transcript

This visualization shows how strings in Go work differently compared to some other languages. When you create a string like "hello", it is stored as an immutable byte array encoded in UTF-8. The length function returns the number of bytes, which matches the number of characters for simple ASCII strings. You cannot change a character inside the string directly because strings are immutable. Instead, when you assign a new string like "world" to the same variable, the old string remains unchanged in memory, and the variable points to the new string. This behavior is important to understand to avoid confusion when working with strings in Go or comparing with other languages where strings might be mutable or represented differently.

Practice

1. In Go, what is the type of a string internally?
var s = "hello"

easy

A. A sequence of bytes representing UTF-8 encoded characters

B. An array of Unicode code points (runes)

C. A linked list of characters

D. A pointer to a null-terminated character array

Solution

1. Step 1: Understand Go string representation

   Go strings are immutable sequences of bytes, typically UTF-8 encoded.

2. Step 2: Compare with other languages

   Unlike some languages that use arrays of Unicode code points, Go uses bytes internally.

3. Final Answer:

   A sequence of bytes representing UTF-8 encoded characters -> Option A

4. Quick Check:

   Go strings = UTF-8 bytes [OK]

Hint: Remember Go strings are byte sequences, not rune arrays [OK]

Common Mistakes:

• Thinking Go strings store runes directly
• Assuming null-terminated strings like C
• Confusing with linked list or array types

2. Which of the following is the correct way to get the length of a string in Go?
s := "hello"

easy

A. length(s)

B. s.length()

C. len(s)

D. s.len

Solution

1. Step 1: Recall Go built-in function for length

   Go uses the built-in function len() to get the length of strings and slices.

2. Step 2: Check other options

   Methods like s.length() or s.len do not exist in Go; length(s) is not valid syntax.

3. Final Answer:

   len(s) -> Option C

4. Quick Check:

   Use len() for string length in Go [OK]

Hint: Use len() function to get string length in Go [OK]

Common Mistakes:

• Using method calls like s.length() from other languages
• Trying to access length as a property
• Using undefined functions like length()

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

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

medium

A. 3

B. 6

C. 4

D. 5

Solution

1. Step 1: Analyze string content and encoding

   The string "Go😊" has 'G' and 'o' as 1 byte each, and the emoji '😊' is a 4-byte UTF-8 character.

2. Step 2: Calculate total byte length

   Total bytes = 1 (G) + 1 (o) + 4 (😊) = 6 bytes.

3. Step 3: Check len() output

   len(s) returns the number of bytes, so output is 6.

4. Final Answer:

   6 -> Option B

5. Quick Check:

   len() counts bytes, not characters [OK]

Hint: len() returns bytes count, not character count [OK]

Common Mistakes:

• Assuming len() returns number of characters
• Ignoring multi-byte UTF-8 characters
• Confusing bytes with runes

4. Identify the error in this Go code that tries to print each character of a string:

package main
import "fmt"
func main() {
  s := "Go"
  for i := 0; i < len(s); i++ {
    fmt.Println(s[i])
  }
}

medium

A. It prints byte values, not characters

B. Syntax error in for loop

C. s[i] is invalid syntax

D. Missing import for fmt

Solution

1. Step 1: Understand s[i] in Go strings

   Accessing s[i] returns the byte at index i, not a character or string.

2. Step 2: Check output of fmt.Println(s[i])

   It prints the numeric byte value (ASCII code), not the character itself.

3. Final Answer:

   It prints byte values, not characters -> Option A

4. Quick Check:

   s[i] = byte, prints number [OK]

Hint: s[i] gives byte, convert to rune or string to print char [OK]

Common Mistakes:

• Expecting s[i] to print characters directly
• Ignoring byte vs rune difference
• Assuming syntax error where none exists

5. How can you correctly iterate over each Unicode character in a Go string to print them?
Choose the correct code snippet.

hard

A. for i := 0; i < len(s); i++ { fmt.Println(string(s[i])) }

B. for i := range s { fmt.Println(s[i]) }

C. for i, c := range s { fmt.Println(s[i]) }

D. for _, r := range s { fmt.Println(string(r)) }

Solution

1. Step 1: Understand iteration over strings in Go

   Using 'for _, r := range s' iterates over runes (Unicode code points), not bytes.

2. Step 2: Check printing each character

   Converting rune 'r' to string prints the actual character correctly.

3. Step 3: Analyze other options

   for i := 0; i < len(s); i++ { fmt.Println(string(s[i])) } prints bytes as strings, which may break multi-byte chars; C and D print bytes, not runes.

4. Final Answer:

   for _, r := range s { fmt.Println(string(r)) } -> Option D

5. Quick Check:

   Use range to get runes for correct Unicode iteration [OK]

Hint: Use 'for _, r := range s' to iterate Unicode chars [OK]

Common Mistakes:

• Iterating by byte index instead of runes
• Printing bytes as characters causing errors
• Confusing index and rune variables