Dev Faq
-2
votes

Ne comprenez pas la logique derrière le problème

J'essaie de comprendre quel est le problème avec mon code. Voici la tâche et mon code:

Écrivez une méthode nommée CANPACK avec trois paramètres de type Int nommé BigCount, SmallCount et But.

  • Le paramètre BigCount représente le nombre de grands sacs à farine (5 kilos chacun).

  • Le paramètre SmallCount représente le nombre de petits sacs à farine (1 kilo chacun).

  • L'objectif de paramètre représente l'objectif de kilos de farine nécessaire pour assembler un package.

    Par conséquent, la somme des kilos de BigCount et de petite encombrement doit être au moins égale à la valeur de l'objectif. La méthode devrait retourner vrai s'il est possible de faire un paquet avec des kilos d'objectif de farine.

    Si la somme est supérieure à celle de l'objectif, assurez-vous que seuls les sacs complets sont utilisés vers le montant de l'objectif. Par exemple, si l'objectif = 9, BigCount = 2 et SmallCount = 0, la méthode doit renvoyer false car chaque gros sac est de 5 kilos et ne peut pas être divisé. Cependant, si goûte = 9, BigCount = 1 et petiteCount = 5, la méthode devrait retourner vrai à cause de 1 sac complet de gros contradictoire et 4 sacs complets de petits encombrés égaux, et c'est bien s'il y a des sacs supplémentaires à gauche.

    Si l'un des paramètres est négatif, renvoyez FAUX.

    exemple d'entrée / sortie:

    • canpack (1, 0, 4); devrait retourner faux car BigCount est 1 (gros sac de 5 kilos) et le but est de 4 kilos.

    • canpack (1, 0, 5); devrait retourner vrai depuis que le BigCount est 1 (gros sac de 5 kilos) et le but est de 5 kilos.

    • canpack (0, 5, 4); devrait retourner vrai depuis que les petits encombrés sont 5 (petits sacs de 1 kilo) et que le but est de 4 kilos, et nous avons 1 sac à gauche qui est correct comme mentionné ci-dessus.

    • canpack (2, 2, 11); Devrait retourner vrai depuis que BigCount est 2 (gros sacs à 5 kilos chacun) et le petit encombré est 2 (petits sacs de 1 kilo), fait au total 12 kilos et but est de 11 kilos.

    • canpack (-3, 2, 12); devrait retourner faux puisque le bigcount est négatif. xxx

      L'instance pour 4,18,19 devrait retourner vrai, mais ce n'est pas le cas. Quelqu'un pourrait-il me dire ce que je fais mal? Merci d'avance

3 commentaires

Veuillez expliquer le raisonnement pour BigCountkilos + SmallCountkilos> = but && bigcountkilos% but == 0

En outre, aimez-vous demander: est-ce une sorte d'affectation? Aussi également, réfléchissez à l'affaire but = 20, gros = 4, petit = 3

Sorry ment but = 19, gros = 4, petit = 3

6 Réponses :

0
votes

Je me sens comme votre logique derrière la recherche de la réponse n'est pas correcte. Les énoncés si ne couvrent pas tous les cas et ne produisent pas la bonne réponse à chaque fois.

Une approche fondamentale serait quelque chose comme:

  • Soustrayez 5 de l'objectif et soustrayez 1 de BigCount tandis que Butte> 0 et BigCount> 0
  • Si l'objectif est toujours> 0, vérifiez si petiteCount> = objectif. Si oui, retournez vrai, sinon faux.
0 commentaires
0
votes 
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;
}
1 commentaires

Vous devez expliquer votre réponse afin de vous assurer que l'adresseur comprendra cela.

1
votes 
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;
    }
}
This will work for all the conditions. Please try this and if anything wrong Kindly update.
0 commentaires
0
votes

Ce code fonctionne sur l'algorithme gourmand et passe tous les cas de test, essayez-le: 

public static boolean canPack(int bigCount, int smallCount, int goal) {
    // Here we are checking if the inputs are valid
    if (bigCount < 0 || smallCount < 0 || goal < 0 || (bigCount*5 + smallCount)  < goal) {
        return false;
    }

    // Here we multiply bigCount with 5 since each bigCount contains 5 kg
    int bigCountKilo = bigCount * 5;

    // We check if goal > 5 and then subtract bigCount from it till the goal is less than 5kg
    while (goal >= 5) {
        if (bigCountKilo > 0) {
            goal -= 5;
            bigCount-=1;
        } else {
            break;
        }
    }

    // Similarly here too we are checking if goal is greater than 0 and then subtracting smallCount values
    while (goal > 0) {
        if (smallCount > 0) {
            goal -= 1;
            smallCount -= 1;
        } else {
            break;
        }
    }

    // We are returning true if goal is reached (if goal becomes zero)
    return (goal == 0);
}

1 commentaires

Vous pouvez utiliser bloc de code pour Section de code qui rendra la question / la réponse plus lisible et bonne. Pour plus d'informations, vous cochez ce Lien < / a>

0
votes 
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;
}
1 commentaires

Bien que ce bloc de code puisse répondre à la question, il serait préférable que vous puissiez fournir une petite explication pour laquelle cela le fait.

1
votes

hey l'explication est assez simple J'espère que vous avez compris la partie supérieure jusqu'au BigCount , petitCount et but . .

Commençons donc ... Supposons but = 9 kg . Cela signifie que vous devez faire un paquet contenant 9 kg de farine. Maintenant BigCount = 2 (signifie 10 kg) et petitCount = 0 .

Combien de farine vous avez (BigCount * 5) + SmallCount = 10kg Avez-vous assez de farine pour faire un paquet? Oui. Pouvez-vous faire un paquet de 9 kg? Non. Parce que vous avez deux sacs de 5 kg chacun et vous ne pouvez pas prendre 1 kg de tout sac.

considère le deuxième scénario Supposons but = 9 kg . Cela signifie que vous devez faire un paquet contenant 9 kg de farine.

maintenant bigCount = 1 (signifie 5 kg) et petitCount = 5 (signifie 5 kg).

Vous avez maintenant 10 kg de farine, mais la question est que vous pouvez faire un paquet sans prendre de farine d'un sac? Cette fois, oui.

5kg + 1kg + 1kg + 1kg + 1kg = 9kg et 1kg extra . .

Vous dire simplement, vous pouvez avoir une farine supplémentaire, mais vous ne pouvez pas prendre de farine des sacs pour atteindre le but.

0 commentaires

Articles qui pourrait vous intéresser :

 Comment envoyer une liste vide à la clause IN
Code de réponse 403 inattendu lors de la récupération des données des API
Impossible de trouver la classe UnityPlayerActivity dans com.unity3d.player
Comment définir un tableau dans jsonobject