Pointers and arrays in C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pointer arithmetic with arrays

What is the output of this C code snippet?

C

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40};
    int *p = arr;
    printf("%d\n", *(p + 2));
    return 0;
}

A 30

B 20

C 40

D 10

💡 Hint

Remember that pointer arithmetic moves by the size of the data type.

The pointer p points to the first element of arr. Adding 2 moves it to the third element (index 2), which is 30.

❓ Predict Output

intermediate

Value of pointer after increment

What will be the value printed by this code?

C

#include <stdio.h>

int main() {
    char str[] = "hello";
    char *p = str;
    p++;
    printf("%c\n", *p);
    return 0;
}

A h

B o

C l

D e

💡 Hint

Incrementing a pointer moves it to the next character.

Initially, p points to 'h'. After p++, it points to 'e', so *p is 'e'.

🔧 Debug

advanced

Identify the error in pointer usage

What error does this code produce when compiled or run?

C

#include <stdio.h>

int main() {
    int *p;
    *p = 5;
    printf("%d\n", *p);
    return 0;
}

A Compilation error: uninitialized pointer

B Prints 5

C Segmentation fault (runtime error)

D Undefined behavior but no error

💡 Hint

Consider what happens when you dereference a pointer that has not been assigned a valid address.

Pointer p is uninitialized and points to an unknown memory location. Writing to *p causes a segmentation fault at runtime.

❓ Predict Output

advanced

Output of pointer to array and sizeof

What is the output of this code?

C

#include <stdio.h>

int main() {
    int arr[5] = {1,2,3,4,5};
    int (*p)[5] = &arr;
    printf("%zu\n", sizeof(p));
    return 0;
}

A 8

B 20

C 4

D 5

💡 Hint

sizeof(p) gives the size of the pointer, not the array it points to.

p is a pointer to an array of 5 ints. sizeof(p) returns the size of the pointer itself, typically 8 bytes on 64-bit systems.

🧠 Conceptual

expert

Number of elements accessed via pointer arithmetic

Given the code below, how many elements of the array can be safely accessed using the pointer p?

C

#include <stdio.h>

int main() {
    int arr[4] = {10, 20, 30, 40};
    int *p = arr + 1;
    // How many elements can be accessed safely via p?
    return 0;
}

A 4

B 3

C 2

D 1

💡 Hint

Pointer p points to the second element. Count elements from there to the end.

p points to arr[1]. The array has 4 elements total, so elements at indices 1, 2, and 3 can be accessed safely, totaling 3 elements.

Practice

1. What does a pointer to an array in C typically store?

easy

A. The address of the first element of the array

B. The total number of elements in the array

C. The sum of all elements in the array

D. The value of the last element in the array

Solution

1. Step 1: Understand pointer basics

   A pointer stores a memory address, not values or counts.

2. Step 2: Pointer to array points to first element

   In C, a pointer to an array points to the first element's address.

3. Final Answer:

   The address of the first element of the array -> Option A

4. Quick Check:

   Pointer = first element address [OK]

Hint: Pointers hold addresses, not values or counts [OK]

Common Mistakes:

• Thinking pointer stores array size
• Confusing pointer with array value
• Assuming pointer stores last element

2. Which of the following is the correct way to declare a pointer to an integer array in C?

easy

A. int ptr[];

B. int *ptr;

C. int &ptr;

D. int ptr*;

Solution

1. Step 1: Recall pointer declaration syntax

   In C, a pointer to int is declared as int *ptr;

2. Step 2: Check other options for syntax errors

   int ptr[] declares an array, not a pointer; int &ptr is invalid in C; int ptr* is incorrect syntax.

3. Final Answer:

   int *ptr; -> Option B

4. Quick Check:

   Pointer syntax uses * before variable [OK]

Hint: Pointer declaration uses * before variable name [OK]

Common Mistakes:

• Using array syntax instead of pointer
• Confusing C++ reference (&) with pointer
• Placing * after variable name incorrectly

3. What is the output of the following C code?

int arr[] = {10, 20, 30};
int *p = arr;
printf("%d", *(p + 1));

medium

A. 10

B. 30

C. Garbage value

D. 20

Solution

1. Step 1: Understand pointer arithmetic

   p points to arr[0], so p + 1 points to arr[1].

2. Step 2: Dereference pointer at p + 1

   *(p + 1) gives value at arr[1], which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   *(p+1) = arr[1] = 20 [OK]

Hint: Pointer + 1 moves to next array element [OK]

Common Mistakes:

• Confusing *(p+1) with *p
• Assuming pointer arithmetic adds 1 byte
• Expecting arr[0] value instead

4. Identify the error in this C code snippet:

int arr[3] = {1, 2, 3};
int *p = arr + 3;
printf("%d", *p);

medium

A. Missing semicolon after array declaration

B. Array size is incorrect

C. Pointer points outside array bounds causing undefined behavior

D. Pointer declaration syntax is wrong

Solution

1. Step 1: Analyze pointer assignment

   arr + 3 points one element past the last array element (out of bounds).

2. Step 2: Dereferencing out-of-bounds pointer

   *p accesses invalid memory, causing undefined behavior.

3. Final Answer:

   Pointer points outside array bounds causing undefined behavior -> Option C

4. Quick Check:

   Pointer out of array range = error [OK]

Hint: Pointer must stay within array limits [OK]

Common Mistakes:

• Ignoring pointer out-of-bounds access
• Thinking array size is wrong
• Confusing pointer syntax errors

5. Given the code below, what will be printed?

int arr[] = {5, 10, 15, 20};
int *p = arr;
for(int i = 0; i < 4; i++) {
    printf("%d ", *(p + i));
}

hard

A. 5 10 15 20

B. 20 15 10 5

C. 5 5 5 5

D. Compilation error

Solution

1. Step 1: Understand the loop and pointer arithmetic

   Loop runs i from 0 to 3, *(p + i) accesses arr[i].

2. Step 2: Print each element in order

   Values printed are arr[0]=5, arr[1]=10, arr[2]=15, arr[3]=20.

3. Final Answer:

   5 10 15 20 -> Option A

4. Quick Check:

   Pointer + i accesses arr[i] in order [OK]

Hint: Pointer + i accesses array element i [OK]

Common Mistakes:

• Assuming reverse order print
• Printing same element repeatedly
• Expecting syntax error