java - java练习题

Question

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

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

makeBricks(3, 1, 8) → true
makeBricks(3, 1, 9) → false
makeBricks(3, 2, 10) → true

我想出了这个解决方案：

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。我的逻辑将返回错误。我应该如何修正我的逻辑？还是有更好的方法来做到这一点？

score 18 · Accepted Answer

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

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 个小砖。

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

score 11 · Accepted Answer

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

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

score 4 · Accepted Answer

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

但是第二个再次检查您是否有足够的总长度（返回目标 / 5 <= 大；）但这忽略了小砖块增加的长度。问题是您正在检查它是否是 5 的倍数，并自动假设如果是，您将只使用大块。实际上，您可以改用五块小砖。（或者，在你的例子中，10 个小砖块。）最后一次检查是正确的，假设你有足够的长度，测试你是否有足够的粒度来获得正确的长度。

score 1 · Accepted Answer

它返回 false ，因为您的第二次检查仅将其与大人物进行比较，在您的反例中，您的大人物为零。

所以 2<=0 是错误的。

这是一个很好的方法：

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

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

score 1 · Accepted Answer

我尝试了其他一些场景：“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;
 }

score 0 · Accepted Answer

这是我的回答。

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

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

score 0 · Accepted Answer

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。

score 0 · Accepted Answer

公共课砖{

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

}

score 0 · Accepted Answer

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

就是这个。这就是它的完成方式。

score 0 · Accepted Answer

这是完美的解决方案：

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

score 0 · Accepted Answer

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

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

你也可以试试这个：

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

score 0 · Accepted Answer

这是我在解决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;

}

score 0 · Accepted Answer

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

score 0 · Accepted Answer

你可以试试这个：

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

java - java练习题

16 回答 16

Related

Reference