Troppe dichiarazioni "if"?

Il seguente codice funziona come ne ho bisogno, ma è brutto, eccessivo o un numero di altre cose. Ho esaminato le formule e ho tentato di scrivere alcune soluzioni, ma ho finito con una quantità simile di dichiarazioni.

Esiste un tipo di formula matematica che mi gioverebbe in questo caso o sono 16 se le affermazioni sono accettabili?

Per spiegare il codice, è per una specie di gioco a turni simultanei. Due giocatori hanno quattro pulsanti di azione ciascuno e i risultati provengono da un array (0-3), ma le variabili 'one' e 'two' possono essere assegnato qualcosa se questo aiuta. Il risultato è 0 = nessuna vittoria, 1 = p1 vince, 2 = p2 vince, 3 = entrambe vince.

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

Se non riesci a trovare una formula, puoi utilizzare una tabella per un numero così limitato di risultati:

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

Poiché il tuo set di dati è così piccolo, puoi comprimere tutto in 1 intero lungo e trasformarlo in una formula

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

Variante più bit per bit:

Questo fa uso del fatto che tutto è un multiplo di 2

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

L'origine della costante magica

Cosa posso dire? Il mondo ha bisogno di magia, a volte la possibilità che qualcosa richieda la sua creazione.

L'essenza della funzione che risolve il problema di OP è una mappa da 2 numeri (uno, due), dominio {0,1,2,3} nell'intervallo {0,1,2,3}. Ciascuna delle risposte si è avvicinata a come implementare quella mappa.

Inoltre, puoi vedere in un numero di risposte una riaffermazione del problema come una mappa di 1 numero di base 2 a 4 cifre N (uno, due) dove uno è la cifra 1, due è la cifra 2 e N = 4 * uno + due; N = {0,1,2, ..., 15} - sedici valori diversi, questo è importante. L'output della funzione è un numero di base 4 a 1 cifra {0,1,2,3} - 4 valori diversi, anch'essi importanti.

Ora, un numero di base 4 di 1 cifra può essere espresso come un numero di base 2 di 2 cifre; {0,1,2,3} = {00,01,10,11} e quindi ogni uscita può essere codificata con solo 2 bit. Da sopra, ci sono solo 16 uscite diverse possibili, quindi 16 * 2 = 32 bit è tutto ciò che è necessario per codificare l'intera mappa; questo può rientrare in 1 intero.

La costante M è una codifica della mappa m in cui m (0) è codificato in bit M [0: 1], m (1) è codificato in bit M [2: 3] e m (n) è codificato in bit M [n * 2: n * 2 + 1].

Non resta che indicizzare e restituire la parte giusta della costante, in questo caso puoi spostare M a destra 2 * N volte e prendere i 2 bit meno significativi, ovvero (M >> 2 * N) e 0x3. Le espressioni (una << 3) e (due << 1) stanno semplicemente moltiplicando le cose osservando che 2 * x = x << 1 e 8 * x = x << 3.

Non mi piace nessuna delle soluzioni presentate ad eccezione di JAB. Nessuno degli altri semplifica la lettura del codice e la comprensione di ciò che viene calcolato .

Ecco come scriverei questo codice: conosco solo C #, non Java, ma ottieni l'immagine:

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

Ora è molto più chiaro ciò che viene calcolato qui: questo sottolinea che stiamo calcolando chi viene colpito da quale attacco e restituendo entrambi i risultati.

Tuttavia questo potrebbe essere ancora migliore; quell'array booleano è alquanto opaco. Mi piace l'approccio alla ricerca da tavolo, ma sarei propenso a scriverlo in modo tale da chiarire quali fossero le semantiche di gioco previste. Cioè, piuttosto che "un attacco pari a zero e una difesa di uno si traduce in nessun colpo", trovano invece un modo per rendere il codice più chiaramente implicito "un attacco a calcio basso e una difesa a blocco basso provoca nessun colpo". Fai in modo che il codice rifletta la logica aziendale del gioco.

È possibile creare una matrice che contiene risultati

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

Quando vuoi ottenere valore, userai

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

Altre persone hanno già suggerito la mia idea iniziale, il metodo matrix, ma oltre a consolidare le istruzioni if ​​puoi evitare parte di ciò che hai assicurandoti che gli argomenti forniti siano nell'intervallo previsto e utilizzando i rendimenti sul posto (alcuni codici gli standard che ho visto impongono un punto di uscita per le funzioni, ma ho scoperto che i ritorni multipli sono molto utili per evitare la codifica delle frecce e con la prevalenza delle eccezioni in Java non ha molto senso applicare rigorosamente una regola del genere poiché qualsiasi eccezione non rilevata generata all'interno del metodo costituisce comunque un possibile punto di uscita). Le istruzioni switch di nidificazione sono una possibilità, ma per il piccolo intervallo di valori che stai verificando qui trovo se le istruzioni sono più compatte e non rischiano di determinare una grande differenza di prestazioni,

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
}

Questo finisce per essere meno leggibile di quanto potrebbe altrimenti essere dovuto all'irregolarità di parti della mappatura input-> result. Preferisco invece lo stile matrice grazie alla sua semplicità e al modo in cui puoi impostare la matrice in modo che abbia senso visivamente (anche se questo è in parte influenzato dai miei ricordi delle mappe di Karnaugh):

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

Aggiornamento: data la tua menzione di blocco / colpire, ecco una modifica più radicale alla funzione che utilizza tipi enumerati di proprietà / possesso di attributi per gli input e il risultato e modifica anche un po 'il risultato per tenere conto del blocco, che dovrebbe tradursi in un funzione leggibile.

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

Non devi nemmeno cambiare la funzione stessa se vuoi aggiungere blocchi / attacchi di più altezze, solo gli enum; l'aggiunta di ulteriori tipi di mosse richiederà probabilmente una modifica della funzione. Inoltre, EnumSets potrebbe essere più estensibile dell'utilizzo di enumerazioni extra come proprietà dell'enum principale, ad esempio EnumSet<Move> attacks = EnumSet.of(Move.ATTACK_HIGH, Move.ATTACK_LOW, ...);e quindi attacks.contains(move)piuttosto che move.type == MoveType.ATTACK, sebbene l'uso di EnumSets sarà probabilmente leggermente più lento dei controlli di uguale diretto.

Nel caso in cui un blocco riuscito comporti un contatore, è possibile sostituirlo if (one.height == two.height) return LandedHit.NEITHER;con

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

Inoltre, la sostituzione di alcune delle ifdichiarazioni con l'uso dell'operatore ternario ( boolean_expression ? result_if_true : result_if_false) potrebbe rendere il codice più compatto (ad esempio, il codice nel blocco precedente diventerebbe return one.isAttack() ? LandedHit.PLAYER_TWO : LandedHit.PLAYER_ONE;), ma ciò può portare a oneliners più difficili da leggere, quindi non vorrei lo consiglio per ramificazioni più complesse.

Perché non usare un array?

Inizierò dall'inizio. Vedo uno schema, i valori vanno da 0 a 3 e vuoi catturare tutti i valori possibili. Questo è il suo tavolo:

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

quando guardiamo questa stessa tabella binaria vediamo i seguenti risultati:

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

Ora forse vedi già qualche modello ma quando combino il valore uno e due vedo che stai usando tutti i valori 0000, 0001, 0010, ..... 1110 e 1111. Ora combiniamo il valore uno e due per creare un singolo Numero intero a 4 bit.

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

Quando lo traduciamo nuovamente in valori decimali, vediamo una matrice molto possibile di valori in cui l'uno e due combinati potrebbero essere usati come indice:

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

L'array è quindi {0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 2, 1, 3, 3}, dove l'indice è semplicemente uno e due combinati.

Non sono un programmatore Java, ma puoi sbarazzarti di tutte le istruzioni if ​​e scriverlo come qualcosa del genere:

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

Non so se un bit-shift di 2 sia più veloce della moltiplicazione. Ma potrebbe valere la pena provarlo.

Questo utilizza un po 'di bitmagic (lo stai già facendo tenendo due bit di informazione (basso / alto e attacco / blocco) in un unico numero intero):

Non l'ho eseguito, l'ho digitato solo qui, per favore ricontrolla. L'idea sicuramente funziona. EDIT: ora è testato per ogni input, funziona bene.

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

O dovrei suggerire di separare i due bit di informazioni in variabili separate? Il codice basato principalmente su operazioni su bit come questa sopra è di solito molto difficile da mantenere.

Ad essere onesti, ognuno ha il proprio stile di codice. Non avrei pensato che le prestazioni sarebbero state influenzate troppo. Se lo capisci meglio dell'uso della versione di una custodia, continua a usarlo.

Potresti annidare gli if, quindi potenzialmente ci sarebbe un leggero aumento delle prestazioni per i tuoi ultimi controlli se non avrebbe attraversato tante istruzioni if. Ma nel tuo contesto di un corso Java di base probabilmente non ne trarrà beneficio.

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

Quindi, invece di ...

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

Faresti...

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

E riformattalo come preferisci.

Questo non migliora l'aspetto del codice, ma potenzialmente lo accelera un po ', credo.

Vediamo cosa sappiamo

1: le tue risposte sono simmetriche per P1 (giocatore uno) e P2 (giocatore due). Questo ha senso per un gioco di combattimento ma è anche qualcosa di cui puoi trarre vantaggio per migliorare la tua logica.

2: 3 battiti 0 battiti 2 battiti 1 battiti 3. Gli unici casi non coperti da questi casi sono combinazioni di 0 vs 1 e 2 vs 3. Per dirla in un altro modo, la tabella delle vittorie unica è simile a questa: 0 battiti 2, 1 battiti 3, 2 battiti 1, 3 battiti 0.

3: Se 0/1 vanno l'uno contro l'altro, allora c'è un pareggio senza colpi, ma se 2/3 vanno uno contro l'altro, entrambi colpiscono

Innanzitutto, costruiamo una funzione a senso unico che ci dice se abbiamo vinto:

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

Possiamo quindi utilizzare questa funzione per comporre il risultato finale:

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

Mentre questo è probabilmente più complesso e probabilmente più lento della ricerca della tabella offerta in molte risposte, credo che sia un metodo superiore perché incapsula effettivamente la logica del tuo codice e lo descrive a chiunque stia leggendo il tuo codice. Penso che questo lo renda una migliore implementazione.

(È da un po 'che non faccio Java, quindi mi scuso se la sintassi è disattivata, si spera che sia ancora comprensibile se ho sbagliato leggermente)

A proposito, 0-3 significa chiaramente qualcosa; non sono valori arbitrari, quindi sarebbe utile nominarli.

Spero di capire correttamente la logica. Che ne dici di qualcosa come:

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

Controllare un colpo alto o un colpo basso non è bloccato e lo stesso vale per il giocatore due.

Edit: Algorithm non è stato del tutto compreso, "hit" assegnato durante il blocco che non avevo realizzato (grazie 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;
}

Non ho esperienza con Java, quindi potrebbero esserci degli errori di battitura. Si prega di considerare il codice come pseudo-codice.

Vorrei andare con un semplice interruttore. Per questo, avresti bisogno di una valutazione a singolo numero. Tuttavia, per questo caso, poiché 0 <= one < 4 <= 9e 0 <= two < 4 <= 9, possiamo convertire entrambi gli in in un semplice int moltiplicando oneper 10 e aggiungendo two. Quindi utilizzare un interruttore nel numero risultante come questo:

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

C'è un altro metodo breve che voglio solo indicare come codice teorico. Tuttavia non lo userei perché ha qualche complessità in più che normalmente non vorresti affrontare. La complessità extra deriva dalla base 4 , perché il conteggio è 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];
}

Davvero solo una nota aggiuntiva, nel caso mi manchi qualcosa da Java. In PHP farei:

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

Dato che preferisci i ifcondizionali nidificati , ecco un altro modo.
Si noti che non utilizza il resultmembro e non cambia alcuno stato.

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

Provalo con la custodia dell'interruttore. ..

Dai un'occhiata qui o qui per maggiori informazioni a riguardo

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

È possibile aggiungere più condizioni (non contemporaneamente) e persino avere un'opzione predefinita in cui non sono stati soddisfatti altri casi.

PS: solo se una condizione deve essere soddisfatta ..

Se si presentano contemporaneamente 2 condizioni .. Non credo che l'interruttore possa essere utilizzato. Ma puoi ridurre il tuo codice qui.

Istruzione switch Java più casi

La prima cosa che mi venne in mente fu essenzialmente la stessa risposta data da Francisco Presencia, ma ottimizzata in qualche modo:

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

È possibile ottimizzarlo ulteriormente rendendo l'ultimo caso (per 3) il caso predefinito:

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

Il vantaggio di questo metodo è che è più facile vedere quali valori per onee twocorrispondono a quali valori restituiti rispetto ad alcuni degli altri metodi suggeriti.

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

È possibile utilizzare una custodia invece del mutipleif

Inoltre, per menzionare il fatto che, poiché si hanno due variabili, è necessario unire le due variabili per usarle in switch

Controllare questa istruzione switch Java per gestire due variabili?

Mentre disegno un tavolo tra uno / due e il risultato, vedo uno schema,

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

Quanto sopra ridurrebbe almeno 3 se le dichiarazioni. Non vedo un modello prestabilito né sono in grado di ricavare molto dal codice fornito, ma se tale logica può essere derivata, ridurrebbe un numero di istruzioni if.

Spero che questo ti aiuti.

Un buon punto sarebbe quello di definire le regole come testo, quindi puoi facilmente ottenere la formula corretta. Questo è estratto dalla bella rappresentazione in array di laalto:

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

E qui andiamo con alcuni commenti generali, ma dovresti descriverli in termini di regole:

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

Ovviamente potresti ridurlo a meno codice, ma è generalmente una buona idea capire cosa codifichi piuttosto che trovare una soluzione compatta.

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

Qualche spiegazione sui complicati successi di p1 / p2 sarebbe ottima, sembra interessante!

La soluzione più breve e ancora leggibile:

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

o anche più breve:

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

Non contiene numeri "magici";) Spero che aiuti.

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

Personalmente mi piace mettere in cascata operatori ternari:

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

Ma nel tuo caso, puoi usare:

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

In alternativa, puoi notare uno schema in bit:

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

Quindi puoi usare la magia:

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

Ecco una versione abbastanza concisa, simile alla risposta di JAB . Questo utilizza una mappa per memorizzare che sposta il trionfo sugli altri.

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

Esempio:

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

stampe:

P1Win

Userei una mappa, una HashMap o una TreeMap

Soprattutto se i parametri non sono nel modulo 0 <= X < N

Come un insieme di numeri interi casuali positivi.

Codice

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

Grazie a @Joe Harper mentre ho finito per usare una variante della sua risposta. Per ridurlo ulteriormente poiché 2 risultati per 4 erano gli stessi, l'ho ridotto ulteriormente.

Potrei tornare a questo ad un certo punto, ma se non ci sono grandi resistenze causate da più ifdichiarazioni, per ora lo terrò. Esaminerò la matrice della tabella e cambierò ulteriormente le soluzioni di istruzione.

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. Usa costanti o enumerazioni per rendere il codice più leggibile
2. Prova a dividere il codice in più funzioni
3. Prova a usare la simmetria del problema

Ecco un suggerimento su come potrebbe apparire, ma usare un ints qui è ancora brutto:

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

Sarebbe più bello usare un tipo strutturato per l'input e l'output. L'input in realtà ha due campi: la posizione e il tipo (blocco o attacco). L'output ha anche due campi: player1Wins e player2Wins. La codifica in un unico numero intero rende più difficile la lettura del codice.

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

Sfortunatamente, Java non è molto bravo a esprimere questo tipo di tipi di dati.

Invece fai qualcosa del genere

   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
    }

    }