Does passing arrays as parameters causing segmentation fault?

int array[n];

n has size 0 as it has static storage duration

minimum(array[n]);

You do not pass the array only a single element of the array and it invokes undefined behaviours.

• The first one is that you access the array outside its bounds as indexes are from 0 to n - 1.
• then you pass the integer value converted to the pointer. in the code you dereference it which is anothe Undefined Behavior.

In C language you always need to pass the size of the array. Arrays are passed by pointers.

This makes no sense as you will modify the array if you find a number larger or smaller.

   int* min;
   min = &arr[0];

Your function prototypes do not match actual definitions.

This program have more issues than lines. I would suggest to read again pointer and arrays chapter in your favourite C book

int main(void)
{
     
    size_t size;
    printf("Enter the size of your array:\n");
    if(scanf("%zu", &size) != 1) { /* handle error */ }
    int array[size];
    printf("Enter the elements of your array:\n");
    for (size_t i = 0; i < size; i++)
    {
        printf("Enter element %d:\n", i + 1);
        if(scanf("%d", array + i) != 1) { /* handle error */ }
    }
    printf("The smallest element in the array is: %d\n", minimum(array, size));
    printf("The smallest element in the array is: %d\n", maximum(array, size));
}

int minimum(const int *arr, size_t size)
{
    int min = 0;
    if(arr && size)
    {
        min = arr[0];
        
        for (size_t i = 1; i < size; i++)
        {
            if (arr[i] < min)
            {
                min = arr[i];
            }
        }
    }
    return min;
}

int maximum(const int *arr, size_t size)
{
    int min = 0;
    if(arr && size)
    {
        min = arr[0];
        
        for (size_t i = 1; i < size; i++)
        {
            if (arr[i] > min)
            {
                min = arr[i];
            }
        }
    }
    return min;
}

You have many problems here:

1. You've invoking undefined behavior when you declare int array[n]; before n is given a non-zero value, then try to access any elements of said array (technically, I believe C forbids even declaring zero-length arrays, but it's commonly supported to support inlined variable length terminal arrays on a struct). At the point you declared array, n was zero, so no space is allocated to hold anything. Even with C's variable length array support, n needs to hold the correct value first.

2. scanf("%d", array); is repeatedly reading into the first index of array, not sequential indices. You wanted scanf("%d", &array[i]);.

3. minimum(array[n]); and maximum(array[n]); are nonsensical; you're passing the value one past the end of the array, as if it were a pointer (turn on your compiler warnings, this was an obvious one it should have caught). You wanted minimum(array); and maximum(array);

With all that fixed, your working main is:

int main()
{
     
    printf("Enter the size of your array:\n");
    scanf("%d", &n);
    int array[n];  // Declared *after* n has a value

    printf("Enter the elements of your array:\n");
    for (int i = 0; i < n; i++)
    {
        printf("Enter element %d:\n", i + 1);
        scanf("%d", &array[i]); // Initializing sequential elements
    }
    minimum(array);  // Passing pointer to array's first element, not value of past-the end element
    maximum(array);  // Ditto
    return 0;
}

You minimum and maximum functions also have issues, confusing values and pointers.

int* min;
min = &arr[0];

(a long-winded way to spell int *min = arr;) is initially making min a pointer. But *min = *(arr+i); is assigning the value where it points, not changing where it points (so the array gets mutated in the process of finding the minimum value). The code works, it's just since the caller should not expected a logical read-only operation to change their array.

You can do this two ways, either with pointers (to preserve knowledge of where the minimum was found) or with values (ignoring positional info). With pointers, it looks like:

void minimum(const int arr[n]) // Mark const to ensure compiler warns you if you modify it
{
    int *min = arr; // Initialize min to pointer to first element of array
    for (int i = 1; i < n; i++)
    {
        if (arr[i]<*min)  // Compare values, requires dereference because min is a pointer
        {
            min = &arr[i];  // Update to point to newly found minimum value by taking address where value found
        }
    }
    printf("The smallest element in the array is: %d\n", *min); // Print value by dereferencing
}

Alternatively (and typically slightly more efficiently), you operate by value, discarding information about where the element was found:

void minimum(const int arr[n]) // Mark const to ensure compiler warns you if you modify it
{
    int min = arr[0]; // Initialize min to value of first element of array, not a pointer
    for (int i = 1; i < n; i++)
    {
        if (arr[i]<min)  // Compare values, no dereference of min involved because it's a raw value
        {
            min = arr[i];  // Update to newly found minimum value, again, only dereferencing arr, not min
        }
    }
    printf("The smallest element in the array is: %d\n", min);  // Again, min a value, no dereferencing
}

Either works, and neither involves destructively computing minimums or maximums.