一个java实践问题

Question

我碰到这个问题javabat（http://www.javabat.com/prob/p183562）传来：

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

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

Answer 1

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

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

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

Answer 3

它返回假的，因为你的第二个检查只比较它的大个子，这在你的反例，你有一个零。

so 2 < = 0是错误的。

这里是做一个好办法：但

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

这样你确定，你只需要使用尽可能多的大砖，没有更多的，保证达到目标的唯一途径是如果你有足够的小砖块。

Answer 4

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

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

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

Answer 6

这里还有一个实践的问题，我认为这是相当类似这样的问题，只是想我会发布它，看看它是否适合人群：

给予你一个int SO开始 声望和一个高于首发声望的整数SO目标声望。 你只回答问题，所以你可以 获得声望只有10或 15.你也可以投票，所以你也可以失去声望1。什么是 你应该失去的信誉的最低数额达到目标 声誉？

例如： 您开始使用715和要达到888答案是2

增加挑战改变整数为long不使用循环。

Answer 7

这是我最初的答案;它并没有为其他测试工作，但当时我无法弄清楚它不是如何（仍然真的不能），并且正确的答案让我感到厌烦，因为即使它检查出它吸取它的球实际上是有效的，因为某个陈述是错误的。咆哮咆哮咆哮，以及任何在此方式：

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

if(goal<=((big*5)+small) && goal%(big*5)<=small){ 
    return true; 
    } 
    return false; 
} 

正确答案在这里，但它可以吸它：如果小为> =余数，它应该是真实的

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

if(goal<=((big*5)+small) && goal%5<=small){ 
    return true; 
    } 
    return false; 
} 

，并且永远是，如果不是，那么它就不会是真的。为什么我的方式行不通，这种方式的缺陷是什么？是的，前面的陈述（目标< =（（big * 5）+ small））剔除了它不起作用的所有实例，但是我做了这个覆盖语句来取消任何不等于英寸总数的错误，不是为了这个目的，我从迄今为止所有数学科目中的旧数学问题中推导出来，它以最简单的形式分解为：w =（ax + bx）其中w =整数a =数字（in这种情况5）值大于由b表示的数字（在这种情况下为1）的操作，并且x是在这个几何代数问题中最合适地找到的两个值之间的LCF（在这种情况下为1），角度是36度大于两倍的补充角度（x = 2（180-x）+36; x = 396-2x; 3x = 396; x = 132）。通常给出一组数量的提示，但不仅仅是变量。我的问题是什么，它不起作用的地方在哪里？

Answer 8

这是我的答案。

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

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

Answer 9

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

仅使用布尔运算符来检查没有这两个失败的案例!(fail || fail)。明显的，砖块不足以使目标big*5 + small < goal。当目标不是5的球偶数时，不太明显，不足够的小砖块。

Answer 10

公共类砖{

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

}

Answer 11

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

这是它。这是如何完成的。

Answer 12

这里是完美的解决方案：

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

Answer 13

恐怕没有完美的解决方案，但也许有点更容易理解比以往：

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

Answer 14

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

Answer 15

你也可以试试这个：

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