I've become rusty at the brain teaser questions since I have been using fancy IDEs and C#. I have a solution for this question, but my real question is How should I deal with the array size? Assuming I can't use a list. This is written in C#.

The array size could be too small, or just be a waste of memory in its current state. I left out checks for negative coins, etc. so we could just focus on the algorithm. So I want to get rid of this line: double [] minList = new double[1000];

Here's the interview question, return the minimum number of coins that sum to a value (-1 if impossible:

public static Main(string [] args) {
    double[] coins = {0.01, 0.05, 0.10, 0.25};
    Console.WriteLine(MinNumberOfCoinsToSum(0.24, coins));
} 

public static int MinNumberOfCoinsToSum(double sum, double [] coins)
{
    double [] minList = new double[1000];

    minList[0] = sum;

    for (int i = 1; i < minList.Length; i++)
    {
        double buffer = minList[i-1];
         for (int j = 0; j < coins.Length; j++)
         {
             if(minList[i-1] - coins[j] >= 0.0)
             {
                    buffer = Math.Min(buffer, minList[i-1] - coins[j]);
             }
          }

          minList[i] = Math.Min(minList[i-1], Math.Round(buffer, 2));

          if (minList[i] == 0.0)
          {
                return i;
          }             
     }
      return -1;
}

Well Here's an answer taking in what you guys said (though it doesn't return -1 if not found):

private static int MinNumberOfCoinsToSumRecursiveDecimalVersion(decimal sum,  decimal [] coins)
    {
        decimal buffer = sum;
        for(int i = 0; i < coins.Length; i++)
        {
            if(sum - coins[i] >= 0)
            {
                buffer = Math.Min(buffer, sum - coins[i]);
            }
        }
        if (buffer == sum && sum == 0m)
            return 0;

        if(buffer == sum && sum != 0m)
        {
            return Int32.MinValue;
        }
        int result = 1 + MinNumberOfCoinsToSumRecursiveDecimalVersion(Math.Min(buffer, sum),  coins);
        return result;
    }

However my real is question is how do I deal with an array size when I do not know the size beforehand. Thanks btw for the decimal note... that would have been embarrassing at an interview.

public int MinNumberForCoinSum(int sum, decimal [] coins) {
    // I assume there is a custom Util class, but it would be checking null, empty, or any other business requirement
    foreach(var verification in VerificationUtil.GetArrayVerifications()) {
        verification.Verify(coins);
    }

    if(sum < 0 ) { Throw new InvalidArgumentException()); }

    return MinNumberOfCoinsToSumRecursiveDecimalVersion(sum, coins);
}

• c#
• arrays
• dynamic

The classic solution to deal with unknown array sizes is to use an initial capacity and then start resizing when it gets full. The growth factor is typically 2. This is what most of the growing data structures in the .NET framework do (list, stack, queue etc.)

Forgive if I sound obnoxious: you are way off. The question has nothing to do with resizing arrays. Here is a solution.

public static int numberOfCoins(double[] coins, double sum){
    int total = 0;
    Arrays.sort(coins);
    int amount = (int)(sum*100);//convert to int for precision
    for(int i=coins.length-1; i>=0 && amount > 0; i--){
        int coin = (int)(100*coins[i]);//convert to int for precision
        total+=amount/coin;
        amount%=coin;
    }
    if(amount>0)
       return -1;
    return total;
}//numberOfCoins

Test the code with

public static void main(String... args){
    double[] den = {0.01,.10,.05,.25};
    System.out.println(numberOfCoins(den,1.65));
}

EDIT TO HANDLE INT CASE:

In that case I recommend overloading the function. by adding below as well

public static int numberOfCoins(int[] coins, int sum){
    int total = 0;
    Arrays.sort(coins);
    int amount = sum;
    for(int i=coins.length-1; i>=0 && amount > 0; i--){
        total+=amount/coins[i];
        amount%=coins[i];
    }
    if(amount>0)
        return -1;
    return total;
}//numberOfCoins