Java Don'；我不明白问题背后的逻辑

我试图理解我的代码有什么问题。 以下是任务和我的代码：

编写一个名为canPack的方法，其中包含三个int类型的参数bigCount、smallCount和goal

• 参数bigCount表示大面粉袋的数量（每袋5公斤）

• 参数smallCount表示小面粉袋的数量（每袋1公斤）

• 参数goal表示组装一个包装所需的面粉千克的目标量

因此，bigCount和smallCount的千克之和必须至少等于目标值。如果可以用目标公斤面粉制作包装，则该方法应返回true

如果金额大于目标金额，请确保仅使用满袋达到目标金额。例如，如果goal=9，bigCount=2，smallCount=0，那么该方法应该返回false，因为每个大袋子都有5公斤，并且不能分割。但是，如果目标=9，bigCount=1，smallCount=5，则该方法应返回true，因为1个完整的bigCount包和4个完整的smallCount包等于目标，如果还有其他包，则可以

如果任何参数为负，则返回false

输入/输出示例：

• canPack（1,0,4）；应该返回false，因为bigCount是1（5公斤的大袋子），目标是4公斤

• canPack（1,0,5）；应该返回true，因为bigCount是1（5公斤的大袋子），目标是5公斤

• canPack（0,5,4）；应该返回true，因为smallCount是5（1公斤的小包），目标是4公斤，我们还有1个包，如上所述是可以的

• canPack（2,2,11）；由于bigCount为2（每袋5公斤），smallCount为2（每袋1公斤），总共12公斤，目标为11公斤，因此应返回真值

• canPack（-3,2,12）；应返回false，因为bigCount为负数

publicstaticbooleancanpack（int-bigCount、int-smallCount、int-goal）{
int bigCountKilos=bigCount*5；
int smallCountKilos=smallCount；
如果（大计数<0 | |小计数<0 | |目标<0）{
返回false；
}否则{
如果（bigCountKilos>=goal&&bigCountKilos%goal==0）{
返回true；
}否则如果（bigCountKilos+smallCountKilos>=goal&&bigCountKilos%goal==0）{
返回true；
}else if（bigCountKilos=目标）{
返回true；
}否则{
返回false；
}
}
}
公共静态void main（字符串[]args）{
系统输出println（canPack（4,18,19））；
}

4,18,19的实例应该返回true，但实际情况并非如此。有人能告诉我我做错了什么吗？

---

提前谢谢

我觉得你找到答案背后的逻辑是不正确的。

if

语句不能涵盖所有情况，也不能每次都给出正确答案

一种基本方法是：

• 当目标>0且bigCount>0时，从目标中减去5，从bigCount中减去1
• 如果目标仍然>0，请检查smallCount是否>=目标。如果是，则返回true，否则返回false

专用静态布尔canPack(
最终整数大计数，
最终整数小计数，
最终积分目标
) {
//返回目标-Math.min（目标/5，bigCount）*5
int bigCountKilo=bigCount*5；
if（bigCountKilo+smallCount*1==目标）{
返回true；
}如果（（bigCountKilo>=goal&&bigCountKilo%goal==0）| |（bigCountKilo>=goal&&goal%5=goal）{
返回true；
}否则，如果（bigCountKilo+smallCount>goal&&goal%bigCountKilo此代码适用于贪婪算法并通过了所有测试用例，请尝试一下：

publicstaticbooleancanpack（int-bigCount、int-smallCount、int-goal）{
//这里我们检查输入是否有效
如果（大计数<0 | |小计数<0 | | |目标<0 | | |（大计数*5+小计数）=5）{
如果（bigCountKilo>0）{
目标-=5；
bigCount-=1；
}否则{
打破
}
}
//同样，这里我们也检查目标是否大于0，然后减去smallCount值
而（目标>0）{
如果（smallCount>0）{
目标-=1；
smallCount-=1；
}否则{
打破
}
}
//如果达到目标，我们将返回true（如果目标变为零）
返回（目标==0）；
}
公共静态布尔canPack（int-bigCount、int-smallCount、int-goal）{
//输入验证。
如果（大计数<0 | |小计数<0 | |目标<0）{
返回false；
}
//为bigCount变量创建一个变量，以kg为单位显示它。
int bigCountInKg=bigCount*5；
if（bigCountInKg如果（结果嘿，解释很简单
我希望您理解上半部分，直到
bigCount
、
smallCount
和
goal

让我们开始吧。。。
让我们假设
goal=9kg
。这意味着您必须制作一个包含9kg面粉的包装。
现在
bigCount=2
（表示10kg）和
smallCount=0

你有多少面粉
（大份*5）+小份=10kg
你有足够的面粉做包装吗？有。
你能做一个9公斤的包装吗？不行。
因为你有两个袋子，每个5公斤，你不能从任何袋子里拿出1公斤

考虑第二种情况
    public static boolean canPack(int bigCount, int smallCount, int goal) {

        int bigCountKilos = bigCount * 5;
        int smallCountKilos = smallCount;

        if (bigCount < 0 || smallCount < 0 || goal < 0) {
            return false;
        } else {

            if (bigCountKilos >= goal && bigCountKilos % goal == 0) {
                return true;
            } else if (bigCountKilos + smallCountKilos >= goal && bigCountKilos % goal == 0) {
                return true;
            } else if (bigCountKilos < goal && bigCountKilos + smallCountKilos >= goal) {
                return true;
            } else {
                return false;
            }
        }
    }

    public static void main(String[] args) {
        System.out.println(canPack(4, 18, 19));
    }

private static boolean canPack(
    final int bigCount,
    final int smallCount,
    final int goal
) {

    // return goal - Math.min(goal / 5, bigCount) * 5 <= smallCount;

    final int numberOfBigNeeded = goal / 5;
    final int numberOfBigUsed = Math.min(numberOfBigNeeded, bigCount);
    final int remainingKilosFromGoalAfterUsingBig = goal - numberOfBigUsed * 5;
    final boolean hasEnoughSmallToCoverRemainingKilosFromGoalAfterUsingBig = remainingKilosFromGoalAfterUsingBig <= smallCount;
    return hasEnoughSmallToCoverRemainingKilosFromGoalAfterUsingBig;
}

int bigCountKilo = bigCount*5;
    if(bigCountKilo+smallCount*1 == goal){
        return true;
    }else if((bigCountKilo>=goal&&bigCountKilo%goal == 0)||(bigCountKilo>=goal&&goal%5<=smallCount)){
        return true;
    }else if(smallCount>=goal){
        return true;
    }else if(bigCountKilo+smallCount>goal&&goal%bigCountKilo<=smallCount){
        return true;
    }else{
        return false;
    }
}

public static boolean canPack(int bigCount, int smallCount, int goal) {
    // Input validation.
    if (bigCount < 0 || smallCount < 0 || goal < 0) {
        return false;
    }
    // Create a variable for the the bigCount variable to show it in kg.
    int bigCountInKg = bigCount * 5;
    
    if (bigCountInKg < goal) {
        int result = goal - bigCountInKg;
        if (result <= smallCount) {
            return true;
        } else {
            return false;
        }
    } else if (bigCountInKg == goal) {
        return true;
    } else if (bigCountInKg > goal) {
        int maxBigCount = goal / 5;
        int result = goal - maxBigCount;
        if (result <= smallCount) {
            return true;
        }
    }
    return false;
}