Çok fazla 'if' ifadesi var mı?

Aşağıdaki kod nasıl ihtiyacım var çalışır, ama bu çirkin, aşırı veya başka şeyler. Formüllere baktım ve birkaç çözüm yazmaya çalıştım, ancak benzer miktarda ifadeyle sonuçlandım.

Bu örnekte bana fayda sağlayacak bir tür matematik formülü var mı yoksa ifadeler kabul edilebilirse 16 mı?

Kodu açıklamak için, bir tür eşzamanlı dönüş tabanlı oyun içindir .. iki oyuncunun her biri dört eylem düğmesi vardır ve sonuçlar bir diziden (0-3) gelir, ancak 'one' ve 'two' değişkenleri olabilir bu yardımcı olursa bir şey atar. Sonuç, 0 = ne kazanırsa, 1 = p1 kazanır, 2 = p2 kazanır, 3 = her ikisi de kazanır.

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

Bir formül bulamazsanız, sınırlı sayıda sonuç için bir tablo kullanabilirsiniz:

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

Veri kümeniz çok küçük olduğundan, her şeyi 1 uzun tamsayıya sıkıştırabilir ve bir formüle dönüştürebilirsiniz.

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

Daha bitsel varyant:

Bu, her şeyin 2'nin katları olduğu gerçeğinden yararlanır

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

Büyü Sabiti'nin Kökeni

Ne söyleyebilirim? Dünyanın sihire ihtiyacı vardır, bazen bir şeyin yaratılması olasılığı çağrılır.

OP'nin problemini çözen fonksiyonun özü, 2 sayıdan (bir, iki), alan {0,1,2,3} ile {0,1,2,3} aralığına bir haritadır. Yanıtların her biri bu haritanın nasıl uygulanacağına yaklaştı.

Ayrıca, cevapların bir kısmında sorunun bir yeniden ifade edilmesini, 1 basamaklı 1, iki basamak 2 ve N = 4 * bir olan 1 2 basamaklı 4 numaralı N (bir, iki) haritası olarak görebilirsiniz. + iki; N = {0,1,2, ..., 15} - on altı farklı değer, bu önemli. İşlevin çıktısı 1 basamaklı bir temel 4 sayısı {0,1,2,3} - 4 farklı değerdir, ayrıca önemlidir.

Şimdi, 1 basamaklı bir taban 4 sayısı 2 basamaklı bir taban 2 sayısı olarak ifade edilebilir; {0,1,2,3} = {00,01,10,11} ve böylece her çıkış yalnızca 2 bitle kodlanabilir. Yukarıdan, sadece 16 farklı çıkış mümkündür, bu nedenle tüm haritayı kodlamak için gerekli olan 16 * 2 = 32 bit yeterlidir; bu 1 tamsayıya sığabilir.

M sabiti, m (0) 'nın M [0: 1] bitlerinde kodlandığı, m (1) M [2: 3] bitlerinde kodlandığı ve m (n) bit olarak kodlandığı m haritasının bir kodlamasıdır. M [n * 2: n * 2 + 1].

Geriye kalan tek şey sabitlemenin sağ kısmını indekslemek ve döndürmektir, bu durumda M sağını 2 * N kez kaydırabilir ve en az önemli 2 biti (M >> 2 * N) & 0x3 alabilirsiniz. (Bir << 3) ve (iki << 1) ifadeleri, 2 * x = x << 1 ve 8 * x = x << 3 olduğuna dikkat çekerek bir şeyleri çoğaltır.

JAB'lar dışında sunulan çözümlerin hiçbirini sevmiyorum. Diğer hiçbiri kodu okumayı ve neyin hesaplandığını anlamayı kolaylaştırmaz .

İşte bu kodu yazmak nasıl - Java değil, sadece C # biliyorum, ama resim olsun:

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

Şimdi burada neyin hesaplandığı çok daha açık: Bu, kimin hangi saldırıdan vurulduğunu hesapladığımızı ve her iki sonucu da geri verdiğimizi vurgulamaktadır.

Ancak bu daha da iyi olabilir; Boole dizisi biraz opak. Tablo arama yaklaşımını seviyorum, ancak amaçlanan oyun semantiğinin ne olduğunu netleştirecek şekilde yazmaya eğilimliydim. Yani "sıfır atak ve isabetsiz bir sonucun savunulması" yerine, kodu daha açık bir şekilde "düşük vuruş saldırısı ve düşük blok savunması isabetsiz sonuç" anlamına gelecek şekilde bulmanın bir yolunu bul. Kodun oyunun iş mantığını yansıtmasını sağlayın.

Sonuç içeren bir matris oluşturabilirsiniz

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

Değer almak istediğinizde kullanacaksınız

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

Diğer insanlar ilk fikrimi, matris yöntemini zaten önerdiler, ancak if ifadelerini birleştirmeye ek olarak, sağlanan argümanların beklenen aralıkta olduğundan ve yerinde dönüşler (bazı kodlama) kullanarak sahip olduğunuz şeylerden bazılarını önleyebilirsiniz. Standartlar işlevler için bir çıkış noktası uyguladığını gördüm, ancak ok kodlamasından kaçınmak için birden fazla dönüşün çok yararlı olduğunu gördüm ve Java'daki istisnaların yaygınlığıyla, böyle bir kuralın kesinlikle uygulanmasının pek bir anlamı yok çünkü yönteme atılan yakalanmamış istisnalar olası bir çıkış noktasıdır). Anahtar ifadelerini iç içe yerleştirme bir olasılıktır, ancak burada kontrol ettiğiniz küçük değer aralığı için ifadelerin daha kompakt olup olmadığını ve performans farkının çoğuyla sonuçlanmasının olası olmadığını,

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
}

Bu, aksi takdirde giriş-> sonuç eşlemesinin parçalarının düzensizliğinden kaynaklanabileceğinden daha az okunabilir hale gelir. Basitliği ve matrisi görsel olarak mantıklı hale getirmek için nasıl ayarlayabileceğinizi yerine matris stilini tercih ediyorum (bu kısmen Karnaugh haritalarındaki anılarımdan etkileniyor):

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

Güncelleme: Engelleme / isabetten bahsettiğinizde, girişler ve sonuç için doğrulanmış / öznitelik tutma numaralandırılmış türlerini kullanan ve ayrıca engelleme için sonucu biraz değiştirecek şekilde işlevde daha radikal bir değişiklik. okunabilir işlev.

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

Daha yükseklikte bloklar / saldırılar eklemek istiyorsanız, yalnızca numaralandırmalar işlevinin kendisini değiştirmek zorunda bile değilsiniz; Ancak, ek hareket türleri eklemek muhtemelen işlevin değiştirilmesini gerektirecektir. Ayrıca, EnumSets enumları ana enumun özellikleri olarak kullanmaktan daha uzatılabilir, örneğin EnumSet<Move> attacks = EnumSet.of(Move.ATTACK_HIGH, Move.ATTACK_LOW, ...);ve daha attacks.contains(move)ziyade move.type == MoveType.ATTACK, EnumSets'yi kullanmak muhtemelen doğrudan eşit denetimlerden biraz daha yavaş olacaktır.

Başarılı bir bloğun bir sayaçla sonuçlanması durumunda 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;
}

Ayrıca, bazı ififadelerin üçlü operatör ( boolean_expression ? result_if_true : result_if_false) kullanımı ile değiştirilmesi , kodu daha kompakt hale getirebilir (örneğin, önceki bloktaki kod haline gelir return one.isAttack() ? LandedHit.PLAYER_TWO : LandedHit.PLAYER_ONE;), ancak bu, daha zor okunan onelinerlere yol açabilir. t Daha karmaşık dallanmalar için tavsiye etmem.

Neden bir dizi kullanmıyorsunuz?

En baştan başlayacağım. Bir desen görüyorum, değerler 0'dan 3'e gidiyor ve olası tüm değerleri yakalamak istiyorsunuz. İşte masanız:

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

aynı tablo ikili dosyasına baktığımızda şu sonuçları görüyoruz:

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

Şimdi belki zaten bir desen görüyorsunuz, ancak bir ve iki değeri birleştirdiğimde, tüm değerleri 0000, 0001, 0010, ..... 1110 ve 1111'i kullandığınızı görüyorum. Şimdi tek bir değer oluşturmak için bir ve iki değerini birleştirelim. 4 bit tam sayı.

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

Bunu tekrar ondalık değerlere çevirdiğimizde, bir ve iki birleştirmenin dizin olarak kullanılabileceği çok olası bir değer dizisi görüyoruz:

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

Bu durumda dizi, dizinin {0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 2, 1, 3, 3}basitçe bir ve iki birleşimidir.

Ben bir Java programcısı değilim ama tüm if ifadelerden kurtulabilir ve sadece böyle bir şey olarak yazabilirsiniz:

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

Bitshift'in 2 ile çarpma işleminden daha hızlı olup olmadığını bilmiyorum. Ama denemeye değer olabilir.

Bu, biraz bitmagic kullanır (bunu tek bir tamsayıda iki bit bilgi (düşük / yüksek & saldırı / blok) tutarak zaten yapıyorsunuz):

Ben çalıştırmadım, sadece buraya yazdım, lütfen kontrol edin. Fikir kesinlikle işe yarıyor. EDIT: Şimdi her giriş için test edilmiştir, iyi çalışıyor.

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

Yoksa iki bilgi parçasını ayrı değişkenlere ayırmayı mı önermeliyim? Yukarıdaki gibi çoğunlukla bit işlemlerine dayanan kodun bakımı genellikle gerçekten zordur.

Dürüst olmak gerekirse, herkesin kendi kod stili vardır. Performansın çok fazla etkileneceğini düşünmezdim. Bunu bir anahtar kasa sürümü kullanmaktan daha iyi anlıyorsanız, kullanmaya devam edin.

If'leri iç içe yerleştirebilirsiniz, bu nedenle potansiyel olarak, eğer if ifadeleri kadar geçmeyeceği kadar kontrol ederse son performansınız için hafif bir performans artışı olacaktır. Ancak, temel bir java kursu bağlamında muhtemelen faydası olmayacaktır.

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

Yani, yerine ...

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

Sen yapardın ...

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

Ve sadece istediğiniz gibi yeniden biçimlendirin.

Bu kod daha iyi görünmüyor, ama muhtemelen biraz hızlandırır inanıyorum.

Bakalım ne biliyoruz

1: cevaplarınız P1 (birinci oyuncu) ve P2 (ikinci oyuncu) için simetriktir. Bu bir dövüş oyunu için mantıklı ama aynı zamanda mantığınızı geliştirmek için yararlanabileceğiniz bir şey.

2: 3 vuruş 0 vuruş 2 vuruş 1 vuruş 3. Bu vakalarda ele alınmayan tek vakalar 0 vs 1 ve 2 vs 3 kombinasyonlarıdır. Başka bir deyişle, benzersiz zafer tablosu şöyle görünür: 0 vuruş 2, 1 vuruş 3, 2 vuruş 1, 3 vuruş 0.

3: Eğer 0/1 birbirlerine karşı çıkarsa, o zaman bir beraberlik berabere kalır, ancak 2/3 birbirlerine karşı çıkarsa, her ikisi de vurur

İlk olarak, kazanıp kazanmadığımızı söyleyen tek yönlü bir işlev geliştirelim:

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

Daha sonra bu işlevi nihai sonucu oluşturmak için kullanabiliriz:

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

Bu tartışmasız daha karmaşık ve muhtemelen birçok cevap sunulan tablo arama daha yavaş olsa da, aslında kodunuzun mantığını kapsadığı ve kodunuzu okuyan herkese açıklar çünkü üstün bir yöntem olduğuna inanıyorum. Bence bu daha iyi bir uygulama.

(Herhangi bir Java yaptığımdan beri, sözdizimi kapalıysa özür dilerim, umarım biraz yanlış anladıysam hala anlaşılabilir)

Bu arada, 0-3 açıkça bir şey ifade ediyor; bunlar rastgele değerler değildir, bu yüzden onları adlandırmaya yardımcı olur.

Umarım mantığı doğru anlarım. Nasıl bir şey hakkında:

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

Bir vuruş yüksekinin veya bir vuruş düşükünün kontrol edilmesi engellenmez ve oyuncu iki için aynıdır.

Düzenleme: Algoritma tam olarak anlaşılmadı, ben fark etmedi engelleme sırasında ödül "hit" (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 ile deneyimim yok, bu yüzden bazı yazım hataları olabilir. Lütfen kodu sahte kod olarak kabul edin.

Basit bir anahtarla giderdim. Bunun için tek bir sayı değerlendirmesi yapmanız gerekir. Ancak, bu durumda, 0 <= one < 4 <= 9ve için 0 <= two < 4 <= 9, one10 ile çarparak ve ekleyerek her iki ints'ı basit bir int'e dönüştürebiliriz two. Sonra elde edilen sayıda aşağıdaki gibi bir anahtar kullanın:

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

Teorik bir kod olarak belirtmek istediğim başka bir kısa yöntem daha var. Ancak normalde uğraşmak istemediğiniz ekstra karmaşıklığa sahip olduğu için kullanmam. Ekstra karmaşıklık taban 4'ten gelir , çünkü sayma 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'dan bir şey kaçırmam durumunda gerçekten sadece ek not. PHP'de yapardım:

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

İç içe ifkoşullu tercih ettiğiniz için , işte başka bir yol.
Üyeyi kullanmadığını resultve hiçbir durumu değiştirmediğini unutmayın.

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

Anahtar muhafazası ile deneyin . ..

Bu konuda daha fazla bilgi için buraya veya buraya bir göz atın

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

Buna birden fazla koşul (aynı anda değil) ekleyebilir ve başka hiçbir durumun karşılanmadığı varsayılan bir seçeneğiniz bile olabilir .

Not: Sadece bir koşul sağlanacaksa ..

Aynı anda 2 koşul ortaya çıkarsa .. Anahtarın kullanılabileceğini sanmıyorum. Ancak kodunuzu burada azaltabilirsiniz.

Java anahtarı deyimi birden çok vaka

Bana gelen ilk şey, aslında Francisco Presencia tarafından verilen aynı cevaptı, ancak bir şekilde optimize edildi:

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

Son durumu (3 kişilik) varsayılan vaka yaparak daha da optimize edebilirsiniz:

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

Bu yöntemin avantajı , diğer önerilen yöntemlerden hangilerinin hangi değerlere oneve twohangi dönüş değerlerine karşılık geldiğini görmenin daha kolay olmasıdır .

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

Mutiple yerine bir anahtar kutusu kullanabilirsinizif

Ayrıca, iki değişkeniniz olduğundan, iki değişkeni anahtarda kullanmak için birleştirmeniz gerektiğini belirtmek gerekir.

İki değişkeni işlemek için bu Java anahtarı deyimini kontrol edin ?

Bir / iki ve sonuç arasında bir tablo çizerken, bir desen görüyorum,

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

Yukarıdaki ifadeler eğer en az 3 kesecektir. Ben bir set desen görmüyorum ne de verilen koddan çok bilgi almak mümkün - ama böyle bir mantık türetilebilir, if ifadeleri bir dizi kesecekti.

Bu yardımcı olur umarım.

Kurallar metin olarak tanımlamak iyi bir nokta olabilir, o zaman doğru formülü daha kolay elde edebilirsiniz. Bu laalto'nun güzel dizi temsilinden alınmıştır:

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

Ve burada bazı genel yorumlarla gidiyoruz, ancak bunları kural terimleriyle tanımlamanız gerekir:

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

Elbette bunu daha az kodla karşılaştırabilirsiniz, ancak kompakt bir çözüm bulmak yerine neyi kodladığınızı anlamak genellikle iyi bir fikirdir.

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

Karmaşık p1 / p2 hitleri hakkında bazı açıklamalar harika olurdu, ilginç görünüyor!

En kısa ve okunabilir çözüm:

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

veya daha kısa:

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

Herhangi bir "sihirli" sayı içermez;) Umarım yardımcı olur.

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

Şahsen üçlü operatörleri kademelendirmeyi seviyorum:

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

Ancak sizin durumunuzda şunları kullanabilirsiniz:

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

Veya bit cinsinden bir desen fark edebilirsiniz:

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

Böylece sihri kullanabilirsiniz:

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

İşte JAB'ın yanıtına benzer oldukça kısa bir versiyon . Bu, zafer kazanmak için başkalarının üzerinde hareket eden bir harita kullanır.

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

Misal:

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

Baskılar:

P1Win

Bir Harita, bir HashMap veya bir TreeMap kullanırdım

Özellikle parametreler formda değilse 0 <= X < N

Bir dizi rastgele pozitif tamsayı gibi ..

kod

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

Cevabının bir varyasyonunu kullandığım için @Joe Harper'a teşekkürler. Her 4 sonuç için 2 sonuç aynı olduğundan daha da inceltmek için daha da incelttim.

Bir noktada buna geri dönebilirim, ancak çoklu ifdurumlardan kaynaklanan büyük bir direnç yoksa o zaman şimdilik bunu saklayacağım. Tablo matrisine bakacağım ve deyim çözümlerini daha fazla değiştireceğim.

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. Kodu daha okunaklı hale getirmek için sabitleri veya sıralamaları kullanın
2. Kodu daha fazla işleve ayırmaya çalışın
3. Problemin simetrisini kullanmaya çalışın

İşte bunun nasıl görünebileceğine dair bir öneri, ancak burada bir ints kullanmak hala çirkin:

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

Girdi ve çıktı için yapılandırılmış bir tür kullanmak daha iyi olurdu. Girdinin aslında iki alanı vardır: konum ve tür (blok veya saldırı). Çıktının ayrıca iki alanı vardır: player1Wins ve player2Wins. Bunu tek bir tamsayıya kodlamak kodu okumayı zorlaştırır.

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

Ne yazık ki, Java bu tür veri türlerini ifade etmede çok iyi değil.

Bunun yerine böyle bir şey yap

   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
    }

    }