Why Strings Are a Data Structure Not Just Text in DSA Go - Why It Works

Concept Flow - Why Strings Are a Data Structure Not Just Text

Input: Text String

↓

Store Characters in Array

↓

Access Characters by Index

↓

Traverse Characters

↓

Output or Use String Data

This flow shows how a string is stored as a sequence of characters, accessed by position, and used as a data structure, not just plain text.

Execution Sample

DSA Go

package main

import "fmt"

func main() {
    s := "GoLang"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%c ", s[i])
    }
}

This code loops through each character in the string and prints it, showing string as a sequence of characters.

Execution Table

Step	Operation	Index i	Character Accessed	Output	String State
1	Initialize i=0	0	s[0] = 'G'	Print 'G '	[G, o, L, a, n, g]
2	i=1 < len(s)? Yes	1	s[1] = 'o'	Print 'o '	[G, o, L, a, n, g]
3	i=2 < len(s)? Yes	2	s[2] = 'L'	Print 'L '	[G, o, L, a, n, g]
4	i=3 < len(s)? Yes	3	s[3] = 'a'	Print 'a '	[G, o, L, a, n, g]
5	i=4 < len(s)? Yes	4	s[4] = 'n'	Print 'n '	[G, o, L, a, n, g]
6	i=5 < len(s)? Yes	5	s[5] = 'g'	Print 'g '	[G, o, L, a, n, g]
7	i=6 < len(s)? No	-	-	Loop ends	[G, o, L, a, n, g]

💡 Loop stops when index i reaches length of string, showing string length controls access.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	Final
i	0	1	2	3	4	5	6	6
Character Accessed	G	o	L	a	n	g	-	-
Output		G	G o	G o L	G o L a	G o L a n	G o L a n g	G o L a n g

Key Moments - 3 Insights

Why do we access string characters by index like an array?

Because strings are stored as a sequence (array) of characters, each with a position index, as shown in execution_table rows 1-6.

Why does the loop stop when i equals the string length?

Because valid indexes go from 0 to length-1; accessing index equal to length is out of bounds, shown in execution_table row 7.

Is a string just text or a data structure?

A string is a data structure because it stores characters in order and allows indexed access and traversal, not just plain text, as shown in the concept_flow and execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at Step 4, which character is accessed?

A 'L'

B 'a'

C 'n'

D 'g'

💡 Hint

Check the 'Character Accessed' column at Step 4 in execution_table.

At which step does the loop condition become false?

A Step 6

B Step 5

C Step 7

D Step 1

💡 Hint

Look at the 'Operation' and 'Index i' columns in execution_table to find when i < len(s) is false.

If the string was "Go", how many steps would the loop run?

A 2 steps

B 1 step

C 3 steps

D 4 steps

💡 Hint

Refer to variable_tracker for how i increments and loop stops at length of string.

Concept Snapshot

Strings store characters in order like arrays
Access characters by index starting at 0
Length controls how many characters exist
Strings allow traversal and access
They are data structures, not just text

Full Transcript

Strings are more than just text; they are data structures that store characters in a sequence. Each character has an index starting at zero, allowing us to access characters by position. The length of the string tells us how many characters it contains. In the example code, we loop through each character by index and print it. The loop stops when the index reaches the string length, preventing out-of-bounds access. This shows strings behave like arrays of characters, making them data structures, not just plain text.

Practice

1. Why are strings considered a data structure and not just plain text?

easy

A. Because strings are only used for displaying text on screen

B. Because strings only contain letters and no other characters

C. Because strings are always immutable and cannot be changed

D. Because strings store characters in a specific order and allow access by position

Solution

1. Step 1: Understand what a data structure is

   A data structure organizes data so it can be accessed and modified efficiently. Strings store characters in order, which fits this definition.

2. Step 2: Analyze string properties

   Strings allow access to each character by its position (index), showing they have structure beyond plain text.

3. Final Answer:

   Because strings store characters in a specific order and allow access by position -> Option D

4. Quick Check:

   Strings = ordered characters [OK]

Hint: Strings have order and indexing, so they are data structures [OK]

Common Mistakes:

• Thinking strings only contain letters
• Assuming strings are just for display
• Believing strings cannot be changed

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

easy

A. size(s)

B. length(s)

C. len(s)

D. s.length()

Solution

1. Step 1: Recall Go syntax for string length

   In Go, the built-in function len() returns the length of strings and slices.

2. Step 2: Check other options

   Functions like length(), s.length(), and size() are not valid in Go for strings.

3. Final Answer:

   len(s) -> Option C

4. Quick Check:

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

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

Common Mistakes:

• Using s.length() like in other languages
• Trying length() function which doesn't exist in Go
• Using size() which is invalid for strings

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

package main
import "fmt"
func main() {
  s := "hello"
  fmt.Println(string(s[1]))
}

medium

A. e

B. 104

C. h

D. Error

Solution

1. Step 1: Understand string indexing in Go

   Indexing a string like s[1] returns a byte (uint8) representing the ASCII code of the character.

2. Step 2: Analyze the code output

   string(s[1]) converts the byte to a string of length 1, so it prints 'e'.

3. Final Answer:

   e -> Option A

4. Quick Check:

   string(s[1]) = 'e' [OK]

Hint: s[index] is byte; string(s[index]) converts to char [OK]

Common Mistakes:

• Thinking s[1] prints ASCII number
• Expecting error due to indexing
• Confusing byte and string conversion

4. Identify the error in this Go code snippet:

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

medium

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

B. Missing import for fmt package

C. Incorrect syntax for printing string

D. No error; code runs fine

Solution

1. Step 1: Understand string mutability in Go

   Strings in Go are immutable, meaning you cannot change characters by assigning to an index.

2. Step 2: Analyze the code error

   The line s[0] = 'W' tries to modify the first character, which causes a compile-time error.

3. Final Answer:

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

4. Quick Check:

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

Hint: Strings cannot be changed by index assignment [OK]

Common Mistakes:

• Trying to modify string characters directly
• Ignoring immutability of strings
• Assuming code runs without error

5. Given the string s := "GoLang", which code snippet correctly reverses the string and prints it in Go?

hard

A. s = s[::-1]; fmt.Println(s)

B. for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) }

C. fmt.Println(reverse(s)) // reverse is built-in

D. for i := 0; i < len(s); i++ { fmt.Print(s[len(s)-i]) }

Solution

1. Step 1: Check each option for correctness

   for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) } uses a for loop from the last index to zero, printing each character converted from byte to string. This correctly reverses the string.

2. Step 2: Analyze other options

   fmt.Println(reverse(s)) // reverse is built-in is invalid because Go has no built-in reverse function. s = s[::-1]; fmt.Println(s) uses Python slice syntax, invalid in Go. for i := 0; i < len(s); i++ { fmt.Print(s[len(s)-i]) } has an off-by-one error accessing s[len(s)-i], which causes runtime error.

3. Final Answer:

   for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) } -> Option B

4. Quick Check:

   Reverse string with backward loop [OK]

Hint: Loop backward from len(s)-1 to 0 to reverse string [OK]

Common Mistakes:

• Using Python slice syntax in Go
• Assuming built-in reverse function exists
• Off-by-one errors in indexing