模拟纸牌游戏“ Oorlog”中的“战斗”

让我们为纸牌游戏的一个方面构建一个模拟，我个人以荷兰语名字“ Oorlog”（译为“战争”）来知道。

“ Oorlog”如何工作？

两副纸牌（每张纸牌包括两个小丑）在玩的玩家数量之间平均分配。每个玩家随机洗牌，将其倒置在他们面前，然后所有玩家同时打开该股票的第一张牌。
“战斗”的获胜者由遵循以下规则的纸牌值决定：小丑/王牌击败金；国王击败女王；女王击败杰克；杰克击败10；10败9; ....此外，2和3都击败了Ace / Joker。最后一条规则可能会导致一个循环，其中2或3击败Ace或Joker，Ace或Joker击败某些其他牌，反过来又击败2或3。在这种情况下，2或3赢得战斗。
（在此纸牌游戏中，衣服是无关紧要的。）

当两个或两个以上的玩家拥有相等的最高卡牌时，他们就会有“战争”。这意味着他们将一张卡片倒置，然后每张卡片从库存中打开一张新卡片，再次寻找谁拥有最高的卡片。这一直持续到一个玩家赢得整个战斗为止。
（该战役的所有卡都移到赢得战斗的玩家的弃牌堆中。然后每个人都打开一张新牌。当玩家的存储卡用完时，他们将其弃牌堆倒置并继续使用此新股票。这一直持续到玩家的所有卡都用完，然后赢得最高卡数的玩家才获胜。）

具有三个玩家的“战斗”示例：

4、8，杰克：
杰克获胜。
7，王牌，女王：
王牌获胜。
10、10，国王：
国王获胜。
3，小丑，2：
3胜。
小丑王牌：
2 ：2获胜。
3，女王，王牌：
3胜。
皇后区，皇后区9：
皇后区和皇后区之间有一场“战争”，因此继续使用两张新牌：4、8；
8胜。
4、4、4：
所有人都有一场“战争”，所以它继续了三张新牌：8，王牌，2；
2胜。
Jack，5岁，Jack：
Jack和Jack发生了一场“战争”，因此它继续增加了两张新牌：5、5；
5和5也相等，因此“战争”再次以两张新牌继续：10，国王；
国王赢了。
小丑，小丑，王牌：
所有人都在打一场“战争”，所以它继续推出三张新牌：9、7、9；
9和9也相等，因此“战争”继续出现了两张新牌：杰克，3；
杰克赢了。

因此，面临代码挑战：

输入：

带数组的STDIN或模拟数组的字符串（您的调用-即使您的语言支持数组也是如此）。此阵列按时间顺序包含一场战斗的卡片（请参阅测试案例以更清楚地了解这一点）。

输出：

STDOUT赢得战斗的玩家的索引。
您可以选择是否要零索引（即0，1或2）或一个索引的输出（即1，2，3）。

挑战规则：

输入将是单个数组/代表数组的字符串。因此，您无法使用数组数组来简化它。对于不参与战争的卡，您也不能拥有替代物品。
我们使用数字符号代替字母符号。所以Ace / Joker = 1; 杰克= 11; 皇后= 12; 和King = 13。
在这个挑战中，我们可以假设我们一直在和3个玩家一起玩。
前三个表示“战斗”的开始。当两个或两个以上的玩家进行“战争”时，阵列中的连续纸牌会表明他们的战斗（请参阅测试案例以更清楚地了解此情况）。

通用规则：

这被标记为代码高尔夫，因此以字节为单位的最短答案将获胜。
这并不意味着不应该输入非编码语言。尝试针对“每种”编程语言提出尽可能短的代码高尔夫答案。
请提及您用于输出的索引（零索引或一索引）。

测试用例：

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)

code-golf game card-games

— 凯文·克鲁伊森
source

英文名称的确是War（减去笑话者和减去2和3拍的王牌规则）。

— Martin Ender

@MartinEnder也一样，当出现平局时，两个玩家将3张牌正面朝下翻转，将4张正面朝上。第四名决定了本轮的获胜者，而正面朝下的牌则是“战s”。另外，直到一名玩家拥有所有卡牌后，游戏才会继续吗？我不知道这是否是当地法规，其他人还记得吗？这就是我记得打球的方式。

— Magic Octopus Urn'Oct

@MagicOctopusUrn我记得翻过弃牌堆继续玩，直到一位玩家拥有了全部。

— 卡米尔·德拉卡里

@KamilDrakari是的！那也是我的演奏方式。我在路易斯安那州长大，玩过这种游戏。

— Magic Octopus Urn'Oct

@MagicOctopusUrn我的经验来自明尼苏达州，由于我们现在有2个数据点，我认为可以肯定地说整个美国都一样。

— 卡米尔·德拉卡里

Answers:

q-142个字符

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

注意：零索引。

没有在q中读取stdin的概念，因此您应该将其作为函数调用： {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]

实际上很长，但是有很多极端情况。它保留了活跃玩家的花名册，并循环使用卡牌列表。最成问题的是检测到正确的赢家手中一样[13, 2, 3]，因为3节拍2，如正常，但它必须被复制到被放到角落的情况。

— 奎里
source

JavaScript（ES6），146个字节

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

返回从零开始的索引。如果允许初始交易作为单独的数组，则为127个字节（当然，这也适用于任意数量的手）：

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)

— 尼尔
source

Java 8，257字节

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

好的，我的挑战比我想象的要困难得多，因为将所有东西放在一个这样的阵列中。;）但是，自从我发布此挑战以来已经比一年前多了，所以我决定亲自尝试一下。我花了相当长的时间解决了多个变通方法和怪癖。.因此，它肯定可以打更多的球，但是我会再研究一下。这已经花了比我预期更长的时间。

说明：

在这里尝试。

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

— 凯文·克鲁伊森
source