네덜란드어로 'Oorlog'( 'War'로 번역)라는 이름으로 개인적으로 알고있는 카드 게임의 측면에 대한 시뮬레이션을 작성해 보겠습니다.

'Oorlog'는 어떻게 작동합니까?

2 개의 카드 덱 (각각 2 개의 조커 포함)은 플레이하는 플레이어 수에 따라 동일하게 나누어집니다. 각 플레이어는 자신의 주식을 섞고, 거꾸로 뒤집어 놓으며, 모든 플레이어는 주식의 첫 카드를 동시에 엽니 다.
그 '전투'의 승자는 다음 규칙에 따라 카드의 가치에 의해 결정됩니다. 조커 / 에이스가 패배합니다. 왕은 여왕을 물리 친다. 여왕은 잭을 물리 친다. 잭은 10을 패배시킨다; 10 패 9 .... 또한 2와 3 모두 Ace / Joker를 물리칩니다. 마지막 규칙은 2 또는 3이 Ace 또는 Joker를 이길 수 있으며, Ace 또는 Joker는 다른 카드를 이길 수 있으며, 다른 카드는 2 또는 3을 이깁니다.이 경우 2 또는 3이 전투에서 이깁니다.
(이 카드 게임에는 어울리지 않습니다.)

둘 이상의 플레이어가 같은 카드를 가지면 '전쟁'이됩니다. 즉, 한 장의 카드를 거꾸로 놓은 다음 각각이 자신의 카드에서 새 카드를 열어 누가 가장 높은 카드를 가지고 있는지 확인합니다. 이것은 한 명의 플레이어가 전체 전투에서 승리 할 때까지 계속됩니다.
(그 전투의 모든 카드는 전투에서 승리 한 플레이어의 버림 더미로갑니다. 그런 다음 모든 사람이 새 카드를 엽니 다. 플레이어의 카드가 부족하면 버리는 카드 더미를 뒤집어 놓고이 새로운 스톡을 계속합니다. 이것은 플레이어가 자신의 카드를 모두 사용하지 못하고 카드가 가장 많은 플레이어가 이길 때까지 계속됩니다.)

세 명의 플레이어와 함께 '전투'예 :

1. 4, 8, Jack :
   Jack이 이깁니다.
2. 7, 에이스, 퀸 :
   에이스 승.
3. 10, 10, King :
   King이 이깁니다.
4. 3, Joker, 2 :
   3 승.
5. 에이스, 조커, 2 :
   2 승리.
6. 3, 퀸, 에이스 :
   3 승.
7. Queen, Queen, 9 :
   Queen & Queen은 '전쟁'을 겪고 있습니다. 4, 8;
   8 승
8. 4, 4, 4 :
   모두 '전쟁'을 겪고 있으며, 3 장의 새로운 카드로 계속됩니다 : 8, Ace, 2;
   2 승
9. Jack, 5, Jack :
   Jack & Jack은 '전쟁'을 겪고 있으며, 두 개의 새로운 카드로 계속됩니다 : 5, 5;
   5와 5도 동일하므로 '전쟁'은 두 개의 새로운 카드로 다시 계속됩니다 : 10, King;
   왕이 이긴다.
10. 조커, 조커, 에이스 :
    모두 '전쟁'을 겪고 있으며, 3 장의 새로운 카드를 계속 사용합니다.
    9와 9도 동일하므로 '전쟁'은 두 개의 새로운 카드로 계속됩니다 : Jack, 3;
    잭이 이겼어

따라서 코드 도전에 :

입력:

배열이있는 STDIN 또는 배열을 시뮬레이션하는 문자열 (언어가 배열을 지원하더라도 호출). 이 배열에는 시간 순서대로 전투 카드가 들어 있습니다 (이에 대한 명확한 이해는 테스트 사례 참조).

산출:

STDOUT 전투에서이긴 플레이어의 색인.
인덱스가없는 (예 0: 1, 또는 2) 또는 인덱스가없는 출력 (예 1: 2, 3) 을 원하는지 선택할 수 있습니다 .

도전 규칙 :

• 입력은 배열을 나타내는 단일 배열 / 문자열입니다. 따라서 단순화하기 위해 배열 배열을 가질 수 없습니다. 또한 전쟁에 참여하지 않은 카드에 대한 대리 아이템을 가질 수 없습니다.
• 문자 표기법 대신 얼굴 카드에 숫자 표기법을 사용합니다. 에이스 / 조커 = 1; 잭 = 11; 여왕 = 12; 그리고 왕 = 13.
• 이 도전에서 우리는 항상 3 명의 플레이어 와 놀고 있다고 가정 할 수 있습니다 .
• 처음 3 개는 '전투'의 시작을 나타냅니다. 두 명 이상의 플레이어가 '전쟁'을했을 때, 계속 진행되는 카드는 전투를 나타냅니다 (이에 대한 명확한 이해는 테스트 사례 참조).

일반 규칙:

• 이것은 code-golf 태그가 붙어 있으므로 바이트 단위의 최단 답변이 이깁니다.
  이것은 코드 골프가 아닌 언어가 입력되어서는 안된다는 의미는 아닙니다. '모든'프로그래밍 언어에 대해 가능한 짧은 코드 골프 응답을 생각해보십시오.
• 출력에 사용한 색인 (0 또는 1 색인)을 언급하십시오.

테스트 사례 :

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}

참고 : 인덱스가 0입니다.

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정상으로,하지만 코너 케이스에 넣어하는 중복되어야했다.

자바 스크립트 (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])

0부터 시작하는 인덱스를 반환합니다. 초기 거래가 별도의 배열로 허용되면 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)

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

좋아, 내 도전은 내가 하나의 배열로 모든 것을 할 것이라고 생각했던 것보다 어렵다. ;) 그러나이 챌린지를 게시 한 지 1 년이 지난 지금, 나는 스스로 도전하기로 결정했습니다. 여러 가지 해결 방법과 단점으로 인해 꽤 오래 걸렸습니다. 그래서 확실히 더 골프를 칠 수는 있지만 나중에 다시 살펴 보겠습니다. 이것은 이미 예상보다 오래 걸렸습니다 ..

설명:

여기에서 시도하십시오.

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