Language FoundationsC Programming Deep DiveEasy

Pointer Arithmetic Array Walk

Master the fundamental concepts of c programming deep dive through this focused micro-challenge.

~30 minutes C Programming Deep Dive Ready to learn

Topic Overview

Pointers Scale by Type

In C, a pointer is not just an address. When you write ptr++, the CPU advances by sizeof(*ptr) bytes, not by one. An int* on x86-64 moves 4 bytes per increment; a char* moves 1. This is why arr[i] desugars to *(arr + i) and why the Linux kernel walks buffers with pointer comparisons instead of index variables.

Walking an Array Without Indexing

The idiomatic loop uses a start pointer, an end pointer one past the last element, and strict less-than comparison:

c
Loading…

arr + n points one past the last valid element (valid in C, do not dereference it)
p < end avoids off-by-one errors that p <= arr+n-1 invites
Reverse in place swaps from both ends with two pointers walking inward

For this exercise, you will implement sum_array, max_array, reverse_array, and count_occurrences using only *, ++, and pointer comparison. This task asks you to internalize the scaling rule, because every buffer walk in SQLite, glibc, and kernel code is this pattern with a different type size.

Keep the relevant man page, ABI doc, or Rust reference chapter open while you work. When your output disagrees with the reference implementation on the same machine, the mismatch is usually an alignment rule, an off-by-one terminator, or a register slot you misread in GDB.

Implementation Task

Your Task

Process an array using only pointer arithmetic: walk from p = arr while p < arr + n, dereference with *p, and never write arr[i] in the four functions below. Printing may use any style.

Implement:

int sum_array(int *arr, int n);
int find_max(int *arr, int n);
void reverse_array(int *arr, int n), which swaps with two pointers moving toward each other;
int count_occurrences(int *arr, int n, int value).

Use them on the fixed array {3, 1, 4, 1, 5, 9, 2, 6}.

Input

One word: sum, max, reverse or count. Anything else (or empty input) runs all four in order. The input only picks the mode: the array is always the fixed one above, and nothing else is read.

Output

Each mode starts from the original array.

mode	what it computes	output
`sum`	`sum_array(arr, 8)`	`Original array: [3, 1, 4, 1, 5, 9, 2, 6]` then `Sum: <sum>`
`max`	`find_max(arr, 8)`	`Max: <largest element>`
`reverse`	`reverse_array(arr, 8)`, then print the array	`Reversed array: [<elements, last first>]`
`count`	`count_occurrences(arr, 8, 1)`: how many elements equal the value 1	`Count of 1s: <count>`
anything else	all four, in the order above	the `sum` lines, the `Max` line, the `Reversed array` line, then the `Count of 1s` line (counted on the reversed array, which holds the same elements)

The value counted is always 1, so count mode calls count_occurrences with value = 1. Arrays print as [a, b, c]: elements separated by a comma and a space, inside square brackets.

Example

Input:

c
Loading…

Output:

c
Loading…

Requirements

No subscripts in the four functions: only *p, p++, p-- and pointer comparisons.
Reverse in place with a left and a right pointer.

Hidden tests cover the maximum, the reversal and the occurrence count.