java练习题答案

【问题标题】：A java practice problemjava练习题
【发布时间】：2010-11-06 10:34:20
【问题描述】：

我在javabat中遇到了这个问题(http://www.javabat.com/prob/p183562)：

我们想制作一排砖，是目标英寸长。我们有一个号码小砖（每块 1 英寸）和大砖（每块 5 英寸）。如果返回真可以通过从给定的砖块中选择。这比看起来要难一点可以在没有任何循环的情况下完成。

makeBricks(3, 1, 8) → 真
makeBricks(3, 1, 9) → 假
makeBricks(3, 2, 10) → 真

我想出了这个解决方案：

public boolean makeBricks(int small, int big, int goal) {
    if (goal > small + big * 5)
        return false;
    else if (goal % 5 == 0) 
        return goal / 5 <= big;
    else
        return goal % 5 <= small;
}

这通过了测试。但我自己找到了一个反例：makeBricks(10, 0, 10) -> true。我的逻辑将返回错误。我应该如何修正我的逻辑？或者有更好的方法吗？

【问题讨论】：

这当然是……Java和Python学习网站上的练习题之一……codingbat.com

标签： java logic

【解决方案1】：

我认为您可以删除您的第二个测试。我会试试这个：

public boolean makeBricks(int small, int big, int goal) {
    if (goal > small + big * 5)
        return false;
    else
        return goal % 5 <= small;
}

第一个测试只是检查如果我们将所有块砖排成一排，该行将有多长。如果这不是目标，那么我们知道这是不可能的。

接下来，我们计算小砖的最小数量：goal % 5。例如，如果目标是 8，我们有 1000 块大砖，我们需要多少小砖？ 8 % 5 是 3，所以我们需要 3 块小砖放在行尾。

如果我们有足够的小砖块，并且所有砖块的总长度足够，那么我们就可以达到目标。

【讨论】：

为什么goal%5
我添加了一个解释，@Man。

【解决方案2】：

你的逻辑不正确。应该这样做：

public boolean makeBricks(int small, int big, int goal) {
  if (goal < 0 || big < 0 || small < 0) {
    throw new IllegalArgumentException();
  } else if (goal > big * 5 + small) {
    return false;
  } else if (goal % 5 <= small) {
    return true;
  } else {
    return false;
  }
}

就足够了。这可以简化为：

public boolean makeBricks(int small, int big, int goal) {
  if (goal < 0 || big < 0 || small < 0) {
    throw new IllegalArgumentException();
  } else {
    return goal <= big * 5 + small && goal % 5 <= small;
  }
}

当然，对负目标（无论大小）的健全性检查并不是严格要求的，但建议这样做。如果没有这些检查，则可以通过以下方式简单地获得结果：

public boolean makeBricks(int small, int big, int goal) {
  return goal <= big * 5 + small && goal % 5 <= small;
}

【讨论】：

我不这么认为——例如，你的逻辑会为 makeBricks(0, 5, 4) 产生真值，在这种情况下，你实际上不能只使用一个 5 英寸的球门线-英寸砖。
嗯，不会的。目标

【解决方案3】：

第二个测试完全没有必要。第一个检查您是否有足够的总长度，一切都很好。

但是第二个再次检查你是否有足够的总长度（返回目标 / 5

【讨论】：

【解决方案4】：

我尝试了其他一些场景：“makeBricks(8, 1, 13)” “makeBricks(1, 2, 6)” 在这种情况下，您没有足够的或太多的大砖，但您需要一些。要考虑这两种可能性，您需要以下内容：

public boolean makeBricks(int small, int big, int goal) {
  /* Not enough bricks to make the goal so don't bother */
  if (goal > small + big * 5)
     return false;

  /* How many big bricks can we use */
  int bigBricksToUse = Math.min(big, (goal / 5) );

  /* If we use that many bigs, do we have enough small */
  return goal - (bigBricksToUse * 5) <= small;
 }

【讨论】：

【解决方案5】：

它返回 false，因为您的第二次检查只是将它与大个子进行比较，在您的反例中，您的值为零。

所以 2

这是一个很好的方法：

return (Math.min(goal/5,big)*5 + small) >= goal;

这样，您可以确保只使用所需数量的大砖块，但不会更多，确保达到目标的唯一方法是您有足够的小砖块。

【讨论】：

【解决方案6】：

这是我的答案。

private static boolean makeBricks (int small, int big, int goal) {

    return ((big * 5 + small) >= goal) && (goal % big <= small);
}

【讨论】：

欢迎来到 Stack Overflow！您是否会考虑添加一些叙述来解释为什么此代码有效，以及是什么使它成为问题的答案？
当大砖比需要的多时，此解决方案会失败，并且makeBricks(20, 0, 19) 也有/ by zero 异常

【解决方案7】：

private boolean makeBricks (int small, int big, int goal) {
    return !(big*5 + small < goal || small < goal%5);
}

仅使用布尔运算符来检查是否不存在两种失败情况!(fail || fail)。很明显，没有足够的砖块来实现目标big*5 + small < goal。当目标不是 5 的偶数倍时，不太明显、不够的小砖块small < goal%5。

【讨论】：

【解决方案8】：

公共课砖{

public boolean checkMethod(int small, int big, int goal) {
    if (goal <= small + big * 5 && goal >= big * 5) {
        return true;
    } else
        return false;
}

public static void main(String args[]) {
    Bricks brick = new Bricks();
    System.out.println(brick.checkMethod(10, 0, 10));
}

}

【讨论】：

【解决方案9】：

private boolean  makeBricks(int small, int big, int goal) 
{
    if (goal < 0 || big < 0 || small < 0)
    {
        throw new IllegalArgumentException(); 
    }
    else return goal - (5 * big + small) <= 0;
}

就是这样。就是这样完成的。

【讨论】：

【解决方案10】：

这是完美的解决方案：

public static boolean makeBricks(int small, int big, int goal) {

    int totalInches = small + big*5;
    if(totalInches < goal){
        return false;
    }

    int bigInches= big*5;
    int smallRequired = goal %5;

    if(smallRequired > small && bigInches != goal){
        return false;
    }else if(smallRequired <=small){
        if( bigInches >= goal || smallRequired + bigInches == goal || small +bigInches ==goal 
                || small+ bigInches == goal){
            return true;
        }if(bigInches + small > goal){
            if(small > goal-bigInches){
                return true;
            }
        }

    }
    return false;
}

【讨论】：

【解决方案11】：

可能没有完美的解决方案，但也许比以前的更容易理解：

public boolean makeBricks(int small, int big, int goal) {
    //not testing for invalid input - no invalid input from codingbat.com (in this case)

    int obviousDemandSmall = goal%5;
    if (obviousDemandSmall>small) return false;

    boolean needSmallToMakeUpForBig = (goal/5>big) ? true : false;
    if (!needSmallToMakeUpForBig) return true;

    int superfluousSmallFromFirstGlance = small-obviousDemandSmall;
    int extraSmallCanMakeThisManyBig = superfluousSmallFromFirstGlance/5;
    int missingBig = goal/5-big;
    if (extraSmallCanMakeThisManyBig>=missingBig) return true;

    return false;
}

【讨论】：

【解决方案12】：

if (goal < 0 || big < 0 || small < 0) {
            throw new IllegalArgumentException();
        } else {
            int reqBig = goal / 5;
            int reqSamll = goal % 5;

            if (reqBig <= big && reqSamll <= small)
                return true;
            else if (reqBig > big) {
                int remainingLen = goal - (big * 5);
                if (remainingLen <= small)
                    return true;
                else
                    return false;
            } else
                return false;
        }

【讨论】：

完美的解决方案，没有任何循环。它为我的所有测试用例提供了成功的解决方案。

【解决方案13】：

你也可以试试这个：

public boolean makeBricks(int small, int big, int goal) {
return goal - big * 5 <= small
        && goal % 5 <= small;
}

【讨论】：

【解决方案14】：

这是我在解决codingbat问题时使用的非常简单的解决方案：

public boolean makeBricks(int small, int big, int goal) {

// first we check if we have enough bricks to reach the goal

 if ((small + big * 5) >= goal) {

  //if yes then we check if the goal can be achieved by building it with our big bricks and how much small bricks should be needed then.

   if (goal % 5 <= small) {

    return true;

    }
  }

 return false;

}

【讨论】：

【解决方案15】：

public boolean makeBricks(int small, int big, int goal) {
  if ((goal % 5) <= small && ((Math.floor(goal/5)) <= big || (5*big + small) >= goal))
     return true;
  return false;
}

【讨论】：

【解决方案16】：

你可以试试这个：

function makeBricks(small, big, goal){
    return (small * 1) + (big * 5) >= goal;
}

【讨论】：