How to print out a specific array and return its pointer from a recursive function

I asked a question here before the answer to which i found it myself. But there was an extra requirement.

The exercise goes like this :

We are given an array of float values of size N. Each float value represents a cash flow in a bank account. For example a deposit (when the value is positive) or a withdrawal (when it is negative). The initial balance of the account is equal to zero.

So if the cash flow is (+10, -5, +7, -8) the balances are (0+10)=+10, (10-5)=+5, (5+7)=+12, and (12-8)=+4; thus the maximum and minimum balances
are +12 and +4, with a difference equal to +8

with the same set of cash flows but ordered as (-5, +10, -8, +7) the balances are(0-5)=-5, (-5+10)=+5, (+5-8)=-3, and (-3+7)=+4, with a maximum and a minimum equal to +5 and -5 and a difference is equal to +10.

Using recursion we have to find the best arrangement so that the difference between the maximum and minimum is minimal

This is the code that prints out every permutation

#include <stdio.h>
#include <stdlib.h>

void permutation(float *val,float *sol,float *mark,int n,int pos)
{
    if(pos==n)
    {
        for (int i = 0; i < n; ++i) {
            printf("%.0f ",sol[i]);
        }
        printf("\n");
        return;
    }
    for (int i = 0; i < n; ++i) {
        if(mark[i]==0)
        {
            mark[i]=1;
            sol[pos]=val[i];
            permutation(val,sol,mark,n,pos+1);
            mark[i]=0;
        }
    }
}
int main() {
    float *sol;
    float *val;
    int n=4;
    float *mark;
    mark = calloc(n, sizeof(float ));
    if(mark==NULL)
    {
        exit(1);
    }
    val = malloc(n* sizeof(float ));
    if(val==NULL)
    {
        exit(1);
    }
    val=(float []){+10, -5, +7, -8};
    
    sol=malloc(n* sizeof(float));
    if(sol==NULL)
    {
        exit(1);
    }

    permutation(val,sol,mark,n,0);
    return 0;
}

But as i said how do i print out a specific array in my case the one that the difference between max and min is minimal. Also the exercise requires me to return the pointer of this array. How do i do that as well?

One approach is that, instead of printing during the recursion, perform your calculations on each permutation. If it yields the best result yet, copy the current permutation to an output buffer.

Once all permutations are exhausted, then you print the best one.

Note that in the event where two or more permutations produce the best result, this chooses the first encountered. This means the starting order of the array influences the order of the result.

A cursory, naive example using your algorithm (and VLAs):

#include <float.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

static void print_array(float *data, size_t length)
{
	for (size_t i = 0; i < length; i++)
		printf("%5.1f ", data[i]);
	putchar('\n');
}

static float flow_minmax_diff(float *data, size_t length)
{
	float min = FLT_MAX;
	float max = FLT_MIN;
	float balance = 0;

	for (size_t i = 0; i < length; i++) {
		balance += data[i];

		if (balance > max)
			max = balance;

		if (balance < min)
			min = balance;
	}

	return max - min;
}

static void permutation_actual(
		float *difference,
		float *result,
		float *values,
		float *swap,
		bool *marked,
		size_t length,
		size_t depth)
{
	if (depth == length) {
		float d = flow_minmax_diff(swap, length);

		if (d < *difference) {
			*difference = d;
			memcpy(result, swap, sizeof *swap * length);
		}

		return;
	}

	for (size_t i = 0; i < length; i++) {
		if (marked[i])
			continue;

		marked[i] = true;
		swap[depth] = values[i];
		permutation_actual(difference, result, values, swap, marked, length, depth + 1);
		marked[i] = false;
	}
}

static float best_permutation(float *res, float *values, size_t length)
{
	float temp[length];
	bool markers[length];
	memset(markers, 0, sizeof markers);

	float diff = FLT_MAX;
	permutation_actual(&diff, res, values, temp, markers, length, 0);
	return diff;
}

int main(void)
{
	float values[] = { -8.f, -5.f, 7.f, 10.f };
	size_t length = sizeof values / sizeof *values;
	float best[length];
	float difference = best_permutation(best, values, length);

	printf("Difference: %5.1f\n", difference);
	print_array(best, length);
}

Result:

Difference:   8.0
10.0  -8.0   7.0  -5.0

As for how to "return the pointer of this array", with the example in mind, you could simply allocate (malloc) the resulting array in best_permutation, and return it, instead of feeding it as an argument.

(flow_minmax_diff could always be called on the result.)

As a side note, this

val = malloc(n * sizeof(float));
val = (float []){ +10, -5, +7, -8 };

is two very separate assignments of a float * value to the variable val. This does not perform any kind of "initialization" of the memory located at the address returned by malloc.

The result being that val is a pointer to the first element of an array of automatic storage duration, and the memory allocated by malloc is leaked.

For example:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    float *val = malloc(4 * sizeof(float));
    printf("%p\n", (void *) val);
    val = (float []){ +10, -5, +7, -8 };
    printf("%p\n", (void *) val);
}

0x55bd9c5092a0
0x7ffd138ea010