How to malloc this array in this function and return the array to the main function?

The error is because you have declared twice in twoSum function.

The argument ret is a red-herring in any case as you can't assign (i.e. can't return via the passed pointer) an allocated pointer to it that the caller can use - because arguments are passed by value in C (see Changing address contained by pointer using function for more info on this). Since you're returning the pointer, you just need to remove the argument and rewrite your function.

int *twoSum(int *nums, int numsSize, int target)
{
    int i, j;
    int *ret = malloc(sizeof(int) * 2);
    if (!ret) return NULL;

    /* In case, no such indexes are found. */
    ret[0] = -1;
    ret[1] = -1;

    for(i = 0;i < numsSize; i++)
    {
        for(j = i+1; j < numsSize; j++)
        {
            if(nums[i] + nums[j] == target)
            {
                ret[0] = i;
                ret[1] = j;
            }
        }
    }
    return ret;
}

As already said you have two declarations of ret. One time in the parameter list

int* twoSum(int* nums, int numsSize, int target, int* ret)

and another at:

int *ret = malloc(sizeof(int)*2);

Beside the suggestion from @usr there is another possible way.

If you want to provide a pointer in the caller to which the dynamic memory allocated in the function twoSum shall point to, declare ret as int** and dereference ret to assign the pointer in the caller by the address of the allocated memory.

Don´t forget to check if the allocation were successful by checking the returned pointer from malloc() for NULL.

The returned pointer from malloc() do not need to be casted.

void twoSum (int* nums, int numsSize, int target, int** ret){

     int i,j;
     *ret = malloc(sizeof(int)*2);

     if (*ret == NULL)
     {
         fputs("Allocation failed!",stderr);
         exit(1);     
     }

     for(i = 0; i < numsSize; i++)
     {
         for(j = i + 1; j < numsSize; j++)
         {
             if(nums[i] + nums[j] == target)
             {
                 (*ret)[0] = i;
                 (*ret)[1] = j;
             }
         }
     }
     return;
}

And call it like:

twoSum(nums_ptr, numsSize, target, &ptr);

ret is coming as an input variable to the function twoSum. You are redeclaring ret in line number 2 with:

int* ret=(int*)malloc(sizeof(int)*2);

Instead you should just do an assignment to it later:

ret=(int*)malloc(sizeof(int)*2);

ret is effectively declared twice in the function twoSum:

• as the name of the last argument with type int *
• as a local variable with the same type.

The error is confusing as both declarations have the same type, but it is nevertheless an error.

Note that the function twoSum should just update the array to which it gets the pointer ret and return 1 for success and 0 for failure, or some other convention. The posted version keeps searching for solutions even if it found one and always returns ret, even if no solutions were found. The caller has no way to tell.

Here is a modified version:

/**
 * Note: The caller must pass a pointer to an array of 2 int
 * the return value is 1 if a solution was found, 0 otherwise
 */
int twoSum(int const *nums, int numsSize, int target, int *ret) {
    int i, j;
    for (i = 0; i < numsSize; i++) {
        for (j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                ret[0] = i;
                ret[1] = j;
                return 1;
            }
        }
    }
    return 0;
}