java实践问题

我在javabat（）中遇到了这个问题：

我们想做一排砖 球门有几英寸长。我们有一个号码 小砖块（每个1英寸）和大砖块 砖（每个5英寸）。如果为，则返回true 有可能通过以下方式实现目标： 从给定的砖块中选择。这 比它看起来和看起来要难一点 无需任何循环即可完成

制砖（3、1、8）→ 正确
制砖（3、1、9）→ 假
制砖（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;
}

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

public boolean makeBricks（int-small、int-big、int-goal）{
如果（目标>小+大*5）
返回false；
否则如果（目标%5==0）
返回目标/5您的逻辑不正确。应该这样做：

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）{
如果（目标<0 | |大<0 | |小<0）{
抛出新的IllegalArgumentException（）；
}否则如果（目标>大*5+小）{
返回false；
}否则，如果（目标%5我认为您可以取消第二次测试。我会尝试以下方法：

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

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

public boolean makeBricks（int-small、int-big、int-goal）{
如果（目标>小+大*5）
返回false；
其他的
返回目标%5返回false，因为您的第二次检查只是将其与BIG进行比较，在反例中，BIG为零

所以第二个测试完全没有必要。第一个测试检查你是否有足够的总长度，并且一切正常

但是第二个测试再次检查你是否有足够的总长度（返回目标/5我尝试了一些其他场景：“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;
 }

public boolean makeBricks（int-small、int-big、int-goal）{
/*没有足够的砖块来进球，所以不要费心了*/
如果（目标>小+大*5）
返回false；
/*我们能用多少块大砖头*/
int bigBricksToUse=Math.min（大，（目标/5））；
/*如果我们用那么多大的，我们有足够的小的吗*/
返回目标-（bigBricksToUse*5）这是我的答案

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

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

私有静态布尔makeBricks（int-small、int-big、int-goal）{
返回（（大*5+小）>=goal）&&（目标%big
私有布尔makeBricks（int-small，int-big，int-goal）{
返回！（大*5+小<目标| |小<目标%5）；
}

仅使用布尔运算符检查两种失败情况是否都存在。
（fail | | fail）
。明显的是，没有足够的砖块使目标
变大*5+变小
。当目标不是5
小
的偶数倍时，不太明显的是，没有足够的小砖块{

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

公共布尔校验方法（int-small、int-big、int-goal）{
如果（目标=大*5）{
返回true；
}否则
返回false；
}
公共静态void main（字符串参数[]）{
砖块=新砖块（）；
System.out.println（brick.checkMethod（10,0,10））；
}

}
私有布尔makeBricks（int-small、int-big、int-goal）
{
如果（目标<0 | |大<0 | |小<0）
{
抛出新的IllegalArgumentException（）；
}
否则返回目标-（5*大+小）以下是完美的解决方案：

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

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

公共静态布尔makeBricks（int-small、int-big、int-goal）{
整数英寸=小+大*5；
如果（总英寸<目标）{
返回false；
}
int BIGINCHENS=大*5；
int smallRequired=目标%5；
如果（smallRequired>small&&bigins！=目标）{
返回false；
}如果（smallRequired=goal | | | smallRequired+bigins==goal | | small+bigins==goal
||小+大英寸==目标）{
返回true；
}如果（大英寸+小英寸>目标）{
如果（小>目标大英寸）{
返回true；
}
}
}
返回false；
}
可能没有完美的解决方案，但可能比之前的解决方案更容易理解：

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

if（目标<0 | |大<0 | |小<0）{
抛出新的IllegalArgumentException（）；
}否则{
int reqBig=目标/5；
int reqSamll=目标%5；
如果（reqBig您也可以尝试以下方法：

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

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

public boolean makeBricks（int-small、int-big、int-goal）{
return goal-big*5这是我在解决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;

}

public boolean makeBricks（int-small、int-big、int-goal）{
//首先，我们检查是否有足够的砖块来达到目标
如果（（小+大*5）>=目标）{
//如果是，那么我们检查是否可以通过使用我们的大砖块来实现目标，以及需要多少小砖块。
if（目标%5
public boolean makeBricks（int-small，int-big，int-goal）{
如果（（目标%5）您可以尝试以下方法：

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

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

函数makeBricks（小、大、目标）{
返回（小*1）+（大*5）>=目标；
}
我不这么认为-例如，您的逻辑将为makeBricks生成true（0、5、4）在这里，你不能用一块五英寸的砖块来制作一个四英寸的球门线。嗯，不，这是当然的。这是java和Python学习网站上的一个实践问题……CODEBATB.COMLY欢迎堆栈溢出！你会考虑添加一些叙述来解释为什么这个代码能工作，什么使它成为T的答案？这个问题？当大砖块的数量超过需要时，这个解决方案就会失败，而且对于
makeBricks（20，0，19）
完美的解决方案没有任何循环，这个解决方案也有一个
/by zero
例外。它在我所有的测试用例中都给了我成功的解决方案。为什么目标%5我添加了一个解释，@Man。
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;
}