Hãy xây dựng một mô phỏng cho một khía cạnh trong trò chơi bài, mà cá nhân tôi biết bằng tên tiếng Hà Lan 'Oorlog' (tạm dịch là 'Chiến tranh').

'Oorlog' hoạt động như thế nào?

Hai bộ bài (mỗi bộ gồm hai Joker) được chia đều cho số lượng người chơi đang chơi. Mỗi người chơi xáo trộn cổ phiếu của chính họ, đặt nó lộn ngược trước mặt họ, và tất cả người chơi mở thẻ đầu tiên của cổ phiếu cùng một lúc.
Người chiến thắng trong 'trận chiến' đó được xác định bởi các giá trị của các quân bài theo các quy tắc sau: Joker / Ace đánh bại King; Vua đánh bại Nữ hoàng; Nữ hoàng đánh bại Jack; Jack đánh bại 10; 10 thất bại 9; .... Ngoài ra, cả 2 và 3 đều đánh bại Ace / Joker. Quy tắc cuối cùng có thể dẫn đến một chu kỳ trong đó 2 hoặc 3 nhịp Ace hoặc Joker, Ace hoặc Joker đánh bại một số thẻ khác, lần lượt đánh bại 2 hoặc 3. Trong trường hợp này, 2 hoặc 3 thắng trận chiến.
(Suit không liên quan trong trò chơi bài này.)

Khi hai hoặc nhiều người chơi có thẻ cao nhất bằng nhau, họ có 'chiến tranh'. Điều này có nghĩa là họ đặt một thẻ lộn ngược, và sau đó mỗi thẻ mở ra một thẻ mới từ cổ phiếu của họ, một lần nữa xem ai có thẻ cao nhất. Điều này tiếp tục cho đến khi một người chơi chiến thắng toàn bộ trận chiến.
. Điều này tiếp tục cho đến khi một người chơi hết thẻ và sau đó người chơi có số lượng thẻ cao nhất sẽ thắng.)

Ví dụ 'trận chiến' với ba người chơi:

1. 4, 8, Jack:
   Jack thắng.
2. 7, Ace, Queen:
   Ace thắng.
3. 10, 10, Vua:
   Vua thắng.
4. 3, Joker,
   thắng 2: 3.
5. Ace, Joker,
   thắng 2 : 2.
6. 3, Nữ hoàng, Ace:
   3 chiến thắng.
7. Queen, Queen, 9:
   Queen & Queen đang có một 'cuộc chiến', vì vậy nó tiếp tục với hai lá bài mới: 4, 8;
   8 chiến thắng.
8. 4, 4, 4:
   Tất cả đang có một 'cuộc chiến', vì vậy nó tiếp tục với ba thẻ mới: 8, Ace, 2;
   2 chiến thắng.
9. Jack, 5, Jack:
   Jack & Jack đang có một 'cuộc chiến', vì vậy nó tiếp tục với hai thẻ mới: 5, 5;
   5 & ​​5 cũng bằng nhau, vì vậy 'cuộc chiến' lại tiếp tục với hai lá bài mới: 10, King;
   Vua thắng.
10. Joker, Joker, Ace:
    Tất cả đang có một 'cuộc chiến', vì vậy nó tiếp tục với ba thẻ mới: 9, 7, 9;
    9 & 9 cũng bằng nhau, vì vậy 'cuộc chiến' tiếp tục với hai lá bài mới: Jack, 3;
    Jack thắng.

Vì vậy, vào thử thách mã:

Đầu vào:

STDIN với một mảng hoặc một chuỗi mô phỏng một mảng (cuộc gọi của bạn - ngay cả khi ngôn ngữ của bạn không hỗ trợ mảng). Mảng này chứa các quân bài của một trận chiến theo thứ tự thời gian (xem các trường hợp thử nghiệm để hiểu rõ hơn về điều này).

Đầu ra:

KHÔNG CÓ chỉ số của người chơi đã thắng trận chiến.
Bạn có thể chọn xem bạn có muốn một zero-lập chỉ mục (ví dụ 0, 1hoặc 2) hoặc một chỉ mục đầu ra (tức là 1, 2, 3).

Quy tắc thử thách:

• Đầu vào sẽ là một mảng / chuỗi đơn đại diện cho một mảng. Vì vậy, bạn không thể có một mảng các mảng để đơn giản hóa nó. Bạn cũng không thể có vật phẩm thay thế cho thẻ không tham gia chiến tranh.
• Chúng tôi sử dụng ký hiệu số cho thẻ mặt thay vì ký hiệu chữ cái. Vậy Ace / Joker = 1; Jack = 11; Nữ hoàng = 12; và vua = 13.
• Trong thử thách này, chúng tôi có thể cho rằng chúng tôi luôn chơi với 3 người chơi .
• Ba phần đầu chỉ ra sự bắt đầu của 'trận chiến'. Khi hai hoặc nhiều người chơi có 'chiến tranh', các thẻ tiếp tục trong mảng biểu thị trận chiến của họ (xem các trường hợp thử nghiệm để hiểu rõ hơn về điều này).

Quy tắc chung:

• Đây được gắn thẻ code-golf , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Điều này không có nghĩa là các ngôn ngữ không chơi mã không nên nhập. Cố gắng đưa ra một câu trả lời golf-code càng ngắn càng tốt cho ngôn ngữ lập trình 'mọi'.
• Vui lòng đề cập đến việc lập chỉ mục (không hoặc chỉ mục một) mà bạn đã sử dụng cho đầu ra.

Các trường hợp thử nghiệm:

Test case 1:  [4, 8, 11]                 ->  2 (or 3)
Test case 2:  [7, 1, 12]                 ->  1 (or 2)
Test case 3:  [10, 10, 13]               ->  2 (or 3)
Test case 4:  [3, 1, 2]                  ->  0 (or 1)
Test case 5:  [1, 1, 2]                  ->  2 (or 3)
Test case 6:  [3, 12, 1]                 ->  0 (or 1)
Test case 7:  [12, 12, 9, 4, 8]          ->  1 (or 2)
Test case 8:  [4, 4, 4, 8, 1, 2]         ->  2 (or 3)
Test case 9:  [11, 5, 11, 5, 5, 10, 13]  ->  2 (or 3)
Test case 10: [1, 1, 1, 9, 7, 9, 11, 3]  ->  0 (or 1)
Test case 11: [13, 13, 4, 1, 3]          ->  1 (or 2)
Test case 12: [13, 4, 13, 2, 3]          ->  2 (or 3)

q - 142 ký tự

{p:til 3;while[1<(#:)p;h:(n:(#:)p)#x;x:n _x;$[1~min h;p:$[max a:h in(2;3);$[1<(#:)(?:)h(&:)a;p(&:)h=3;p(&:)a];p(&:)h=1];p:p(&:)h=max h]];(*:)p}

Lưu ý: không có chỉ mục.

Không có khái niệm đọc stdin trong q, vì vậy bạn nên gọi nó là một hàm: {p:til 3;while[1<(#:)p;h:(n:(#:)p)#x;x:n _x;$[1~min h;p:$[max a:h in(2;3);$[1<(#:)(?:)h(&:)a;p(&:)h=3;p(&:)a];p(&:)h=1];p:p(&:)h=max h]];(*:)p}[1,2,3]

Khá dài, thực sự, nhưng có rất nhiều trường hợp góc. Nó giữ một danh sách những người chơi tích cực và tiêu thụ danh sách các thẻ trong một vòng lặp. Vấn đề nhất là phát hiện người chiến thắng chính xác trong tay như thế nào [13, 2, 3], vì 3nhịp đập 2, như bình thường, nhưng nó phải được nhân đôi để được đưa vào trường hợp góc.

JavaScript (ES6), 146 byte

f=a=>(b=a.splice(0,3)).filter(m=>m-n,n=Math.max(...b.includes(1)?b.filter(m=>m<4):b)).length>1?b.indexOf(n):f([...b.map(m=>m-n?0:a.shift()),...a])

Trả về một chỉ số dựa trên không. 127 byte nếu tôi cho phép giao dịch ban đầu là một mảng riêng biệt (điều này cũng hoạt động với số lượng tay tùy ý):

f=(b,a)=>b.filter(m=>m==n,n=Math.max(...b.includes(1)?b.filter(m=>m<4):b)).length<2?b.indexOf(n):f(b.map(m=>m-n?0:a.shift()),a)

Java 8, 257 byte

int c(int[]a){int t=0,f=0,q,r=0,i=-1,l=a.length,x[];for(;++i<3;t=a[i]>t?a[r=i]:t)a[i]+=a[i]==1?f++*0+13:0;for(;i-->0;t=f>0&a[i]<4?t!=3?a[r=i]:t>a[i]?a[r=i]:t:t);for(f=-1,x=new int[q=l<7?3:l>7?l-3:5];l>3&++i<q;)x[i]=t==a[i]|i>2?a[++f+3]:0;return l>3?c(x):r;}

Ok, thử thách của tôi khó hơn tôi nghĩ nó sẽ xảy ra với mọi thứ trong một mảng như thế. ;) Nhưng vì nó đã hơn tôi năm trước kể từ khi tôi đăng thử thách này, tôi quyết định tự mình thực hiện. Đã làm tôi mất khá nhiều thời gian với nhiều công việc và quirks .. Vì vậy, nó chắc chắn có thể được đánh gôn thêm, nhưng tôi sẽ xem xét điều đó vào lúc khác. Điều này đã diễn ra lâu hơn tôi mong đợi ..

Giải trình:

Hãy thử nó ở đây.

int c(int[]a){      // Method with integer-array parameter and integer return-type
  int t=0,f=0,q,    //  Temp integers
      r=0,          //  Result-integer
      i=-1,         //  Index-integer
      l=a.length,   //  Length of the input-array
      x[];          //  Temp array we use when there is a war
  for(;++i<3;       //  Loop (1) from 0 to 3 (exclusive)
      t=            //    After every iteration, change `t` to:
        a[i]>t?     //     If the current item is larger than `t`:
         a[r=i]     //      Use the current item (and save its index in `r`)
        :           //     Else:
         t)         //      Leave `t` the same
    a[i]+=a[i]==1?  //   If the current item is a 1 (Ace/Joker):
         f++*0      //    Increase `f` by 1,
         +13        //    and change the 1 to 14 (by increasing with 13)
        :           //   Else:
         0;         //    Leave the current item the same (by increasing with 0)
                    //  End of loop (1) (implicit / single-line body)
  for(;i-->0;       //  Loop from 2 down to 0 (inclusive)
    t=f>0&a[i]<4?   //   If a Joker/Ace was present, and the current item is 2 or 3:
       t!=3?        //    And if it's not a 3 (so either 2 or 14)
        a[r=i]      //     Change `t` to the current item (and save its index in `r`)
       :t>a[i]?     //    Else-if the current item is 2, and `t` is a Joker/Ace:
        a[r=i]      //     Change `t` to the current item (and save its index in `r`
       :            //    Else:
        t           //     Leave `t` the same
      :             //   Else:
       t            //    Leave `t` the same
  );                //  End of loop (2)
  for(f=-1,         //  Reset `f` to -1
      x=new int[    //  Create the temp array `x` with length:
       q=l<7?       //   If the current length is 6 or lower:
          3         //    New length after war is 3
         :l>7?      //   Else-if the current length is 8 or higher:
          l-3       //    New length after war is current length - 3
         :          //   Else(-if current length is 7)
          5];       //    New length after war is 5
      l>3&          //  If there is a war:
          ++i<q;)   //   Loop (3) from 0 to the new length (exclusive)
    x[i]=t==a[i]    //    If the current item is at war,
         |i>2?      //    or the current item is after the first 3 items:
          a[++f+3]  //     Fill the new array with the correct next item
         :          //    Else:
          0;        //     Fill the item of the new array with 0
                    //     (since it won't participate in the next round)
                    //   End of loop (3)
  return l>3?       //  If there was a war:
          c(x)      //   Recursive-call with the new array
         :          //  Else:
          r;        //   Return the index of the card that won
}                   // End of method