Quá nhiều câu lệnh 'nếu'?

Đoạn mã sau hoạt động theo cách tôi cần, nhưng nó xấu, quá mức hoặc một số thứ khác. Tôi đã xem xét các công thức và cố gắng viết một vài giải pháp, nhưng cuối cùng tôi cũng nhận được một lượng báo cáo tương tự.

Có một loại công thức toán học nào có lợi cho tôi trong trường hợp này hay là 16 nếu các câu lệnh được chấp nhận?

Để giải thích mã, đây là một loại trò chơi theo lượt đồng thời .. hai người chơi có bốn nút hành động và mỗi kết quả đến từ một mảng (0-3), nhưng các biến 'một' & 'hai' có thể là giao bất cứ điều gì nếu điều này giúp. Kết quả là, 0 = không thắng, 1 = p1 thắng, 2 = p2 thắng, 3 = cả hai thắng.

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

Nếu bạn không thể đưa ra công thức, bạn có thể sử dụng bảng cho số lượng kết quả hạn chế như vậy:

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

Vì tập dữ liệu của bạn rất nhỏ, bạn có thể nén mọi thứ thành 1 số nguyên dài và biến nó thành công thức

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

Biến thể bitwise hơn:

Điều này sử dụng thực tế mọi thứ là bội số của 2

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

Nguồn gốc của hằng số ma thuật

Tôi có thể nói gì? Thế giới cần phép thuật, đôi khi khả năng một cái gì đó kêu gọi sự sáng tạo của nó.

Bản chất của hàm giải quyết vấn đề của OP là ánh xạ từ 2 số (một, hai), miền {0,1,2,3} đến phạm vi {0,1,2,3}. Mỗi câu trả lời đã tiếp cận cách thực hiện bản đồ đó.

Ngoài ra, bạn có thể thấy trong một số câu trả lời phân chia lại vấn đề dưới dạng bản đồ 1 cơ sở 2 chữ số 4 số N (một, hai) trong đó một là chữ số 1, hai là chữ số 2 và N = 4 * một + hai; N = {0,1,2, ..., 15} - mười sáu giá trị khác nhau, đó là điều quan trọng. Đầu ra của hàm là một cơ sở 1 chữ số gồm 4 số {0,1,2,3} - 4 giá trị khác nhau, cũng rất quan trọng.

Bây giờ, một số cơ sở 4 chữ số có thể được biểu thị dưới dạng số cơ sở 2 chữ số 2; {0,1,2,3} = {00,01,10,11} và do đó, mỗi đầu ra có thể được mã hóa chỉ với 2 bit. Từ trên xuống, chỉ có 16 đầu ra khác nhau có thể, vì vậy 16 * 2 = 32 bit là tất cả những gì cần thiết để mã hóa toàn bộ bản đồ; tất cả có thể vừa với 1 số nguyên.

Hằng số M là mã hóa của bản đồ m trong đó m (0) được mã hóa theo bit M [0: 1], m (1) được mã hóa theo bit M [2: 3] và m (n) được mã hóa theo bit M [n * 2: n * 2 + 1].

Tất cả những gì còn lại là lập chỉ mục và trả về phần bên phải của hằng số, trong trường hợp này bạn có thể dịch chuyển M đúng 2 * N lần và lấy 2 bit có ý nghĩa nhỏ nhất, đó là (M >> 2 * N) & 0x3. Các biểu thức (một << 3) và (hai << 1) chỉ là nhân lên nhiều thứ trong khi lưu ý rằng 2 * x = x << 1 và 8 * x = x << 3.

Tôi không thích bất kỳ giải pháp nào được trình bày ngoại trừ JAB. Không ai trong số những người khác làm cho nó dễ dàng để đọc mã và hiểu những gì đang được tính toán .

Đây là cách tôi sẽ viết mã này - Tôi chỉ biết C #, không phải Java, nhưng bạn có được hình ảnh:

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

Bây giờ thì rõ ràng hơn những gì đang được tính toán ở đây: điều này nhấn mạnh rằng chúng ta đang tính toán những người bị tấn công bởi những gì tấn công và trả lại cả hai kết quả.

Tuy nhiên điều này có thể còn tốt hơn; mảng Boolean có phần mờ đục. Tôi thích cách tiếp cận tra cứu bảng nhưng tôi sẽ có xu hướng viết nó theo cách làm cho nó rõ ràng về ngữ nghĩa trò chơi dự định là gì. Đó là, thay vì "một cuộc tấn công bằng không và phòng thủ một kết quả không bị tấn công", thay vào đó, hãy tìm cách làm cho mã rõ ràng hơn ngụ ý "một cuộc tấn công đá thấp và phòng thủ khối thấp không gây ra cú đánh". Làm cho mã phản ánh logic kinh doanh của trò chơi.

Bạn có thể tạo ma trận chứa kết quả

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

Khi bạn muốn nhận được giá trị, bạn sẽ sử dụng

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

Những người khác đã đề xuất ý tưởng ban đầu của tôi, phương thức ma trận, nhưng ngoài việc hợp nhất các câu lệnh if, bạn có thể tránh một số điều bạn có bằng cách đảm bảo các đối số được cung cấp nằm trong phạm vi dự kiến ​​và bằng cách sử dụng trả về tại chỗ (một số mã hóa các tiêu chuẩn mà tôi đã thấy thực thi một điểm thoát cho các hàm, nhưng tôi thấy rằng nhiều trả về rất hữu ích để tránh mã hóa mũi tên và với sự phổ biến của các ngoại lệ trong Java dù sao cũng không thực thi nghiêm ngặt quy tắc như vậy vì bất kỳ ngoại lệ chưa được lưu nào được ném bên trong phương thức là một điểm có thể thoát ra bằng mọi cách). Các câu lệnh chuyển đổi lồng nhau là một khả năng, nhưng đối với phạm vi giá trị nhỏ mà bạn đang kiểm tra ở đây tôi thấy nếu các câu lệnh nhỏ gọn hơn và không có khả năng dẫn đến sự khác biệt về hiệu suất,

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
}

Điều này cuối cùng không thể đọc được hơn nó có thể là do sự bất thường của các phần của ánh xạ kết quả đầu vào->. Thay vào đó, tôi thích phong cách ma trận do tính đơn giản của nó và cách bạn có thể thiết lập ma trận để có ý nghĩa trực quan (mặc dù điều đó một phần bị ảnh hưởng bởi ký ức của tôi về bản đồ Karnaugh):

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

Cập nhật: Khi bạn đề cập đến việc chặn / đánh, đây là một thay đổi căn bản hơn đối với chức năng sử dụng các kiểu liệt kê được giữ đúng / thuộc tính cho các đầu vào và kết quả và cũng sửa đổi kết quả một chút để tính đến việc chặn, điều này sẽ dẫn đến nhiều hơn chức năng có thể đọc được.

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

Bạn thậm chí không phải thay đổi chức năng nếu bạn muốn thêm các khối / tấn công có độ cao hơn, chỉ là các enum; thêm các loại di chuyển có thể sẽ yêu cầu sửa đổi chức năng, mặc dù. Ngoài ra, EnumSets có thể mở rộng hơn so với sử dụng enum bổ sung làm thuộc tính của enum chính, ví dụ EnumSet<Move> attacks = EnumSet.of(Move.ATTACK_HIGH, Move.ATTACK_LOW, ...);và sau đó attacks.contains(move)hơn là move.type == MoveType.ATTACK, mặc dù sử dụng EnumSets có thể sẽ chậm hơn một chút so với kiểm tra bằng trực tiếp.

Đối với trường hợp khối thành công dẫn đến bộ đếm, bạn có thể thay thế if (one.height == two.height) return LandedHit.NEITHER;bằng

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

Ngoài ra, việc thay thế một số ifcâu lệnh bằng cách sử dụng toán tử ternary ( boolean_expression ? result_if_true : result_if_false) có thể làm cho mã nhỏ gọn hơn (ví dụ: mã trong khối trước sẽ trở thành return one.isAttack() ? LandedHit.PLAYER_TWO : LandedHit.PLAYER_ONE;), nhưng điều đó có thể dẫn đến các onelin khó đọc hơn nên tôi sẽ không đọc được t đề nghị nó cho phân nhánh phức tạp hơn.

Tại sao không sử dụng một mảng?

Tôi sẽ bắt đầu lại từ đầu. Tôi thấy một mẫu, các giá trị đi từ 0 đến 3 và bạn muốn bắt tất cả các giá trị có thể. Đây là bảng của bạn:

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

Khi chúng ta nhìn vào bảng nhị phân này, chúng ta sẽ thấy các kết quả sau:

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

Bây giờ có thể bạn đã thấy một số mẫu nhưng khi tôi kết hợp giá trị một và hai tôi thấy rằng bạn đang sử dụng tất cả các giá trị 0000, 0001, 0010, ..... 1110 và 1111. Bây giờ, hãy kết hợp giá trị một và hai để tạo một giá trị Số nguyên 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

Khi chúng tôi dịch lại thành giá trị thập phân, chúng tôi thấy một mảng các giá trị rất có thể trong đó một và hai kết hợp có thể được sử dụng làm chỉ mục:

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

Mảng là sau đó {0, 0, 1, 2, 0, 0, 2, 1, 2, 1, 3, 3, 2, 1, 3, 3}, trong đó chỉ mục của nó chỉ đơn giản là một và hai kết hợp.

Tôi không phải là một lập trình viên Java nhưng bạn có thể loại bỏ tất cả các câu lệnh if và chỉ viết nó ra dưới dạng như thế này:

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

Tôi không biết nếu một bithift bằng 2 nhanh hơn phép nhân. Nhưng nó có thể là giá trị một thử.

Điều này sử dụng một chút bitmagic (bạn đã thực hiện bằng cách giữ hai bit thông tin (thấp / cao & tấn công / khối) trong một số nguyên duy nhất):

Tôi không chạy nó, chỉ gõ nó ở đây, xin vui lòng nhân đôi. Ý tưởng chắc chắn hoạt động. EDIT: Bây giờ nó đã được thử nghiệm cho mọi đầu vào, hoạt động tốt.

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

Hoặc tôi nên đề nghị tách hai bit thông tin thành các biến riêng biệt? Mã dựa chủ yếu vào các hoạt động bit như thế này ở trên thường rất khó để duy trì.

Thành thật mà nói, mọi người đều có phong cách mã riêng. Tôi sẽ không nghĩ rằng hiệu suất sẽ bị ảnh hưởng quá nhiều. Nếu bạn hiểu điều này tốt hơn là sử dụng phiên bản vỏ hộp chuyển đổi, thì hãy tiếp tục sử dụng cái này.

Bạn có thể lồng các if, vì vậy có khả năng sẽ có một sự gia tăng hiệu suất nhẹ cho lần cuối của bạn nếu kiểm tra vì nó sẽ không trải qua nhiều câu lệnh if. Nhưng trong ngữ cảnh của một khóa học java cơ bản, nó có thể sẽ không có lợi.

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

Vì vậy, thay vì ...

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

Bạn sẽ làm ...

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

Và chỉ định dạng lại nó như bạn muốn.

Điều này không làm cho mã trông đẹp hơn, nhưng có khả năng tăng tốc một chút tôi tin.

Hãy xem những gì chúng ta biết

1: câu trả lời của bạn là đối xứng cho P1 (người chơi một) và P2 (người chơi hai). Điều này có ý nghĩa đối với một trò chơi chiến đấu nhưng cũng là thứ bạn có thể tận dụng để cải thiện logic của mình.

2: 3 nhịp 0 nhịp 2 nhịp 1 nhịp 3. Các trường hợp duy nhất không được bao gồm trong các trường hợp này là kết hợp 0 ​​vs 1 và 2 vs 3. Nói cách khác, bảng chiến thắng duy nhất trông như thế này: 0 nhịp 2, 1 nhịp 3, 2 nhịp 1, 3 nhịp 0.

3: Nếu 0/1 đi lên với nhau thì sẽ có một trận hòa không thành công nhưng nếu 2/3 đi ngược lại thì cả hai đều đánh

Trước tiên, chúng ta hãy xây dựng hàm một chiều cho chúng ta biết nếu chúng ta thắng:

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

Sau đó chúng ta có thể sử dụng chức năng này để soạn kết quả cuối cùng:

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

Mặc dù điều này phức tạp hơn và có thể chậm hơn so với tra cứu bảng được đưa ra trong nhiều câu trả lời, tôi tin rằng đây là một phương pháp ưu việt vì nó thực sự gói gọn logic của mã của bạn và mô tả nó cho bất kỳ ai đọc mã của bạn. Tôi nghĩ rằng điều này làm cho nó thực hiện tốt hơn.

(Đã được một thời gian kể từ khi tôi thực hiện bất kỳ Java nào nên xin lỗi nếu cú ​​pháp bị tắt, hy vọng nó vẫn dễ hiểu nếu tôi hiểu sai một chút)

Nhân tiện, 0-3 rõ ràng có ý nghĩa gì đó; chúng không phải là giá trị tùy ý nên sẽ giúp đặt tên cho chúng.

Tôi hy vọng tôi hiểu logic một cách chính xác. Làm thế nào về một cái gì đó như:

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

Kiểm tra một lần đánh cao hoặc một lần hạ thấp không bị chặn và tương tự đối với người chơi hai.

Chỉnh sửa: Thuật toán chưa được hiểu đầy đủ, "hit" được trao khi chặn mà tôi không nhận ra (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;
}

Tôi không có kinh nghiệm với Java nên có thể có một số lỗi chính tả. Vui lòng coi mã là mã giả.

Tôi sẽ đi với một công tắc đơn giản. Đối với điều đó, bạn cần một đánh giá số duy nhất. Tuy nhiên, trong trường hợp này, kể từ 0 <= one < 4 <= 9và 0 <= two < 4 <= 9, chúng ta có thể chuyển đổi cả int thành int đơn giản bằng cách nhân onevới 10 và thêm two. Sau đó sử dụng một công tắc trong số kết quả như thế này:

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ó một phương pháp ngắn khác mà tôi chỉ muốn chỉ ra như một mã lý thuyết. Tuy nhiên tôi sẽ không sử dụng nó bởi vì nó có một số phức tạp thêm mà bạn thường không muốn giải quyết. Sự phức tạp thêm đến từ cơ sở 4 , vì số đếm là 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];
}

Thực sự chỉ là ghi chú bổ sung, trong trường hợp tôi thiếu thứ gì đó từ Java. Trong PHP tôi sẽ là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];
}

Vì bạn thích các ifđiều kiện lồng nhau , đây là một cách khác.
Lưu ý rằng nó không sử dụng resultthành viên và nó không thay đổi bất kỳ trạng thái nào.

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

Hãy thử nó với vỏ chuyển đổi. ..

Hãy xem ở đây hoặc ở đây để biết thêm về nó

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

Bạn có thể thêm nhiều điều kiện (không đồng thời) vào nó và thậm chí có một tùy chọn mặc định trong đó không có trường hợp nào khác được thỏa mãn.

PS: Chỉ khi một điều kiện được thỏa mãn ..

Nếu 2 điều kiện phát sinh đồng thời .. Tôi không nghĩ chuyển đổi có thể được sử dụng. Nhưng bạn có thể giảm mã của bạn ở đây.

Câu lệnh chuyển đổi Java nhiều trường hợp

Điều đầu tiên xảy ra với tôi về cơ bản là cùng một câu trả lời được đưa ra bởi Francisco Presencia, nhưng được tối ưu hóa phần nào:

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

Bạn có thể tối ưu hóa thêm bằng cách đặt trường hợp cuối cùng (cho 3) trường hợp mặc định:

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

Ưu điểm của phương pháp này là dễ dàng hơn để xem giá trị nào onevà twotương ứng với giá trị nào trả về so với một số phương thức được đề xuất khác.

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

Bạn có thể sử dụng trường hợp chuyển đổi thay vì mutiplif

Ngoài ra, để đề cập rằng vì bạn có hai biến nên bạn phải hợp nhất hai biến để sử dụng chúng trong chuyển đổi

Kiểm tra câu lệnh chuyển đổi Java này để xử lý hai biến?

Khi tôi vẽ một bảng giữa một / hai và kết quả, tôi thấy một mẫu,

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

Ở trên sẽ cắt giảm ít nhất 3 nếu báo cáo. Tôi không thấy một mẫu thiết lập cũng như tôi không thể lượm lặt được nhiều từ mã được đưa ra - nhưng nếu logic đó có thể được dẫn xuất, nó sẽ cắt giảm một số câu lệnh if.

Hi vọng điêu nay co ich.

Một điểm tốt sẽ là xác định các quy tắc như văn bản, sau đó bạn có thể dễ dàng rút ra công thức chính xác. Điều này được trích xuất từ ​​đại diện mảng đẹp của laalto:

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

Và ở đây chúng tôi đi với một số ý kiến ​​chung, nhưng bạn nên mô tả chúng theo các quy tắc:

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

Tất nhiên bạn có thể giảm bớt mã này xuống ít mã hơn, nhưng nói chung nên hiểu mã của bạn hơn là tìm một giải pháp nhỏ gọn.

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

Một số lời giải thích về các lượt truy cập p1 / p2 phức tạp sẽ rất tuyệt, trông thật thú vị!

Giải pháp ngắn nhất và vẫn có thể đọc được:

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

hoặc thậm chí ngắn hơ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;
}

Không chứa bất kỳ số "ma thuật" nào;) Hy vọng nó sẽ giúp.

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

Cá nhân tôi thích xếp tầng các nhà khai thác ternary:

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

Nhưng trong trường hợp của bạn, bạn có thể sử dụng:

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

Hoặc, bạn có thể nhận thấy một mẫu theo 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

Vì vậy, bạn có thể sử dụng phép thuật:

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

Đây là một phiên bản khá súc tích, tương tự như phản hồi của JAB . Điều này sử dụng một bản đồ để lưu trữ mà di chuyển chiến thắng trên những người khác.

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

Thí dụ:

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

Bản in:

P1Win

Tôi sẽ sử dụng Bản đồ, là HashMap hoặc TreeMap

Đặc biệt là nếu các tham số không có trong mẫu 0 <= X < N

Giống như một tập hợp các số nguyên dương ngẫu nhiên ..

Mã

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

Cảm ơn @Joe Harper khi tôi kết thúc bằng cách sử dụng một biến thể câu trả lời của anh ấy. Để làm giảm nó xuống hơn nữa vì 2 kết quả trên 4 là như nhau, tôi giảm nó xuống hơn nữa.

Tôi có thể quay lại vấn đề này vào một lúc nào đó, nhưng nếu không có sự kháng cự lớn nào gây ra bởi nhiều tình ifhuống thì tôi sẽ giữ điều này ngay bây giờ. Tôi sẽ xem xét ma trận bảng và chuyển đổi các giải pháp câu lệnh hơn nữa.

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. Sử dụng hằng hoặc enum để làm cho mã dễ đọc hơn
2. Cố gắng chia mã thành nhiều chức năng hơn
3. Cố gắng sử dụng tính đối xứng của vấn đề

Đây là một gợi ý làm thế nào điều này có thể trông như thế nào, nhưng sử dụng một số nguyên ở đây vẫn còn hơi xấu:

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

Nó sẽ tốt hơn để sử dụng một loại có cấu trúc cho đầu vào và đầu ra. Đầu vào thực sự có hai trường: vị trí và loại (chặn hoặc tấn công). Đầu ra cũng có hai trường: player1Wins và player2Wins. Mã hóa này thành một số nguyên duy nhất làm cho việc đọc mã khó hơn.

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

Thật không may, Java không giỏi trong việc thể hiện các loại dữ liệu đó.

Thay vào đó hãy làm một cái gì đó như thế này

   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
    }

    }