Давайте побудуємо моделювання для аспекту в картковій грі, який я особисто знаю по голландській назві "Oorlog" (перекладається як "Війна").

Як працює «Орлог»?

Дві колоди карт (кожна з яких включає два Джокери) порівну поділяються між кількістю гравців. Кожен гравець перетасовує свій власний запас, кладе його догори дном, і всі гравці одночасно відкривають першу карту акції.
Переможець у цій "битві" визначається значеннями карт, що відповідають цим правилам: Джокер / Ейс перемагає Кінга; Король перемагає королеву; Королева перемагає Джека; Джек перемагає 10; 10 поразок 9; .... Крім того, і 2, і 3 поразка туза / Джокера. Останнє правило може призвести до циклу, коли 2 чи 3 удари туза чи Джокера, Ейс або Джокер б'є якусь іншу карту, яка, в свою чергу, перемагає 2 або 3. У цьому випадку 2 або 3 виграє битву.
(Костюм не має значення в цій картковій грі.)

Коли двоє або більше гравців мають однакові найвищі карти, їм належить "війна". Це означає, що вони кладуть одну карту догори дном, а потім кожна відкриває нову карту зі свого складу, знову дивлячись, хто має найвищу карту. Це триває, поки жоден гравець не виграє весь бій.
(Усі картки цього бою переходять до купи скинутих гравця, який виграв битву. Тоді кожен відкриває нову карту. Коли запас гравця не має карт, вони перевертають свою купу скинутих ногами і продовжують цей новий запас. Це триває, поки гравець не виграє всіх своїх карт, а потім виграє гравець з найбільшою кількістю карт.)

Приклад "битв" з трьома гравцями:

1. 4, 8, Джек:
   Джек виграє.
2. 7, туз, королева:
   туз перемагає.
3. 10, 10, Король:
   Король перемагає.
4. 3, Джокер, 2:
   3 перемоги.
5. Туз, Джокер, 2:
   2 перемоги.
6. 3, Королева, Туз:
   3 перемоги.
7. Королева, Королева, 9:
   Королева та Королева ведуть «війну», тому вона продовжується з двома новими картами: 4, 8;
   8 перемог.
8. 4, 4, 4:
   Усі мають "війну", тому триває три нові карти: 8, туз, 2;
   2 перемоги.
9. Джек, 5, Джек:
   Джек і Джек мають "війну", тому це триває з двома новими картами: 5, 5;
   5 і 5 також рівні, тому "війна" знову продовжується з двома новими картами: 10, король;
   Король перемагає.
10. Джокер, Джокер, Туз: У
    всіх "війна", тому триває три нові карти: 9, 7, 9;
    9 і 9 також рівні, тому "війна" триває з двома новими картами: Джек, 3;
    Джек виграє.

Отже, на виклик коду:

Вхід:

STDIN з масивом або рядок, що імітує масив (ваш дзвінок - навіть якщо ваша мова підтримує масиви). Цей масив містить карти битви в хронологічному порядку (див. Тестові випадки для більш чіткого розуміння цього).

Вихід:

ВИБІРТЕ індекс гравця, який виграв битву.
Ви можете вибрати , чи хочете ви нульовий індексуються (тобто 0, 1чи 2) або один-індексований вихід (тобто 1, 2,3 ).

Правила виклику:

• Вхід буде одним масивом / рядком, що представляє масив. Таким чином, ви не можете мати масив масивів, щоб спростити його. Ви також не можете мати сурогатні предмети для карток, які не беруть участі у війні.
• Ми використовуємо позначення чисел для лицьових карток замість позначення літер. Отже туз / Джокер = 1; Джек = 11; Королева = 12; і Кінг =13 .
• У цьому виклику можна вважати, що ми завжди граємо з трьома гравцями .
• Перші три вказують на початок «битви». Коли два або більше гравців мають "війну", карти, що продовжуються в масиві, вказують на їх бій (див. Тестові випадки для більш чіткого розуміння цього).

Загальні правила:

• Це позначений код-гольф , тому найкоротша відповідь у байтах виграє.
  Це не означає, що мови для гольфу, кодові не повинні вводитись. Спробуйте придумати якомога коротший відповідь на код-гольф для мови програмування "кожен".
• Будь ласка, зазначте, яку індексацію (нульову чи одноіндексовану) ви використовували для виводу.

Тестові приклади:

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 символи

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

Примітка: індексовано нуль.

Немає поняття читання stdin у q, тому слід називати це функцією: {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, як звичайне, але його треба було дублювати, щоб його покласти у кутовий корпус.

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)

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