Проблема практики Java

Question

Я сталкивался с этой проблемой в Джавабате

Мы хотим сделать ряд кирпичей, которые это цель дюймов длиной. У нас есть номер из маленьких кирпичей (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. Моя логика вернет ложь. Как мне исправить мою логику? Или есть лучший способ сделать это?

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

Второй тест совершенно не нужен. Первый проверяет, хватит ли вам общей длины, и все ли хорошо.

Но второй снова проверяет, достаточно ли у вас общей длины (возврат цели / 5 <= большой;), но при этом игнорируется длина, добавленная маленькими кубиками. Проблема в том, что вы проверяете, является ли оно кратным 5, и автоматически предполагаете, что собираетесь использовать только большие блоки, если это так. В действительности вы могли бы использовать пять маленьких кирпичей вместо (или, как в вашем примере, 10 маленьких кубиков.) Последняя проверка верна, проверяя, достаточно ли у вас гранулярности для получения нужной длины, при условии, что у вас достаточно длины. </p>

Answer 4

Вот мой оригинальный ответ; это не сработало для других тестов, но в то время я не мог понять, как это не сработало (все еще действительно не может), и правильный ответ меня бесит, потому что, даже если он проверяет, он сосет на самом деле работает, потому что определенное утверждение чертовски ложно. Рэнт Рэнт Рэнт, ну как тут:

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

if(goal

Правильный ответ здесь, хотя он может сосать его:

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

if(goal

если small -> = остаток, он должен быть истинным, и всегда будет так, а если нет, то он не может быть истинным. Почему мой путь не работает, и этот путь работает в своем несовершенстве? Да, предыдущий оператор (цель <= ((большой * 5) + маленький)) отключает все случаи, когда он не работает, но я сделал это общее заявление, чтобы отменить, что все, что не равно общей сумме дюймов, является ложным, не для этой цели я вывел ее из старой математической задачи в каждом математическом предмете, который у меня был до сих пор, который разбивается в простейшей форме на это: w = (ax + bx) где w = целое a = число (в в этом случае 5) значение операции больше, чем число, представленное b (в данном случае 1), а x - это LCF между двумя найденными значениями (в данном случае снова 1) наиболее адекватно этой геометрической алгебраической задачей, угол равен 36 градусам. более чем в два раза больше его дополнительного угла (x = 2 (180-x) +36; x = 396-2x; 3x = 396; x = 132). Обычно дается подсказка относительно количества групп, а не только переменных. А что не так с моим, где экземпляр, где он не работает? </p>

Answer 5

вот еще одна практическая проблема, о которой я подумал, что она довольно похожа на эту проблему, просто я решил опубликовать ее и посмотреть, будет ли она работать для людей:

вы получили int SO начиная репутация и целевая репутация SO SO, которая выше, чем начальная репутация. Вы отвечаете только на вопросы, чтобы вы могли получить репутацию только на 10 или 15. Вы также можете отказаться от голосования, чтобы потерять репутацию на 1. что такое минимальное количество репутации, которое Вы должны проиграть, чтобы достичь цели репутации?

Пример: Вы начинаете с 715 и хотите достичь 888. Ответ - 2.

чтобы увеличить сложность, измените целые числа на длинные и не используйте цикл.

Answer 6

Я пробовал некоторые другие сценарии: «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 7

он возвращает false, потому что ваша вторая проверка сравнивает его только с большими числами, которые в вашем контрпримере имеют ноль.

, поэтому 2 <= 0 неверно. </p>

вот хороший способ сделать это:

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

Таким образом, вы обязательно будете использовать столько кирпичей, сколько вам нужно, но не больше, гарантируя, что единственный способ достичь цели - это если у вас достаточно маленьких кирпичей.

Answer 8

Это довольно короткое и простое решение, которое я использовал при решении проблемы 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;

}

Answer 9

Также вы можете попробовать это:

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

Answer 10

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