пример кода Java обзор (makeChocolate в codingbat)

Question

Проблема здесь кодирования летучей мыши Java заставила меня растянуть немного:

Проблема:

Мы хотим, чтобы сделать пакет целевых килограммов шоколада. У нас есть небольшие бары (по 1 килограмм каждый) и большие бары (по 5 килограммов каждый). Верните количество маленьких баров, чтобы использовать, предполагая, что мы всегда используем большие бары перед небольшими барами. Возврат -1, если это невозможно.

makeChocolate (4, 1, 9) → 4 makeChocolate (4, 1, 10) → -1 makeChocolate (4, 1, 7) → 2

http://codingbat.com/prob/p191363

я мог придумать с этим в качестве решения, я не уверен, что это лучший способ, который любой энтузиаст хотел бы рассмотреть, с большим удовольствием! Я напечатал это без компилятора или что-нибудь так, простите меня за углубления:

ЛЮБОГО ЛУЧШЕ ОТВЕТЫ БЫ ОЦЕНЕНЫ:

public int makeChocolate(int small, int big, int goal) { 
    if(goal<5&&small>=goal) 
    { 
    return goal; 
    } 

    if(goal<5&&small<goal) 
    { 
    return -1; 
    } 

    if(goal>=5) 
    { 
    if(5*big>goal) 
    { 
     int temp=goal/5; 
     if(goal-temp*5<=small) 
     { 
     return goal-temp*5; 
     } 
     if(goal-temp*5>small) 
     { 
     return -1; 
     } 
    } 

    if(5*big<goal) 
    { 
     if(small<(goal-5*big)) 
     { 
     return -1; 
     } 
     if(small>=(goal-5*big)) 
     { 
     return goal-5*big; 
     } 
    } 
    } 
    return 0;  
} 

Answer 1

private final int BIG_SIZE = 5; 

public int makeChocolate(int small, int big, int goal) { 
    int s = goal - Math.min(big, goal/BIG_SIZE) * BIG_SIZE ; 
    return (s <= small) ? s : -1; 
} 

Объяснение:

goal/BIG_SIZE вычисляет общее количество больших баров обязательный. Конечно, это может быть больше, чем у нас, поэтому Math.min(big, goal/BIG_SIZE) ограничит это число до big (количество больших баров у нас есть).

Если мы умножим это число на размер большой полосы (5 килограммов) и вычтем от goal, мы получим количество оставшихся килограммов, заполненных небольшими барами (s).

Вторая строка просто проверяет, есть ли у нас достаточно маленьких баров. Если да, то s - результат, если нет, мы не можем сделать этот шоколад (-1).

Answer 2

private final int BIG_SIZE = 5; 

public int makeChocolate(int small, int big, int goal) 
{ 
    if(big > 0 && goal >= BIG_SIZE) 
     return makeChocolate(small, --big, goal-BIG_SIZE); 

    return (small >= goal ? goal : -1); 
} 

Краткое объяснение:

В то время как мы все еще можем использовать большой шоколад (т.е. #big> 0 & & цель> BIG_SIZE), вызов метода рекурсивно сбросив одну большую шоколадку и BIG_SIZE цели.

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

Answer 3

private final int BIG_SIZE = 5; 

public int makeChocolate(int small, int big, int goal) { 
    // 1 
    while (goal >= BIG_SIZE && big >= 1) {goal -=BIG_SIZE; big -= 1;} 
    // 2 
    return goal <= small ? goal : -1; 
} 

Я думаю, что это прозрачный раствор:

1. Используйте все большие конфеты
2. Проверьте, если у нас достаточно маленький шоколад и возвращаемое значение

Answer 4

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

public int makeChocolate(int small, int big, int goal) { 
    big *= 5; 
    if (big + small < goal || small < goal%5) 
     return -1; //goal can not be met 
    small = goal - big; //use big bars first 
    return small < 0 ? (big+small)%5 : small; 
} 

Answer 5

Вот мое решение, используя While-цикл (вместо вызова метода рекурсивно):

public int makeChocolate(int small, int big, int goal) { 
    while (goal >=5 && big>0) { 
    goal -= 5; 
    big--;  
    } 
    if (goal<=small) { 
    return goal; 
    } 
    else return -1; 
} 

1.Substract 5 до тех пор, пока остальные от 0 до 4 включительно.

2.Stop вычитание, если количество больших баров исчезло.

3. проверьте, хватит ли маленьких баров для достижения цели.

4.Return остальное, в противном случае -1

Answer 6

public int makeChocolate(int small, int big, int goal) { 
    int nbSmallNeeded; 
    int nbBigNeeded = Math.abs(goal/5); 
    if(big >= nbBigNeeded){ 
     nbSmallNeeded= goal - nbBigNeeded*5; 
    } 
    else { 
     nbSmallNeeded = goal - 5*big; 
    } 
    return small >= nbSmallNeeded? nbSmallNeeded: -1; 
} 

Answer 7

public int makeChocolate(int small, int big, int goal) 
{ 
    int b=big*5; 
    if(b>0 && b+small>=goal && goal%5<=small || small>=goal) 
    { 
    while(goal>=5 && b>0) 
    { 
    goal-=5; 
    b-=5; 
    } 
    return goal; 
    } 
    return -1; 
} 

«тогда», чтобы проверить, есть достаточно большие и маленькие шоколадки, и «пока», чтобы избавиться от нужного количества большие конфеты

Answer 8

public int makeChocolate(int small, int big, int goal) { 

//fail number 1 -- not enough chocolate to reach the goal. 
if(goal > big*5 +small) return -1; 

//fail number 2 -- not enough small ones to fill the remaining. 
if(goal%5 > small) return -1; 

//fail number 3 -- not enough big ones 
if(goal - big*5 >=5) return goal-big*5; 

return goal%5; 
} 

Я считаю, что codingbat пытается решить эту проблему без использования какой-либо формы петли только если заявления, как с его предыдущим MakeBrics упражнения. Его стратегия заключается в том, чтобы найти простые способы проверки отказа. Простой способ взглянуть на это - увидеть это как процесс скрининга.

Fail 1 - Нет смысла пытаться рассчитать, сколько нам нужно, если у нас не будет достаточно шоколада для начала. Это требует времени и неэффективно.

Сбой 2 - Мы проверяем наличие достаточного количества небольших баров, чтобы заполнить оставшееся пространство. Если это не операция прекращения, так как нет смысла рассчитывать дальше.

Fail 3 - В случае, когда у нас недостаточно больших, чтобы слепо опираться на операцию модуля внизу, принимали ли они бесконечные большие, поэтому он дает только отдых, нам нужно только проверить, сколько мы имеют большие. Поскольку провал №1 прошел, мы знаем, что у нас достаточно шоколада, чтобы заполнить заказ, поэтому все, что нам нужно сделать, это суммировать большие, а затем вычесть из цели, которая оставляет нам правильный ответ маленьких.

Answer 9

public int makeChocolate(int small, int big, int goal) { 
    int goalDiv = goal/5; 
    int goalRem = goal % 5; 

    // Equal or more big bars, and small bars available 
    if (goalDiv <= big && goalRem <= small) 
    return goalRem; 

    // Not enough big bars, but more than goal when combined with small bar 
    if (goalDiv > big && (big * 5 + small >= goal)) 
    return goal - (big * 5); 

    return -1; 
} 

Answer 10

public int makeChocolate(int small, int big, int goal) { 
    if(goal > (big * 5)) 
    { 
    if((goal - 5 * big) <= small) return goal - 5 * big; 
    } 
    else 
    { 
    if(goal % 5 <= small) return goal % 5; 
    } 
    return -1; 
} 

Answer 11

Вот мой код:

public int makeChocolate(int small, int big, int goal) { 

    goal=goal-big*5; 

    while(goal<0){ 
     goal+=5; 
    } 

    if(small>=goal){ 
     return goal; 
    } 
    else{ 
     return -1; 
    } 

} 

Answer 12

public int makeChocolate(int small, int big, int goal) { 
    if(goal/5 <= big) 
     goal = goal - (goal/5)*5; 
    else 
     goal = goal - big*5; 
    if(goal <= small) 
     return goal; 
    return -1; 
} 

Answer 13

public int makeChocolate(int small, int big, int goal) { 
    int bigs = big*5; 
    while(bigs > goal) { 
    big--; 
    bigs = big*5; 
    } 
    int compare = goal - bigs; 
    if(small >= compare) return compare; 
    if(small < compare) return -1; 
    return small; 
} 

Answer 14

public int makeChocolate(int small, int big, int goal) { 

int big_amount = 0; 

for (int x = 1; x * 5 <= goal; x++){ 
    if (big > big_amount) 
    big_amount++; 
} 

    if (goal - big_amount*5 > small) 
    return -1; 
    else 
    return goal - big_amount*5; 
} 

Answer 15

public int makeChocolate(int small, int big, int goal) { 
    // Condtion When Fails 
    if (goal > 5 * big + small || goal % 5 > small) { 
     return -1; 
    } 

    if (goal > 5 * big) { 
     return (goal - 5 * big); 
    } else { 
     return (goal % 5); 

    } 

}