How Strings Work Differently Across Languages in DSA C - Debugging & Practice

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this C string code?

Consider this C code snippet that manipulates strings using pointers. What will be printed?

DSA C

char str[] = "hello";
char *p = str;
p++;
printf("%c\n", *p);

A o

B h

C l

D e

💡 Hint

Remember that p++ moves the pointer to the next character in the array.

The pointer p initially points to 'h'. After p++, it points to 'e'. So, *p is 'e'.

❓ Predict Output

intermediate

What happens when you modify a string literal in C?

What will happen when running this C code?

DSA C

char *str = "hello";
str[0] = 'H';
printf("%s\n", str);

A Prints 'Hello'

B Runtime error (segmentation fault)

C Prints 'hello'

D Compilation error

💡 Hint

String literals are stored in read-only memory in many systems.

Modifying a string literal causes undefined behavior, often a segmentation fault at runtime.

🔧 Debug

advanced

Why does this string copy code cause a problem?

Examine this code that copies a string. What is the issue?

DSA C

char *src = "hello";
char dest[5];
strcpy(dest, src);
printf("%s\n", dest);

A src is a pointer, cannot be used with strcpy

B strcpy requires dynamic memory allocation for dest

C dest array is too small, missing space for null terminator

D No problem, prints 'hello'

💡 Hint

Remember that strings in C end with a null character '\0'.

dest has size 5, but 'hello' plus '\0' needs 6 bytes, causing buffer overflow.

🧠 Conceptual

advanced

How are strings stored differently in C compared to higher-level languages?

Which statement best describes how strings work in C compared to languages like Python or Java?

A C strings are arrays of characters ending with a null byte; higher-level languages use objects with length metadata

B C strings are immutable like in Java; Python strings are mutable arrays

C C strings are objects with methods; Python and Java use raw character arrays

D C strings store length explicitly; Python and Java use null-terminated strings

💡 Hint

Think about how C strings know where they end.

C strings are simple arrays ending with '\0'. Python and Java strings are objects that store length and other info.

🚀 Application

expert

What is the output after this pointer manipulation on a C string?

Given the code below, what will be printed?

DSA C

char str[] = "world";
char *p = str + 2;
*(p + 1) = 'x';
printf("%s\n", str);

A worxd

B worxd\0

C woxld

D world

💡 Hint

Look carefully at which character is changed by *(p + 1) = 'x'.

p points to 'r' (index 2). p+1 points to 'l' (index 3). Changing it to 'x' makes string 'worxd'.

Practice

1. In C, how is a string typically represented in memory?

easy

A. As a built-in string object with methods

B. As an array of characters ending with a null character '\0'

C. As a linked list of characters

D. As a fixed-length integer array

Solution

1. Step 1: Understand C string representation

   In C, strings are arrays of characters stored in contiguous memory locations.

2. Step 2: Identify string termination

   C strings end with a special null character '\0' to mark the end of the string.

3. Final Answer:

   As an array of characters ending with a null character '\0' -> Option B

4. Quick Check:

   C strings = char array + '\0' [OK]

Hint: Remember C strings end with '\0' to mark string end [OK]

Common Mistakes:

• Thinking strings are objects with methods like in other languages
• Assuming strings are linked lists in C
• Ignoring the null terminator character

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

easy

A. char str[] = "hello";

B. char[] str = 'hello';

C. string str = "hello";

D. char str = "hello";

Solution

1. Step 1: Check declaration syntax for string literals in C

   In C, strings are arrays of characters, so we declare with char array syntax.

2. Step 2: Validate initialization

   char str[] = "hello"; creates an array with characters 'h','e','l','l','o','\0'.

3. Final Answer:

   char str[] = "hello"; -> Option A

4. Quick Check:

   char array with double quotes = correct string declaration [OK]

Hint: Use char array with double quotes for string literals in C [OK]

Common Mistakes:

• Using single quotes for strings instead of double quotes
• Trying to use 'string' type which doesn't exist in C
• Declaring char as a single character instead of array

3. What will be the output of this C code snippet?

char str[] = "abc";
printf("%c", str[3]);

medium

A. \0 (null character, no visible output)

B. c

C. a

D. Runtime error

Solution

1. Step 1: Understand string indexing in C

   String "abc" is stored as ['a','b','c','\0'] with indices 0 to 3.

2. Step 2: Identify character at index 3

   str[3] is the null terminator '\0', which prints no visible character.

3. Final Answer:

   \0 (null character, no visible output) -> Option A

4. Quick Check:

   Index 3 = '\0' null terminator [OK]

Hint: Remember last char in C string is '\0' at length index [OK]

Common Mistakes:

• Expecting str[3] to print 'c' instead of null
• Assuming runtime error due to out-of-bounds access
• Confusing zero-based indexing

4. Identify the error in this C code snippet that attempts to copy a string:

char src[] = "hello";
char dest[5];
strcpy(dest, src);
printf("%s", dest);

medium

A. strcpy function is not declared

B. printf format specifier should be %c instead of %s

C. src should be a pointer, not an array

D. dest array size is too small to hold the string and null terminator

Solution

1. Step 1: Check size of destination array

   "hello" has 5 characters plus '\0' terminator, total 6 chars needed.

2. Step 2: Compare with dest array size

   dest is declared with size 5, which is too small to hold full string plus '\0'.

3. Final Answer:

   dest array size is too small to hold the string and null terminator -> Option D

4. Quick Check:

   Destination must fit string + '\0' [OK]

Hint: Always allocate space for string length + 1 for '\0' [OK]

Common Mistakes:

• Ignoring null terminator space in array size
• Assuming strcpy needs special declaration
• Confusing %c and %s in printf

5. Given the following C code, what will be the output?

char str1[] = "test";
char *str2 = "test";
str1[0] = 'b';
// str2[0] = 'b'; // commented out
printf("%s %s", str1, str2);

Why is the line modifying str2 commented out?

hard

A. Because str2 is an array and arrays cannot be modified

B. Because str2 is a constant pointer and cannot be changed

C. Because string literals pointed by str2 are stored in read-only memory and cannot be modified

D. Because str2 points to a copy of str1 which is immutable

Solution

1. Step 1: Understand difference between array and pointer to string literal

   str1 is a modifiable array copy of "test"; str2 points to a string literal in read-only memory.

2. Step 2: Explain why modifying str2 causes error

   Modifying string literals is undefined behavior and often causes runtime error, so line is commented out.

3. Final Answer:

   Because string literals pointed by str2 are stored in read-only memory and cannot be modified -> Option C

4. Quick Check:

   String literals are read-only, arrays are modifiable [OK]

Hint: String literals are read-only; arrays can be changed [OK]

Common Mistakes:

• Thinking str2 is a constant pointer (it's pointer to const data)
• Assuming arrays cannot be modified
• Confusing pointer and array behavior