Leetcode C program, two numbers in array that add to target

I am trying to solve a Leetcode problem using C, and for some reason the Output of my program is showing an empty array. The challenge is to write a function that returns an array consisting of the indices of two numbers in an array that sum to a target number. I solved it with Python, but now I am trying to solve it with C. What am I missing? Does it have something to do with returnSize?

Note: The constraints say there will be only one answer (two numbers that add up to the target) in each array for each target.

The solution I have tried is as follows:

/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int* answer;
    answer = malloc(2*sizeof(int));

    // Success flag flips when two ints are identified
    bool success = false;

    // Look through every element of nums
    for(int first_number = 0; first_number < numsSize; first_number++)
    {
        // If index is at end of array, do not check further.
        if(first_number < numsSize)
        {
            // For each number in array, look at all of the numbers after it
            for(int second_number=(first_number + 1); second_number < numsSize; second_number++)
            {
                if((nums[first_number] + nums[second_number] == target))
                {
                    answer[0] = first_number;
                    answer[1] = second_number;
                    // Flip success flag
                    success = true;
                }
            }
        }

        // Check success flag and break. No need to check further.
        if(success){
            break;
        }
    }

    return answer;
}

<b>Update</b><br/>
Answered by Fe2O3. Thank you. If anyone comes across this post, read Fe2O3's answer. WhozCraig also gives a good explanation of the problem. It turns out int *returnSize is a pointer to a variable that stores the size of the output array. I guess the size of dynamically allocated arrays can't be determined as easily as statically allocated arrays (e.g. int returnSize[2]). Fe2O3 also has some good things to say about the implementation of the Leetcode answer and not limiting oneself to standard answers. He gave multiple solutions that work. I hope this helps.

Having bitten into this apple, I feel compelled to demonstrate how this function might be written by one with more experience:

int *twoSum( int *nums, int numsSize, int target, int *returnSize ) {
	*returnSize = 0; // default

	for( int i = 0; i < numsSize; i++ )
		for( int j = i + 1; j < numsSize; j++ )
			if( nums[ i ] + nums[ j ] == target ) {
				int *answer = malloc( 2 * sizeof *answer );
                /* Omitting verification of malloc success for brevity */
				answer[0] = i;
				answer[1] = j;
                *returnSize = 2;
				return answer;
			}

	return NULL;
}

It's a silly (Leetcode) problem.<br>
The caller should provide the array (could be stack instead of heap allocation) for the two indices (if found). The function would "know" it can write two integer indices into that array IF a pair is located. Then the function merely returns true or false as to whether it had success or not...

EDIT<br>
Longer response to OP question below:

A minor change to the Leetcode problem might take this form. Notice that the "return array" exists on the stack in the function main() (without needing the heap allocation.) The function needs 4 parameters and returns true/false if it was able to put the two desired values into the 2 element array.

int main(){
	const int arr[] = { 1, 2, 3, 4, 9 };
	const int arrSz = sizeof arr/sizeof arr[0];
	const int target = 4 + 9; // last two values
	int inds[2] = { 0 }; // ALWAYS initialise variables

	if( twoSum( arr, arrSz, target, inds ) )
		print( "[%d, %d]\n", inds[0], inds[1] );
	else
		print("Error\n");
	return 0;
}

UPDATE:<br>
Bothered by the OP reference to "future job interview questions", this answer needs to be revisited.

Below is a "general purpose" version of the function that disregards the "promise" that only one pair of array elements may satisfy the task. The following will grow the array being returned if multiple pairs are found.

Further, (and this is the "job interview" aspect), the solution should recognise that there was no restriction that each of any pair found had to be distinct. In other words, one element + its own value may be a legitimate solution. It is unwise to assume... This sensitivity and "thinking outside the box" is often what potential employers are seeking. It is the coder who thinks only "inside the box" who will introduce bugs into code.

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

// 0 == allow arr[X] + arr[X] == target
// 1 == only distinct elements to be considered
#define ONLY_DIFF 1

int *twoSum( int *nums, int sz, int target, int *rs ) {
	// Begin with no pairs
	int *retArr = NULL;
	*rs = 0;

	for( int i = 0; i < sz; i++ )
		for( int j = i + ONLY_DIFF; j < sz; j++ )
			if( nums[ i ] + nums[ j ] == target ) {
				int *hope = realloc( retArr, (*rs + 2) * sizeof *hope );
				if( hope == NULL ) {
					fprintf( stderr, "realloc failure\n" );
					exit( EXIT_FAILURE );
				}
				retArr = hope;
				*rs += 2;
				retArr[ *rs - 2 ] = i;
				retArr[ *rs - 1 ] = j;
			}

	return retArr;
}