Занадто багато тверджень "якщо"?

Наступний код працює так, як мені потрібно, але це некрасиво, надмірно чи ряд інших речей. Я переглянув формули і спробував написати кілька рішень, але закінчую подібну кількість тверджень.

Чи є такий тип математичної формули, який би мені приніс користь у цьому випадку, або 16, якщо твердження прийнятні?

Щоб пояснити код, це така собі гра з одночасним поворотом. У двох гравців є по чотири кнопки дій кожна, результати виходять із масиву (0-3), але змінні "один" та "два" можуть бути призначив що-небудь, якщо це допоможе. Результат: 0 = ні перемога, 1 = p1 перемога, 2 = p2 виграш, 3 = обидва виграти.

public int fightMath(int one, int two) {

    if(one == 0 && two == 0) { result = 0; }
    else if(one == 0 && two == 1) { result = 0; }
    else if(one == 0 && two == 2) { result = 1; }
    else if(one == 0 && two == 3) { result = 2; }
    else if(one == 1 && two == 0) { result = 0; }
    else if(one == 1 && two == 1) { result = 0; }
    else if(one == 1 && two == 2) { result = 2; }
    else if(one == 1 && two == 3) { result = 1; }
    else if(one == 2 && two == 0) { result = 2; }
    else if(one == 2 && two == 1) { result = 1; }
    else if(one == 2 && two == 2) { result = 3; }
    else if(one == 2 && two == 3) { result = 3; }
    else if(one == 3 && two == 0) { result = 1; }
    else if(one == 3 && two == 1) { result = 2; }
    else if(one == 3 && two == 2) { result = 3; }
    else if(one == 3 && two == 3) { result = 3; }

    return result;
}

Якщо ви не можете придумати формулу, ви можете використовувати таблицю для такої обмеженої кількості результатів:

final int[][] result = new int[][] {
  { 0, 0, 1, 2 },
  { 0, 0, 2, 1 },
  { 2, 1, 3, 3 },
  { 1, 2, 3, 3 }
};
return result[one][two];

Оскільки набір даних настільки малий, ви можете стиснути все в 1 довге ціле число і перетворити його у формулу

public int fightMath(int one,int two)
{
   return (int)(0xF9F66090L >> (2*(one*4 + two)))%4;
}

Бітовий варіант:

Це використовує той факт, що все кратно 2

public int fightMath(int one,int two)
{
   return (0xF9F66090 >> ((one << 3) | (two << 1))) & 0x3;
}

Походження магічної константи

Що я можу сказати? Світ потребує магії, іноді можливість чогось вимагає його створення.

Суть функції, що вирішує задачу ОП, - це карта від 2 чисел (одне, два), домен {0,1,2,3} до діапазону {0,1,2,3}. Кожна з відповідей підходила до того, як реалізувати цю карту.

Крім того, ви можете побачити в ряді відповідей перестановку задачі як карту 1 2-значного базового 4 числа N (один, два), де один - цифра 1, два - цифра 2, а N = 4 * одна + два; N = {0,1,2, ..., 15} - шістнадцять різних значень, це важливо. Результатом функції є одне однозначне базове 4 число {0,1,2,3} - 4 різні значення, також важливі.

Тепер 1-розрядне базове 4 число може бути виражене як двозначне базове 2 число; {0,1,2,3} = {00,01,10,11}, і тому кожен вихід може бути закодований лише 2 бітами. Зверху можливі лише 16 різних виходів, тому 16 * 2 = 32 біта - це все, що необхідно для кодування всієї карти; це все може вміститися в одне ціле число.

Константа M - це кодування карти m, де m (0) кодується бітами M [0: 1], m (1) кодується бітами M [2: 3], а m (n) кодується бітами M [n * 2: n * 2 + 1].

Залишилося лише індексувати та повернути праву частину константи, в цьому випадку ви можете змістити M вправо в 2 * N рази і взяти 2 найменш значущих біта, тобто (M >> 2 * N) & 0x3. Вирази (один << 3) і (два << 1) просто множать речі, зазначаючи, що 2 * x = x << 1 і 8 * x = x << 3.

Мені не подобається жодне з представлених рішень, крім JAB. Ніхто з інших не дозволяє легко прочитати код і зрозуміти, що обчислюється .

Ось як я написав би цей код - я знаю лише C #, а не Java, але ви отримаєте малюнок:

const bool t = true;
const bool f = false;
static readonly bool[,] attackResult = {
    { f, f, t, f }, 
    { f, f, f, t },
    { f, t, t, t },
    { t, f, t, t }
};
[Flags] enum HitResult 
{ 
    Neither = 0,
    PlayerOne = 1,
    PlayerTwo = 2,
    Both = PlayerOne | PlayerTwo
}
static HitResult ResolveAttack(int one, int two)
{
    return 
        (attackResult[one, two] ? HitResult.PlayerOne : HitResult.Neither) | 
        (attackResult[two, one] ? HitResult.PlayerTwo : HitResult.Neither);
}    

Зараз набагато зрозуміліше, що тут обчислюється: це підкреслює, що ми обчислюємо того, хто потрапив у атаку, і повертаємо обидва результати.

Однак це може бути ще краще; що булівський масив дещо непрозорий. Мені подобається підхід до пошуку таблиці, але я був би схильний записати його таким чином, щоб було зрозуміло, якою була призначена семантика гри. Тобто, замість того, щоб "атака нуля і захист одного результату не влучила", замість того, щоб знайти спосіб зробити код більш чітким, що означає "атаку з низьким ударом і низький захист блоку не призводить до удару". Зробіть, щоб код відображав ділову логіку гри.

Ви можете створити матрицю, яка містить результати

int[][] results = {{0, 0, 1, 2}, {0, 0, 2, 1},{2, 1, 3, 3},{2, 1, 3, 3}};

Коли ви хочете отримати цінність, ви будете використовувати

public int fightMath(int one, int two) {
  return this.results[one][two]; 
}

Інші люди вже запропонували мою початкову ідею, метод матриці, але на додаток до консолідації висловлювань if ви можете уникнути деякого з того, що у вас є, переконавшись, що подані аргументи знаходяться в очікуваному діапазоні та використовуючи на місці повернення (деяке кодування Стандарти Я бачив, як застосовується функція "одна точка виходу" для функцій, але я виявив, що багаторазове повернення дуже корисно для уникнення кодування стрілки і за поширеності винятків на Java, все одно не дуже важливо суворо виконувати таке правило так як будь-який невловимий виняток, кинутий всередині методу, все одно є можливою точкою виходу). Оператори введення комутаторів - це можливість, але для невеликого діапазону значень, які ви перевіряєте тут, я виявляю, чи твердження більш компактні та не можуть призвести до значної різниці в продуктивності,

public int fightMath(int one, int two) {
    if (one > 3 || one < 0 || two > 3 || two < 0) {
        throw new IllegalArgumentException("Result is undefined for arguments outside the range [0, 3]");
    }

    if (one <= 1) {
        if (two <= 1) return 0;
        if (two - one == 2) return 1;
        return 2; // two can only be 3 here, no need for an explicit conditional
    }

    // one >= 2
    if (two >= 2) return 3;
    if (two == 1) return 1;
    return 2; // two can only be 0 here
}

Це в кінцевому підсумку є менш читабельним, ніж це може бути інакше через неправильність відображення частин введення> результатів. Натомість я віддаю перевагу стилю матриці через його простоту та те, як ви можете налаштувати матрицю, щоб візуально мати сенс (хоча на це частково впливають мої спогади про карти Карна):

int[][] results = {{0, 0, 1, 2},
                   {0, 0, 2, 1},
                   {2, 1, 3, 3},
                   {2, 1, 3, 3}};

Оновлення: Зважаючи на вашу згадку про блокування / натискання, ось більш радикальна зміна функції, яка використовує перелічені типи для введення та результату, які містять належні / тримання атрибутів, а також трохи змінює результат, щоб врахувати блокування, що може призвести до більше читабельна функція.

enum MoveType {
    ATTACK,
    BLOCK;
}

enum MoveHeight {
    HIGH,
    LOW;
}

enum Move {
    // Enum members can have properties/attributes/data members of their own
    ATTACK_HIGH(MoveType.ATTACK, MoveHeight.HIGH),
    ATTACK_LOW(MoveType.ATTACK, MoveHeight.LOW),
    BLOCK_HIGH(MoveType.BLOCK, MoveHeight.HIGH),
    BLOCK_LOW(MoveType.BLOCK, MoveHeight.LOW);

    public final MoveType type;
    public final MoveHeight height;

    private Move(MoveType type, MoveHeight height) {
        this.type = type;
        this.height = height;
    }

    /** Makes the attack checks later on simpler. */
    public boolean isAttack() {
        return this.type == MoveType.ATTACK;
    }
}

enum LandedHit {
    NEITHER,
    PLAYER_ONE,
    PLAYER_TWO,
    BOTH;
}

LandedHit fightMath(Move one, Move two) {
    // One is an attack, the other is a block
    if (one.type != two.type) {
        // attack at some height gets blocked by block at same height
        if (one.height == two.height) return LandedHit.NEITHER;

        // Either player 1 attacked or player 2 attacked; whoever did
        // lands a hit
        if (one.isAttack()) return LandedHit.PLAYER_ONE;
        return LandedHit.PLAYER_TWO;
    }

    // both attack
    if (one.isAttack()) return LandedHit.BOTH;

    // both block
    return LandedHit.NEITHER;
}

Вам навіть не потрібно змінювати саму функцію, якщо ви хочете додати блоки / атаки більшої висоти, просто перерахунки; додавання додаткових типів рухів, ймовірно, потребуватиме зміни функції. Крім того, EnumSets може бути більш розширюваним, ніж використання додаткових перерахунків як властивостей основного перерахунку, наприклад, EnumSet<Move> attacks = EnumSet.of(Move.ATTACK_HIGH, Move.ATTACK_LOW, ...);а потім, attacks.contains(move)а не move.type == MoveType.ATTACK, хоча використання EnumSets, ймовірно, буде трохи повільніше, ніж прямі рівні перевірки.

У випадку, коли вдалий блок призводить до лічильника, його можна замінити if (one.height == two.height) return LandedHit.NEITHER;на

if (one.height == two.height) {
    // Successful block results in a counter against the attacker
    if (one.isAttack()) return LandedHit.PLAYER_TWO;
    return LandedHit.PLAYER_ONE;
}

Крім того, заміна деяких ifвисловлювань з використанням термінального оператора ( boolean_expression ? result_if_true : result_if_false) може зробити код більш компактним (наприклад, код у попередньому блоці стане return one.isAttack() ? LandedHit.PLAYER_TWO : LandedHit.PLAYER_ONE;), але це може призвести до більш важкого для читання oneliners, щоб я не хотів ' t рекомендувати його для більш складних розгалужень.

Чому б не використовувати масив?

Почну з самого початку. Я бачу закономірність, значення переходить від 0 до 3, і ви хочете отримати всі можливі значення. Це ваш стіл:

0 & 0 = 0
0 & 1 = 0
0 & 2 = 1
0 & 3 = 2
1 & 0 = 0
1 & 1 = 0
1 & 2 = 2
1 & 3 = 1
2 & 0 = 2
2 & 1 = 1
2 & 2 = 3
2 & 3 = 3
3 & 0 = 2
3 & 1 = 1
3 & 2 = 3
3 & 3 = 3

коли ми дивимось на цю ж бінарну таблицю, ми бачимо такі результати:

00 & 00 = 00
00 & 01 = 00
00 & 10 = 01
00 & 11 = 10
01 & 00 = 00
01 & 01 = 00
01 & 10 = 10
01 & 11 = 01
10 & 00 = 10
10 & 01 = 01
10 & 10 = 11
10 & 11 = 11
11 & 00 = 10
11 & 01 = 01
11 & 10 = 11
11 & 11 = 11

Тепер, можливо, ви вже бачите деякий візерунок, але коли я поєдную значення одне і два, я бачу, що ви використовуєте всі значення 0000, 0001, 0010, ..... 1110 і 1111. Тепер давайте поєднаємо значення одне і два, щоб зробити єдине 4 бітове ціле число.

0000 = 00
0001 = 00
0010 = 01
0011 = 10
0100 = 00
0101 = 00
0110 = 10
0111 = 01
1000 = 10
1001 = 01
1010 = 11
1011 = 11
1100 = 10
1101 = 01
1110 = 11
1111 = 11

Коли ми переводимо це назад у десяткові значення, ми бачимо дуже можливий масив значень, де один та два комбіновані можуть використовуватися як індекс:

0 = 0
1 = 0
2 = 1
3 = 2
4 = 0
5 = 0
6 = 2
7 = 1
8 = 2
9 = 1
10 = 3
11 = 3
12 = 2
13 = 1
14 = 3
15 = 3

Масив - це тоді {0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 2, 1, 3, 3}, де його індекс просто один і два разом.

Я не Java-програміст, але ви можете позбутися всіх, якщо заяви, і просто записати це як щось подібне:

int[] myIntArray = {0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 2, 1, 3, 3};
result = myIntArray[one * 4 + two]; 

Я не знаю, чи швидше переміщення на 2 швидше, ніж множення. Але варто спробувати.

Для цього використовується трохи бітмагічного (ви вже робите це, тримаючи два біти інформації (низький / високий & атака / блок) в одному цілому цілому):

Я не запускав його, лише набрав його тут, будь ласка, перевірте двічі. Ідея напевно спрацьовує. EDIT: Зараз тестується на кожен вхід, працює чудово.

public int fightMath(int one, int two) {
    if(one<2 && two<2){ //both players blocking
        return 0; // nobody hits
    }else if(one>1 && two>1){ //both players attacking
        return 3; // both hit
    }else{ // some of them attack, other one blocks
        int different_height = (one ^ two) & 1; // is 0 if they are both going for the same height - i.e. blocker wins, and 1 if height is different, thus attacker wins
        int attacker = one>1?1:0; // is 1 if one is the attacker, two is the blocker, and 0 if one is the blocker, two is the attacker
        return (attacker ^ different_height) + 1;
    }
}

Або я пропоную розділити два біти інформації на окремі змінні? Код, заснований в основному на бітових операціях, як це вище, зазвичай дуже важко підтримувати.

Якщо чесно сказати, у кожного є свій стиль коду. Я б не думав, що на ефективність буде занадто сильно впливати. Якщо ви розумієте це краще, ніж використовувати версію корпусу комутатора, тоді продовжуйте використовувати цю.

Ви можете вкласти ifs, так що потенційно може бути незначне підвищення продуктивності для вашого останнього, якщо перевірки, як би не пройшло стільки, якби заяви. Але у вашому контексті базового курсу java це, мабуть, не принесе користі.

else if(one == 3 && two == 3) { result = 3; }

Тож замість ...

if(one == 0 && two == 0) { result = 0; }
else if(one == 0 && two == 1) { result = 0; }
else if(one == 0 && two == 2) { result = 1; }
else if(one == 0 && two == 3) { result = 2; }

Ви б зробили ...

if(one == 0) 
{ 
    if(two == 0) { result = 0; }
    else if(two == 1) { result = 0; }
    else if(two == 2) { result = 1; }
    else if(two == 3) { result = 2; }
}

І просто переформатуйте його, як хочете.

Це не робить код краще виглядати, але, можливо, я його трохи прискорює.

Подивимося, що ми знаємо

1: ваші відповіді симетричні для P1 (гравець один) та P2 (гравець два). Це має сенс для бойової гри, але також є те, чим ви можете скористатися, щоб покращити свою логіку.

2: 3 удари 0 ударів 2 удари 1 удар 3. Єдині випадки, які не охоплені цими випадками, - це комбінації 0 проти 1 і 2 проти 3. Іншим чином, унікальна таблиця перемог виглядає так: 0 ударів 2, 1 удар 3, 2 удари 1, 3 удари 0.

3: Якщо 0/1 йде вгору один проти одного, то відбувається нічия нічия, але якщо 2/3 піднімаються проти кожного, то обидва удари

Спочатку давайте побудуємо односторонню функцію, яка говорить нам, чи ми перемогли:

// returns whether we beat our opponent
public boolean doesBeat(int attacker, int defender) {
  int[] beats = {2, 3, 1, 0};
  return defender == beats[attacker];
}

Потім ми можемо використовувати цю функцію для складання кінцевого результату:

// returns the overall fight result
// bit 0 = one hits
// bit 1 = two hits
public int fightMath(int one, int two)
{
  // Check to see whether either has an outright winning combo
  if (doesBeat(one, two))
    return 1;

  if (doesBeat(two, one))
    return 2;

  // If both have 0/1 then its hitless draw but if both have 2/3 then they both hit.
  // We can check this by seeing whether the second bit is set and we need only check
  // one's value as combinations where they don't both have 0/1 or 2/3 have already
  // been dealt with 
  return (one & 2) ? 3 : 0;
}

Хоча це, мабуть, складніше і, ймовірно, повільніше, ніж пошук таблиць, запропонований у багатьох відповідях, я вважаю, що це чудовий метод, оскільки він фактично інкапсулює логіку вашого коду і описує його для тих, хто читає ваш код. Я думаю, що це робить її кращою реалізацією.

(Минуло деякий час, оскільки я зробив будь-яку Java, тому вибачте, якщо синтаксис вимкнений, сподіваємось, він все ще зрозумілий, якщо я зрозумів його трохи неправильно)

До речі, 0-3 явно щось означають ; вони не є довільними значеннями, тому це допоможе назвати їх.

Сподіваюся, я правильно зрозумів логіку. Як щодо чогось такого:

public int fightMath (int one, int two)
{
    int oneHit = ((one == 3 && two != 1) || (one == 2 && two != 0)) ? 1 : 0;
    int twoHit = ((two == 3 && one != 1) || (two == 2 && one != 0)) ? 2 : 0;

    return oneHit+twoHit;
}

Перевірка високого удару або низького удару не заблокована, і однаково для гравця два.

Редагувати: Алгоритм не був повністю зрозумілий, "потрапляння" призначається при блокуванні, яке я не усвідомлював (Thx elias):

public int fightMath (int one, int two)
{
    int oneAttack = ((one == 3 && two != 1) || (one == 2 && two != 0)) ? 1 : (one >= 2) ? 2 : 0;
    int twoAttack = ((two == 3 && one != 1) || (two == 2 && one != 0)) ? 2 : (two >= 2) ? 1 : 0;

    return oneAttack | twoAttack;
}

Я не маю досвіду роботи з Java, тому можуть бути помилки. Будь ласка, розгляньте код як псевдокод.

Я б пішов з простим перемикачем. Для цього вам знадобиться оцінка одного номера. Однак у цьому випадку, оскільки 0 <= one < 4 <= 9і 0 <= two < 4 <= 9, ми можемо перетворити обидва int у простий int шляхом множення oneна 10 та додавання two. Потім використовуйте перемикач в отриманому числі таким чином:

public int fightMath(int one, int two) {
    // Convert one and two to a single variable in base 10
    int evaluate = one * 10 + two;

    switch(evaluate) {
        // I'd consider a comment in each line here and in the original code
        // for clarity
        case 0: result = 0; break;
        case 1: result = 0; break;
        case 1: result = 0; break;
        case 2: result = 1; break;
        case 3: result = 2; break;
        case 10: result = 0; break;
        case 11: result = 0; break;
        case 12: result = 2; break;
        case 13: result = 1; break;
        case 20: result = 2; break;
        case 21: result = 1; break;
        case 22: result = 3; break;
        case 23: result = 3; break;
        case 30: result = 1; break;
        case 31: result = 2; break;
        case 32: result = 3; break;
        case 33: result = 3; break;
    }

    return result;
}

Є ще один короткий метод, який я просто хочу зазначити як теоретичний код. Однак я б не використовував його, оскільки він має додаткову складність, з якою ти зазвичай не хочеш мати справу. Додаткова складність походить від основи 4 , оскільки підрахунок дорівнює 0, 1, 2, 3, 10, 11, 12, 13, 20, ...

public int fightMath(int one, int two) {
    // Convert one and two to a single variable in base 4
    int evaluate = one * 4 + two;

    allresults = new int[] { 0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 1, 2, 3, 3 };

    return allresults[evaluate];
}

Дійсно, лише додаткова примітка, якщо я щось не пропускаю з Java. У PHP я би зробив:

function fightMath($one, $two) {
    // Convert one and two to a single variable in base 4
    $evaluate = $one * 10 + $two;

    $allresults = array(
         0 => 0,  1 => 0,  2 => 1,  3 => 2,
        10 => 0, 11 => 0, 12 => 2, 13 => 1,
        20 => 2, 21 => 1, 22 => 3, 23 => 3,
        30 => 1, 31 => 2, 32 => 3, 33 => 3 );

    return $allresults[$evaluate];
}

Оскільки ви віддаєте перевагу вкладеним ifумовам, ось ще один спосіб.
Зауважте, що він не використовує resultчлен і він не змінює жодного стану.

public int fightMath(int one, int two) {
    if (one == 0) {
      if (two == 0) { return 0; }
      if (two == 1) { return 0; }
      if (two == 2) { return 1; }
      if (two == 3) { return 2; }
    }   
    if (one == 1) {
      if (two == 0) { return 0; }
      if (two == 1) { return 0; }
      if (two == 2) { return 2; }
      if (two == 3) { return 1; }
    }
    if (one == 2) {
      if (two == 0) { return 2; }
      if (two == 1) { return 1; }
      if (two == 2) { return 3; }
      if (two == 3) { return 3; }
    }
    if (one == 3) {
      if (two == 0) { return 1; }
      if (two == 1) { return 2; }
      if (two == 2) { return 3; }
      if (two == 3) { return 3; }
    }
    return DEFAULT_RESULT;
}

Спробуйте це з корпусом вимикача...

Подивіться тут або тут, щоб отримати докладнішу інформацію про це

switch (expression)
{ 
  case constant:
        statements;
        break;
  [ case constant-2:
        statements;
        break;  ] ...
  [ default:
        statements;
        break;  ] ...
}

Ви можете додати до нього кілька умов (не одночасно) і навіть мати параметр за замовчуванням, коли жодних інших випадків не було задоволено.

PS: Тільки за умови виконання однієї умови.

Якщо дві умови виникають одночасно .. Я не думаю, що перемикач можна використовувати. Але ви можете зменшити свій код тут.

Заява Java перемикання декількох випадків

Перше, що мені прийшло в голову - це по суті та сама відповідь, яку дав Франциско Презенсія, але дещо оптимізована:

public int fightMath(int one, int two)
{
    switch (one*10 + two)
    {
    case  0:
    case  1:
    case 10:
    case 11:
        return 0;
    case  2:
    case 13:
    case 21:
    case 30:
        return 1;
    case  3:
    case 12:
    case 20:
    case 31:
        return 2;
    case 22:
    case 23:
    case 32:
    case 33:
        return 3;
    }
}

Ви можете додатково оптимізувати його, зробивши останній випадок (для 3) за замовчуванням:

    //case 22:
    //case 23:
    //case 32:
    //case 33:
    default:
        return 3;

Перевага цього методу полягає в тому, що легше зрозуміти, для яких значень oneі twoвідповідати цим повернутим значенням, ніж деякі інші запропоновані методи.

((two&2)*(1+((one^two)&1))+(one&2)*(2-((one^two)&1)))/2

Ви можете використовувати корпус комутатора замість муфеляif

Також слід зазначити, що оскільки у вас є дві змінні, то вам доведеться об'єднати дві змінні, щоб використовувати їх в комутаторі

Перевірте цей оператор перемикача Java на обробку двох змінних?

Коли я малюю таблицю між одним / двома та результатом, я бачу один візерунок,

if(one<2 && two <2) result=0; return;

Вище сказане зменшило б принаймні 3, якщо заяви. Я не бачу заданого шаблону, і я не в змозі багато чого зрозуміти з наведеного коду, але якщо така логіка може бути виведена, вона зменшила б кількість тверджень if.

Сподіваюсь, це допомагає.

Хорошим моментом було б визначити правила як текст, ви можете легше вивести правильну формулу. Це витягнуто з приємного представлення масиву laalto:

{ 0, 0, 1, 2 },
{ 0, 0, 2, 1 },
{ 2, 1, 3, 3 },
{ 1, 2, 3, 3 }

І тут ми ідемо з деякими загальними коментарями, але ви повинні описати їх правилами:

if(one<2) // left half
{
    if(two<2) // upper left half
    {
        result = 0; //neither hits
    }
    else // lower left half
    {
        result = 1+(one+two)%2; //p2 hits if sum is even
    }
}
else // right half
{
    if(two<2) // upper right half
    {
        result = 1+(one+two+1)%2; //p1 hits if sum is even
    }
    else // lower right half
    {
        return 3; //both hit
    }
}

Звичайно, ви можете стиснути це до меншого коду, але це загальна ідея зрозуміти, що ви кодуєте, а не знайти компактне рішення.

if((one<2)&&(two<2)) result = 0; //top left
else if((one>1)&&(two>1)) result = 3; //bottom right
else result = 1+(one+two+((one>1)?1:0))%2; //no idea what that means

Деякі пояснення щодо складних хітів p1 / p2 були б чудовими, виглядає цікаво!

Найкоротше і досі читабельне рішення:

static public int fightMath(int one, int two)
{
    if (one < 2 && two < 2) return 0;
    if (one > 1 && two > 1) return 3;
    int n = (one + two) % 2;
    return one < two ? 1 + n : 2 - n;
}

або навіть коротше:

static public int fightMath(int one, int two)
{
    if (one / 2 == two / 2) return (one / 2) * 3;
    return 1 + (one + two + one / 2) % 2;
}

Не містить жодних "магічних" номерів;) Сподіваюся, це допомагає.

static int val(int i, int u){ int q = (i & 1) ^ (u & 1); return ((i >> 1) << (1 ^ q))|((u >> 1) << q); }

Мені особисто подобається каскад потрійних операторів:

int result = condition1
    ? result1
    : condition2
    ? result2
    : condition3
    ? result3
    : resultElse;

Але у вашому випадку ви можете використовувати:

final int[] result = new int[/*16*/] {
    0, 0, 1, 2,
    0, 0, 2, 1,
    2, 1, 3, 3,
    1, 2, 3, 3
};

public int fightMath(int one, int two) {
    return result[one*4 + two];
}

Або ви можете помітити візерунок у бітах:

one   two   result

section 1: higher bits are equals =>
both result bits are equals to that higher bits

00    00    00
00    01    00
01    00    00
01    01    00
10    10    11
10    11    11
11    10    11
11    11    11

section 2: higher bits are different =>
lower result bit is inverse of lower bit of 'two'
higher result bit is lower bit of 'two'

00    10    01
00    11    10
01    10    10
01    11    01
10    00    10
10    01    01
11    00    01
11    01    10

Отже, ви можете використовувати магію:

int fightMath(int one, int two) {
    int b1 = one & 2, b2 = two & 2;
    if (b1 == b2)
        return b1 | (b1 >> 1);

    b1 = two & 1;

    return (b1 << 1) | (~b1);
}

Ось досить коротка версія, схожа на відповідь JAB . Тут використовується карта для зберігання, яка перемагає тріумф над іншими.

public enum Result {
  P1Win, P2Win, BothWin, NeitherWin;
}

public enum Move {
  BLOCK_HIGH, BLOCK_LOW, ATTACK_HIGH, ATTACK_LOW;

  static final Map<Move, List<Move>> beats = new EnumMap<Move, List<Move>>(
      Move.class);

  static {
    beats.put(BLOCK_HIGH, new ArrayList<Move>());
    beats.put(BLOCK_LOW, new ArrayList<Move>());
    beats.put(ATTACK_HIGH, Arrays.asList(ATTACK_LOW, BLOCK_LOW));
    beats.put(ATTACK_LOW, Arrays.asList(ATTACK_HIGH, BLOCK_HIGH));
  }

  public static Result compare(Move p1Move, Move p2Move) {
    boolean p1Wins = beats.get(p1Move).contains(p2Move);
    boolean p2Wins = beats.get(p2Move).contains(p1Move);

    if (p1Wins) {
      return (p2Wins) ? Result.BothWin : Result.P1Win;
    }
    if (p2Wins) {
      return (p1Wins) ? Result.BothWin : Result.P2Win;
    }

    return Result.NeitherWin;
  }
} 

Приклад:

System.out.println(Move.compare(Move.ATTACK_HIGH, Move.BLOCK_LOW));

Друкує:

P1Win

Я б використовував Карту, або HashMap, або TreeMap

Особливо, якщо параметри не у формі 0 <= X < N

Як набір випадкових натуральних чисел ..

Код

public class MyMap
{
    private TreeMap<String,Integer> map;

    public MyMap ()
    {
        map = new TreeMap<String,Integer> ();
    }

    public void put (int key1, int key2, Integer value)
    {
        String key = (key1+":"+key2);

        map.put(key, new Integer(value));
    }

    public Integer get (int key1, int key2)
    {
        String key = (key1+":"+key2);

        return map.get(key);
    }
}

Завдяки @Joe Harper, як я закінчив, використовуючи варіацію його відповіді. Щоб зменшити його ще більше, оскільки 2 результати на 4 були однаковими, я зменшив його ще далі.

Я можу повернутися до цього в якийсь момент, але якщо немає серйозного опору, спричиненого декількома ifзаявами, я зараз це зберігаю. Далі я загляну в матрицю таблиці та перекладу рішення рішень.

public int fightMath(int one, int two) {
  if (one === 0) {
    if (two === 2) { return 1; }
    else if(two === 3) { return 2; }
    else { return 0; }
  } else if (one === 1) {
    if (two === 2) { return 2; }
    else if (two === 3) { return 1; }
    else { return 0; }
  } else if (one === 2) {
    if (two === 0) { return 2; }
    else if (two === 1) { return 1; }
    else { return 3; }
  } else if (one === 3) {
    if (two === 0) { return 1; }
    else if (two === 1) { return 2; }
    else { return 3; }
  }
}

1. Використовуйте константи або перерахунки, щоб зробити код читабельнішим
2. Спробуйте розділити код на більше функцій
3. Спробуйте використати симетрію проблеми

Ось пропозиція, як це могло б виглядати, але використання ints тут все-таки некрасиво:

static final int BLOCK_HIGH = 0;
static final int BLOCK_LOW = 1;
static final int ATTACK_HIGH = 2;
static final int ATTACK_LOW = 3;

public static int fightMath(int one, int two) {
    boolean player1Wins = handleAttack(one, two);
    boolean player2Wins = handleAttack(two, one);
    return encodeResult(player1Wins, player2Wins); 
}



private static boolean handleAttack(int one, int two) {
     return one == ATTACK_HIGH && two != BLOCK_HIGH
        || one == ATTACK_LOW && two != BLOCK_LOW
        || one == BLOCK_HIGH && two == ATTACK_HIGH
        || one == BLOCK_LOW && two == ATTACK_LOW;

}

private static int encodeResult(boolean player1Wins, boolean player2Wins) {
    return (player1Wins ? 1 : 0) + (player2Wins ? 2 : 0);
}

Було б приємніше використовувати структурований тип для введення та виводу. Вхід фактично має два поля: позицію та тип (блок чи атака). Вихід також має два поля: player1Wins та player2Wins. Кодування цього цілого цілого числа ускладнює читання коду.

class PlayerMove {
    PlayerMovePosition pos;
    PlayerMoveType type;
}

enum PlayerMovePosition {
    HIGH,LOW
}

enum PlayerMoveType {
    BLOCK,ATTACK
}

class AttackResult {
    boolean player1Wins;
    boolean player2Wins;

    public AttackResult(boolean player1Wins, boolean player2Wins) {
        this.player1Wins = player1Wins;
        this.player2Wins = player2Wins;
    }
}

AttackResult fightMath(PlayerMove a, PlayerMove b) {
    return new AttackResult(isWinningMove(a, b), isWinningMove(b, a));
}

boolean isWinningMove(PlayerMove a, PlayerMove b) {
    return a.type == PlayerMoveType.ATTACK && !successfulBlock(b, a)
            || successfulBlock(a, b);
}

boolean successfulBlock(PlayerMove a, PlayerMove b) {
    return a.type == PlayerMoveType.BLOCK 
            && b.type == PlayerMoveType.ATTACK 
            && a.pos == b.pos;
}

На жаль, Java не дуже добре виражає такі типи даних.

Замість цього зробіть щось подібне

   public int fightMath(int one, int two) {
    return Calculate(one,two)

    }


    private int Calculate(int one,int two){

    if (one==0){
        if(two==0){
     //return value}
    }else if (one==1){
   // return value as per condtiion
    }

    }