C# 关于数组大小的面试练习，即我可以'；不要使用arraylist、链表或任何标准列表类

自从我使用了花哨的IDE和C#之后，我对脑筋急转弯的问题就变得生疏了。我对这个问题有一个解决方案，但我真正的问题是我应该如何处理数组大小？假设我不能使用列表。这是用C写的

数组大小可能太小，或者在当前状态下只是浪费内存。我没有检查负数硬币等，所以我们可以只关注算法。所以我想去掉这一行：

double[]minList=newdouble[1000]

以下是面试问题，返回总和等于某个值的最小硬币数（-1，如果不可能：

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;
}

publicstaticmain（字符串[]args）{
双[]币={0.01,0.05,0.10,0.25}；
控制台写线（MinnumberOfcinstosum（0.24，硬币））；
} 
公共静态货币（双和，双[]硬币）
{
double[]minList=新的double[1000]；
minList[0]=总和；
for（int i=1；i=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）
{
返回i；
}             
}
返回-1；
}

好吧，下面是一个包含你们所说内容的答案（尽管它不会返回-1，如果没有找到）：

private static int minnumberOfcinstosumrecursiveDecimalVersion（十进制和，十进制[]硬币）
{
十进制缓冲区=总和；
对于（int i=0；i=0）
{
buffer=Math.Min（buffer，sum-coins[i]）；
}
}
如果（缓冲区==sum&&sum==0m）
返回0；
如果（缓冲区==总和和总和！=0m）
{
返回Int32.MinValue；
}
int result=1+MinnumberOfConstosumRecursiveDecimalVersion（数学最小值（缓冲区，总和），硬币）；
返回结果；
}

然而，我真正的问题是，当我事先不知道数组的大小时，如何处理数组的大小。顺便说一句，谢谢你的小数点注释…那在面试时会很尴尬

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);
}

public int-MinNumberForCoinSum（int-sum，十进制[]硬币）{
//我假设有一个自定义的Util类，但它将检查null、empty或任何其他业务需求
foreach（VerificationUtil.GetArrayVerifications（）中的var验证）{
验证。验证（硬币）；
}
如果（总和<0）{抛出新的InvalidArgumentException（））；}
返回MinnumberOfcinstosumrecursiveDecimalVersion（金额，硬币）；
}
处理未知数组大小的经典解决方案是使用初始容量，然后在容量满时开始调整大小。生长因子通常为2。这就是.NET framework中大多数不断增长的数据结构（列表、堆栈、队列等）所做的。
请原谅我的话：你太离谱了。问题与调整数组大小无关。这里有一个解决方案

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

使用

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

编辑以处理INT大小写：

在这种情况下，我建议重载函数。在下面加上

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

我认为这个问题根本不需要数组——它只是递归的。而且，使用double将一事无成。在你们的面额中，只有0.25是完全可以代表的
decimal
是您的朋友。这并不能回答您的问题，但就我个人而言，我不会将其作为数组。我会通过按值对货币列表排序，降序，将数量除以当前货币的值来完成。甚至比十进制更好的是，使用整数
int[]硬币={1,5,10,25}
我很好奇他们是否会向你扔“假”硬币。拥有
coins={1,5,8,10,25}
将产生
sum=24
的错误结果。感谢您的评论。这个问题是为了说明一个我忘记了的一般概念。我真的不在乎面试的问题。我在重新学习动态规划，这个问题就在我的脑海里。显然，我选择了一个糟糕的问题作为例子。它是否应该处理这样的情况：coins={1,2,6,7}，sum=12？@fgb，在这种情况下，我建议重载该方法。请看我文章中的编辑。谢谢，这就是我想要的答案。
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