Zu viele "wenn" - Aussagen?

Wenn Sie nicht kommen mit einer Formel, die Sie verwenden können, ein Tisch für eine begrenzte Anzahl von Ergebnissen:

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

InformationsquelleAutor der Antwort laalto

Ich mag keinen der präsentierten Lösungen, außer für JAB ist. Keiner der anderen es einfach machen, den code zu Lesen und zu verstehen, was berechnet.

Hier, wie ich, würde dieser code zu schreiben-ich weiß nur, C#, Java nicht, aber Sie erhalten das Bild:

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

Jetzt ist es viel mehr klar, was berechnet hier: dies unterstreicht, dass wir-computing, die getroffen wird, durch das, was angreifen und für die Rückgabe der beiden Ergebnisse.

Allerdings könnte dies noch besser; das Boolean-array ist etwas undurchsichtig. Ich mag die Tabelle-lookup-Ansatz, aber ich wäre geneigt zu schreiben, es in einer Weise, die deutlich machte, was der beabsichtigten Spiel-Semantik wurden. Das heißt, anstatt "ein Angriff von null und eine Verteidigung ergibt keine Treffer", statt einen Weg finden, um den code deutlicher zu bedeuten "einen low-kick-Angriff und einem niedrigen block-Verteidigung ergibt sich kein Treffer". Den code spiegeln die business-Logik des Spiels.

InformationsquelleAutor der Antwort Eric Lippert

Andere Leute haben auch schon vorgeschlagen, meine ursprüngliche Idee, die matrix-Methode, sondern darüber hinaus zur Festigung der if-Anweisungen können Sie vermeiden, einige von dem, was Sie haben, dafür zu sorgen, dass Argumente geliefert werden, die in dem erwarteten Bereich und mithilfe von in-place gibt (einige coding-standards, die ich gesehen habe durchzusetzen, one-point-of-Abfahrt für Funktionen, aber ich habe festgestellt, dass mehrere Rücksendungen sind sehr nützlich für die Vermeidung von Pfeil Codierung und mit der Prävalenz von Ausnahmen in Java es gibt nicht viel Punkt in streng Durchsetzung dieser Regel jedenfalls als jede uncaught exception geworfen werden, innerhalb der Methode ist ein möglicher Punkt, der Ausgang sowieso). Verschachtelung switch-Anweisungen ist eine Möglichkeit, aber für den kleinen Bereich der Werte, die Sie überprüft haben, hier finde ich die if-Anweisungen werden kompakter und voraussichtlich nicht zu viel von einem performance-Unterschied, vor allem, wenn Ihr Programm ist rundenbasiert statt in Echtzeit.

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
}

Diese nicht am Ende wird weniger lesbar, als es sonst aufgrund der Unregelmäßigkeit der Teile der input->Ergebnis-mapping. Ich bevorzuge den matrix-Stil statt, die aufgrund Ihrer Einfachheit und wie können Sie die matrix sinnvoll visuell (aber das ist zum Teil beeinflusst durch meine Erinnerungen von Karnaugh maps):

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

Update: Angesichts Ihrer erwähnen zu blockieren/schlagen, hier ist eine weitere Radikale änderung der Funktion, die nutzt propertied/Attribut-holding aufgezählten Arten für die Eingaben und das Ergebnis und ändert auch das Ergebnis ein wenig zu Konto für die Sperrung, sollte das Ergebnis in eine besser lesbare Funktion.

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

Sie haben nicht einmal um die Funktion zu ändern, selbst wenn Sie hinzufügen möchten, Blöcke/Angriffe, mehr Höhen, nur die enums; zusätzliche Arten von Bewegungen wird wahrscheinlich erfordern eine änderung der Funktion, wenn. Auch, EnumSets könnte besser erweiterbar als die Verwendung von extra enums als Eigenschaften der wichtigsten enum, z.B. EnumSet<Move> attacks = EnumSet.of(Move.ATTACK_HIGH, Move.ATTACK_LOW, ...); und dann attacks.contains(move) eher als move.type == MoveType.ATTACKallerdings mit EnumSets wahrscheinlich etwas langsamer sein als die direkte equals prüft.

Für den Fall, wo ein erfolgreicher block Ergebnisse in einen Zähler, können Sie ersetzen Sie if (one.height == two.height) return LandedHit.NEITHER; mit

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

Auch, ersetzen einige der if Aussagen mit der Nutzung der ternäre operator (boolean_expression ? result_if_true : result_if_false) könnte der code kompakter (zum Beispiel, der code im vorherigen block werden würde return one.isAttack() ? LandedHit.PLAYER_TWO : LandedHit.PLAYER_ONE;), aber kann dazu führen, dass hart-zu-Lesen oneliners also ich würde nicht empfehlen es für komplexere Verzweigung.

InformationsquelleAutor der Antwort JAB

Nutzt diese ein wenig bitmagic (Sie tun es bereits durch Aufnahme von zwei bits von Informationen (niedrig/hoch & Angriff/block) in einem einzigen integer):

ich habe es nicht benutzen, nur schrieb es hier, bitte prüfen. Die Idee sicher funktioniert.
EDIT: ist Es jetzt getestet, die für jede Eingabe, funktioniert gut.

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

Oder sollte ich schlage vor, trennen Sie die zwei bits von Informationen in separate Variablen?
Code meist basierend auf dem bit-Operationen, wie dies oben ist in der Regel wirklich schwer zu pflegen.

InformationsquelleAutor der Antwort elias

Lassen Sie uns sehen, was wir wissen

1: Ihre Antworten sind symmetrisch für P1 (Spieler eins) und P2 (Spieler zwei). Dies macht Sinn für ein Kampf-Spiel, aber ist auch etwas, das Sie nutzen können, um verbessern Sie Ihre Logik.

2: 3 beats beats 2 0 schlägt 1 Schläge 3. Die einzigen Fälle, die nicht unter diese Fälle sind Kombinationen von 0 vs 1 und 2 vs 3. Mit anderen Worten-der einzigartige Sieg-Tabelle sieht wie folgt aus: 0 schlägt 2, 1 Schläge 3, 2 Schläge 1, 3 schlägt 0.

3: 0/1 gehen gegeneinander, dann gibt es eine durch Hitless ziehen, aber wenn 2/3 gehen gegen jede dann beide Treffer

Erste, lasst uns bauen Sie ein one-way-Funktion, die uns erzählen, wenn wir gewonnen:

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

Können wir dann verwenden Sie diese Funktion zum erstellen der final-Ergebnis:

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

Während dies ist wohl komplexer und wahrscheinlich langsamer als die lookup-Tabelle angeboten, in vielen Antworten ich glaube, es ist eine hervorragende Methode, weil es tatsächlich kapselt die Logik des Codes und beschreibt es jedem, der das Lesen Ihres Codes. Ich denke, dies macht es zu einem besseren Umsetzung.

(Es ist schon eine Weile her, ich habe alle Java-also entschuldigt, wenn die syntax aus, hoffentlich ist es trotzdem verständlich, wenn ich habe es ein wenig falsch)

Durch die Art und Weise, 0-3 klar bedeuten etwas; Sie sind nicht beliebige Werte, so dass es helfen würde, Sie zu benennen.

InformationsquelleAutor der Antwort Jack Aidley

Ich habe keine Erfahrung mit Java, so könnte es einige Tippfehler. Bitte betrachten Sie das code-pseudo-code.

Dann würde ich mit einem einfachen Schalter. Für, die, Sie müssten eine einzelne Zahl Evaluierung. Jedoch, für diesen Fall, da 0 <= one < 4 <= 9 und 0 <= two < 4 <= 9 können wir konvertieren die beiden ints zu einem einfachen int durch Multiplikation one durch 10 und addieren two. Verwenden Sie dann einen Schalter in die sich daraus ergebende Zahl wie diese:

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

Gibt es noch eine kurze Methode, die ich möchte nur darauf hinweisen, wie eine theoretische code. Aber ich würde es nicht verwenden, weil es einige zusätzliche Komplexität, die Sie normalerweise nicht wollen, zu beschäftigen. Die zusätzliche Komplexität kommt aus der base 4denn das zählen wird 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];
}

Wirklich nur als zusätzlicher Hinweis, falls ich etwas fehlt von Java. In PHP würde ich das tun:

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

InformationsquelleAutor der Antwort Francisco Presencia

Versuchen Sie es mit switch-Gehäuse...

Werfen Sie einen Blick hier oder hier für mehr info über es

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

Können Sie hinzufügen mehrere Bedingungen(nicht gleichzeitig) und auch haben eine Standard-optionwo keine anderen Fälle zufrieden gewesen.

PS: Nur wenn eine Bedingung ist, um zufrieden zu sein..

Wenn 2 Bedingungen gleichzeitig auftreten.. ich glaube nicht, dass Schalter verwendet werden kann.
Aber reduzieren Sie Ihren code hier ein.

Java switch-Anweisung in mehreren Fällen

InformationsquelleAutor der Antwort Nevin Madhukar K

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

InformationsquelleAutor der Antwort Dawood ibn Kareem

Wie ich zeichnen Sie eine Tabelle zwischen ein/zwei und das Ergebnis ist, ich sehe eine Muster,

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

Den oben abschneiden würde unten mindestens 3 if-Anweisungen. Ich sehe nicht ein festes Muster, noch bin ich in der Lage zu Lesen viel aus dem code - aber wenn eine solche Logik abgeleitet werden kann, wäre es cut nach unten eine Reihe von if-Anweisungen.

Hoffe, das hilft.

InformationsquelleAutor der Antwort AnonNihcas

Die kürzeste und noch lesbar Lösung:

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

oder noch kürzer:

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

Enthält keine "Magische" Zahl 😉
Hoffe, es hilft.

InformationsquelleAutor der Antwort P.W.

Ich persönlich mag die Kaskade ternäre Operatoren:

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

Aber in Ihrem Fall, die Sie verwenden können:

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

Oder, Sie können feststellen, ein Muster in bits:

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

So können Sie Magie verwenden:

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

InformationsquelleAutor der Antwort Kirill Gamazkov

Ich würde eine Karte, entweder HashMap oder TreeMap

Besonders, wenn der Parameter nicht auf die form 0 <= X < N

Wie eine Reihe von zufälligen positiven ganzen zahlen ..

Code

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

InformationsquelleAutor der Antwort Khaled.K

1. Verwenden Sie Konstanten oder enums machen den code lesbarer
2. Versuchen, teilen Sie den code in weitere Funktionen
3. Versuchen, verwenden Sie die Symmetrie des Problems

Hier ist ein Vorschlag, wie dies Aussehen könnte, aber die Nutzung eines ints hier ist immer noch eine Art von hässlich:

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

Schöner wäre es natürlich, verwenden Sie einen strukturierten Datentyp für die Eingabe und die Ausgabe. Die Eingabe hat eigentlich zwei Felder: die position und den Typ (block oder Angriff). Die Ausgabe hat auch zwei Felder: player1Wins und player2Wins. Die Kodierung dieser in einem einzigen ganzzahligen macht es schwieriger, den code zu Lesen.

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

Leider ist Java nicht sehr gut an, um diese Arten von Daten-Typen.

InformationsquelleAutor der Antwort peq