#include <stdio.h>
#include <stdlib.h>
/* Build a range using a simple for‑loop.
This is the most common and flexible approach. */
int* make_range_loop(int start, int end) {
int size = end - start;
int* values = malloc(size * sizeof(int));
for (int i = 0; i < size; ++i) {
values[i] = start + i;
}
return values;
}
/* Build a range using pointer arithmetic.
This keeps the loop tight and expressive. */
int* make_range_pointer(int start, int end) {
int size = end - start;
int* values = malloc(size * sizeof(int));
int* p = values;
for (int n = start; n < end; ++n) {
*p++ = n;
}
return values;
}
/* Build a range using a fixed-size array.
No malloc; size known at compile time.
The caller provides the array and its size. */
void make_range_static(int* arr, int size, int start) {
/* Fill the array with consecutive integers beginning at 'start'. */
for (int i = 0; i < size; ++i) {
arr[i] = start + i;
}
}
/* Build a range 0..end-1 using a manual loop.
Included for completeness. */
int* make_range_zero_to_n(int end) {
int* values = malloc(end * sizeof(int));
for (int i = 0; i < end; ++i) {
values[i] = i;
}
return values;
}
/* Print a list for demonstration. */
void print_range(const char* label, const int* values, int size) {
printf("%s: ", label);
for (int i = 0; i < size; ++i) {
printf("%d ", values[i]);
}
printf("\n");
}
int main(void) {
int start = 1;
int end = 10;
int size = end - start;
int* a = make_range_loop(start, end);
int* b = make_range_pointer(start, end);
int* c = make_range_zero_to_n(end);
/* Static array option: no malloc */
int d[10] = {0}; /* initialized to zero; we will overwrite with a range */
make_range_static(d, 10, 1);
print_range("loop", a, size);
print_range("pointer arithmetic", b, size);
print_range("zero to n", c, end);
print_range("static array", d, 10);
free(a);
free(b);
free(c);
return 0;
}
/*
run:
loop: 1 2 3 4 5 6 7 8 9
pointer arithmetic: 1 2 3 4 5 6 7 8 9
zero to n: 0 1 2 3 4 5 6 7 8 9
static array: 1 2 3 4 5 6 7 8 9 10
*/
