파티에서 나는 게임 LCR을 소개 받았다. 이제는 기술이없고 무작위 기회 만 있기 때문에 훌륭한 게임이 아닙니다. 그러나 나는 이것을 코딩 할 수 있었고 R을 게임을 모델링하기 위해 빠른 프로그램을 만들었습니다.

게임 방식에 맞게 Wikipedia에서 수정 된 게임 규칙 :

각 플레이어는 최소 3 개의 칩을받습니다. 플레이어는 차례로 6면 주사위 3 개를 굴립니다. 각 주사위에는 한쪽에 "L", "C", "R"이 표시되고 나머지 3 개의쪽에 하나의 점이 표시됩니다. 던져진 각각의 "L"또는 "R"에 대해, 플레이어는 각각 하나의 칩을 왼쪽 또는 오른쪽으로 플레이어에게 전달해야합니다. "C"는 칩이 중앙 (포트)에 있음을 나타냅니다. 점은 효과가 없습니다.

만약 플레이어가 남은 칩이 3 개 미만이면 여전히 게임에 있지만 칩의 수는 3 개를 모두 굴리는 것이 아니라 자신의 차례에 굴리는 주사위의 수입니다. 플레이어가 칩이없는 경우, 턴에 주사위를 통과하지만 다른 사람으로부터 칩을 받아 다음 턴을 할 수 있습니다. 승자는 칩을 중앙에 놓은 마지막 플레이어입니다.

컨테스트 : 선택한 언어로 플레이어 수와 시작 칩 수를 입력하고 LCR 게임을 시뮬레이트하여 각 플레이어가 굴린 후 게임 상태를 보여주는 프로그램을 작성하십시오.

예를 들어 게임은 다음과 같이 출력 될 수 있습니다.

[[[3,3,3,3],0],[[1,4,3,4],0],[[1,4,3,4],0],[[1,4,1,4],2],[[1,4,1,2],4],
[[0,4,1,3],4],[[0,3,2,3],4],[[0,3,0,3],6],[[0,3,1,1],7],[[0,3,1,1],7],
[[2,0,1,1],8],[[2,0,0,1],9],[[2,0,0,0],10],[[0,1,0,0],11],
[[1,0,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[0,0,0,0],12]]

ht : JonathanAllan

결과는 정확히 이와 같을 필요는 없지만 주사위 굴림, 각 플레이어의 칩 수 및 각 턴마다 센터의 칩 수를 쉽게 식별 할 수 있어야합니다.

코드 골프이므로 가장 짧은 코드가 승리합니다.

이맥스 리스프 , 279 바이트

(defmacro n(i)`(incf(nth ,i c)))
(defun f(p s)(g(let((a'(0)))(dotimes(i p)(push s a))(princ a))0 p))
(defun g(c v p)(dotimes(i(min(nth v c)3))(decf(nth v c))(case(random 6)(0(n(mod(1- v)p)))(1(n(mod(1+ v)p)))(2(n p))(t(n v))))(princ c)(or(eq(-sum c)(nth p c))(g c(mod(1+ v)p)p)))

이 기능을로 사용하십시오 (f 4 3).

더 읽기 쉬운 버전 :

(defmacro n (i) `(incf (nth ,i c)))

(defun f(p s)
  (g
   (let ((a '(0)))
     (dotimes (i p)
       (push s a))
     (princ a))
   0
   p))

(defun g (c v p)
  (dotimes (i (min (nth v c) 3))
    (decf (nth v c))
    (case (random 6)
      (0 (n (mod (1- v) p)))
      (1 (n (mod (1+ v) p)))
      (2 (n p))
      (t (n v))))
    (princ c)
    (or (eq (-sum c) (nth p c))
    (g c (mod (1+ v) p) p)))

출력 예 :

(3 3 3 3 0)(1 4 3 4 0)(2 2 4 4 0)(2 2 2 5 1)(4 2 2 3 1)(2 2 2 4 2)(2 1 3 4 2)(2 2 0 4 4)(2 2 0 4 4)(1 2 0 4 5)(2 1 0 4 5)(2 1 0 4 5)(2 1 1 3 5)(0 1 1 3 7)(1 0 1 3 7)(1 0 1 3 7)(1 0 3 1 7)(1 0 3 1 7)(1 0 3 1 7)(1 1 2 1 7)(1 1 3 0 7)(0 1 3 0 8)(1 0 3 0 8)(1 1 1 1 8)(1 1 2 0 8)(0 1 2 1 8)(0 1 2 1 8)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 0 10)(0 1 1 0 10)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 0 0 12)

자바 8, 281 277 275 274 253 바이트

턴 플레이어에 칩이 0 개있을 때 동일한 상태를 출력하는 버전 :

p->n->{java.util.Arrays A=null;int c[]=new int[p],i=0,t,r,s=1,u,f=9;for(A.fill(c,n);s>0;f=0,System.out.print(A.toString(c)))for(t=c[++i%p],t=t>3?3:t;t-->f;r*=Math.random(),c[i%p]-=1-r/3,s=c[u=(i+r-1+p)%p]+=1-r&1-r/4,c[u]=s<0?0:s,s=A.stream(c).sum())r=6;}

배열에서 세 번째 플레이어로 시작합니다.

온라인으로 사용해보십시오.

칩이 0 인 플레이어를 건너 뛰는 버전 (274 바이트) :

p->n->{java.util.Arrays A=null;int c[]=new int[p],i=p,t,r,s=1,u,f=9;for(A.fill(c,n);s>0;f=0,System.out.print(A.toString(c))){for(t=c[i%p],t=t>3?3:t;t-->f;r*=Math.random(),c[i%p]-=1-r/3,s=c[u=(i+r-1+p)%p]+=1-r&1-r/4,c[u]=s<0?0:s)r=6;for(s=A.stream(c).sum();s>0&c[++i%p]<1;);}}

배열의 첫 번째 플레이어에서 시작합니다.

온라인으로 사용해보십시오.

@ OlivierGrégoire 덕분에 -7 바이트 .

설명 (두 번째 버전) :

p->n->{                      // Method with two integer parameters and no return-type
  java.util.Arrays A=null;   //  Create a static Arrays-object to save bytes
  int c[]=new int[p],        //  Integer-array with chips of each player (0 by default)
      i=p,                   //  Index integer, starting at the amount of players
      t,                     //  Temp integer to roll 3 dice
      r,                     //  Temp integer for the dice-result
      s=1,u,                 //  Temp integers (and `s` is also the total-sum integer)
      f=9;                   //  Flag integer, starting at a single digit above 3
  for(A.fill(c,n);           //  Give each player in the array the chips
      s>0                    //  Loop as long as the total-sum is not 0 yet
      ;                      //    After every iteration:
       f=0,                  //     Set the flag to 0
       System.out.print(A.toString(c))){
                             //     Print the current state
    for(t=c[i%p],            //   Set `t` to the current player's chips
        t=t>3?3:t;           //   If this is larger than 3: set it to 3 instead
        t-->f                //   Loop that many times (1, 2, or 3)
                             //   (the flag is used to skip this loop the first iteration,
                             //   so we can print the initial state)
        ;                    //     After every iteration:
         r*=Math.random(),   //      Roll the dice in the range [0,5]
         c[i%p]-=r<3?        //      If the dice-roll is 0, 1 or 2:
                  1          //       Remove a chip from this player
                 :0,         //      Else: Leave the chip-amount the same
         s=c[u=(i+r-1+p)%p]  //      If the dice-roll is 0, go to the player left
                             //      If the dice-roll is 2, go to the player right
             +=1-r&1-r/4,    //       And add a chip to this player
         c[u]=s<0?0:s)       //      Change negative amount of chips to 0
      r=6;                   //    Reset the dice-roll to 6 so we can roll again
    for(s=A.stream(c).sum(); //   Calculate the total sum of the chips of the players
        s>0&                 //   If this sum is larger than 0:
         c[++i%p]<1;);}}     //    Determine the next player in line with at least 1 chip

파이썬 2 , 159 148 바이트

from random import*
n,c=input()
g=[c]*n;i=0
while sum(g):exec"r=randrange(6);g[i]-=1;g[i-[0,1,~-n][max(0,r-3)]]+=r>0;"*min(3,g[i]);i=(i+1)%n;print g

온라인으로 사용해보십시오!

롤마다 모든 플레이어 칩을 인쇄합니다

젤리 , 39 바이트

<sup>반복 동작을 수정하기 위해 +2 ( ¡앞에 nilad가 있어야 함 «3Ḣ$-> ⁸FḢ«3)

출력 목록을 회전하여 이전에 왼쪽에서 행동했던 플레이어의 칩이 회전하도록 정의하면 가장 오른쪽으로 멀리 할 수 ​​있습니다 33 바이트에 대해 6 바이트 (그러나 내 의견으로는 그것을 읽는 것이 다소 어색합니다).</sup>

ẋµ’1¦‘.,2ŻX¤¦$¹Ø.X¤?⁸FḢ«3¤¡ṙ1µSпṙ"JC$$

왼쪽에 플레이어 당 칩 수와 오른쪽에 플레이어 당 칩 수를 수용하는 Dyadic Link는 게임 시작과 매 턴마다 플레이어 칩 수를 표시합니다 (0 칩이 패스하는 턴 포함) .

온라인으로 사용해보십시오!

어떻게?

각 플레이어는 칩 수에 따라 최대 3 번씩 동전을 뒤집습니다. 플레이어가 머리를 뒤집 으면 아무것도하지 않지만 꼬리를 뒤집 으면 3 면체 주사위를 굴려 칩을 L, C 또는 R로 잃습니다. (플레이어가 칩이 0이면 0이 넘습니다.)
이것은 반복됩니다. 플레이어 칩의 합이 0
이 될 때까지 구현은 플레이어를 1 턴씩 왼쪽으로 회전시킨 다음 결과 상태를 다시 회전하지 않은 것처럼 정렬합니다.

ẋµ’1¦‘.,2ŻX¤¦$¹Ø.X¤?⁸«3Ḣ¤¡ṙ1µSпṙ"JC$$ - Link: chipsPerPlayer, C; numberOfPlayers, P
ẋ                                      - repeat C P times (making a list of P Cs)
                              п       - collect up results in a list while...
                             S         - ...п condition: sum (while players have chips)
 µ                          µ          - ...п do: the monadic chain:
                         ¡             -   repeat...
                        ¤              -   ...¡ number of times: nilad and link(s) as a nilad:
                    ⁸                  -     chain's left argument (the chip list)
                     «3                -     minimum with three (vectorises)
                       Ḣ               -     head -- i.e. min(left-most player's chips, 3)
                   ?                   -   ...¡ action: if...
                  ¤                    -     ...? clause: nilad and link(s) as a nilad:
               Ø.                      -       the list [0,1]
                 X                     -       random choice (0 is falsey while 1 is truthy)
             $                         -     ...? then: last two links as a monad:
    ¦                                  -       sparsely apply...
   1                                   -       ...¦ to indices: one (the left-most)
  ’                                    -       ...¦ action: decrement (player lost a chip)
            ¦                          -       sparsely apply...
           ¤                           -       ...¦ to indices: nilad and link(s) as a nilad:
      .,2                              -         literal pair of literals .5 and two = [.5,2]
         Ż                             -         prepend a zero = [0,0.5,2]
          X                            -         random choice
                                       -         -- Note application to index .5 is a no-op
                                       -                 index 0 is the right-most entry (L) 
                                       -                 index 2 is the second entry (R) 
                          ṙ1           -   rotate the list left by one for the next п loop
                                     $ - last two links as a monad:
                                    $  -   last two links as a monad:
                                  J    -     range of length -- i.e. [1,2,3,...,turns+1]
                                   C   -     complement = 1-x        [0,-1,-2,...,-turns]
                                 "     -   zipped-appliction of:
                                ṙ      -     rotate left by
                                       -   -- i.e. rotate 1st left by 0, 2nd left by -1, ...)

C #, 356? +13? 바이트

필요 using System;나는 그것을 계산하는 데 필요한있어 경우 코드 13 바이트의 총, 다음과 같이하십시오. 그렇지 않으면 모든 클래스에서 plonk하고 호출하십시오 L(players, starting chips);.

static int i,j,k,l;public static void L(int p,int s){var r=new Random();var x=new int[p];for(i=0;i<p;i++)x[i]=s;
for(i=0;i<s*p;){for(j=0;j<p;j++){for(l=0;l<x[j]&l<3;l++){k=r.Next(-1,5);if(k<2){if(k==0){x[j]--;i++;}else{x[(p+j+k)%p]++;x[j]--;}}}Console.Write(a(x)+i);}}}public static string a(int[] x){var n="|";for(l=0;l<x.Length;)n+=x[l++]+" ";
return n;}

2,2 게임의 샘플 출력 :

|1 3 0|2 2 0|1 3 0|1 3 0|0 4 0|0 3 1|0 3 1|2 1 1|1 2 1|1 2 1|0 3 1|0 3 1|0 3 1|1 1 2|1 1 2|1 1 2|0 2 2|1 1 2|0 1 3|1 0 3|0 1 3|0 1 3|0 1 3|1 0 3|1 0 3|1 0 3|0 1 3|1 0 3|0 1 3|0 0 4

덜 골프 버전 :

using System;
//class omitted.
static int i,j,k,l;
public static void LCR(int pl, int sc){
var r=new Random();
var state = new int[pl];
for(i=0;i<pl;i++)state[i]=sc;
for(i=0;i<sc*pl;){
    for(j=0;j<pl;j++){
        for(l=0;l<state[j] && l<3;l++){
            k=r.Next(-1,5);
            if(k<2){
                if(k==0){state[j]--;i++;}else{state[(pl+j+k)%pl]++;state[j]--;}
            }
        }
        Console.Write(a(state)+i);
    }
}
}
public static string a(int[] x){
    var n="|";
    for(l=0;l<x.Length;)n+=x[l++]+" ";
    return n;
}

C # (Visual C # 대화식 컴파일러) , 201 199 바이트

n=>m=>{var r=new Random();var j=Enumerable.Repeat(n,m).ToList();for(int i=0;j.Any(c=>c>0);i++,Print(j))for(int k=0,x=r.Next(6);k++<Math.Min(j[i%m],3);j[((x<1?-1:1)+i+m)%m]+=x<2?1:0,j[i%m]-=x<3?1:0);}

온라인으로 사용해보십시오!

startingChips=>playerNum=>{
//Instantiate a new random number generator
var rng = new Random();
//Create a list of chips
var players = Enumerable.Repeat(startingChips, playerNum ).ToList();
//Loop as long any player still has chips
for(int turnNum = 0;players.Any(c=>c>0);
//And print the result every iteration
i++,Print(j))
//Get a random number within the range of 0-5 and loop for...
for(int k = 0,randomNum = rng.Next(6);
//either 3 or the amount of chips we have, whichever is smaller
k++<Math.Min(players[turnNum % playerNum ],3);
//Increment either the right player if the random number is 1, else increment the right player if it is 0
players[((randomNum<1?-1:1)+ turnNum + playerNum ) % playerNum ]+=x<2?1:0,
//Decrement current player if the die roll is under 3
players[ turnNum % playerNum ]-=x<3?1:0);}

숯 , 61 바이트

≔⁰ηＷΣθ«≔Ｅθ⭆⌊⟦κ׳⁼λη⟧‽⁶ιＵＭθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5ＬΦ§ιλ›μ2≔﹪⊕ηＬθη⟦⪫θ,

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 주사위 롤과 남은 칩 출력 사이의 대안 (초기 칩 수나 중앙 칩 수는 출력에 포함되지 않음). 설명:

≔⁰η

첫 번째 플레이어부터 시작하십시오.

ＷΣθ«

남은 칩이 없을 때까지 반복하십시오.

≔Ｅθ⭆⌊⟦κ׳⁼λη⟧‽⁶ι

현재 플레이어의 주사위를 3 개까지 굴립니다. 이 주사위는 0-5로 표시되며, 0-2는 점을 나타내고, 3은 왼쪽으로, 4는 가운데, 5는 오른쪽입니다.

ＵＭθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5ＬΦ§ιλ›μ2

오른쪽에있는 플레이어가 왼쪽으로 통과 한 칩 수와 왼쪽에있는 플레이어가 오른쪽을 통과 한 칩 수를 더하지만 플레이어가 전달한 칩 수는 빼십시오.

≔﹪⊕ηＬθη

다음 선수에게 전진하십시오.

⟦⪫θ,

플레이어가 보유한 새로운 칩 수를 출력합니다.

모든 사람이 주사위를 동시에 굴리는 것이 더 간단합니다. 주사위 롤과 남은 칩 인쇄를 포함하여 50 바이트로 수행 할 수 있습니다.

ＷΣθ«≔Ｅθ⭆⌊⟦κ³⟧‽⁶ιＵＭθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5ＬΦ§ιλ›μ2⟦⪫ι,⪫θ,

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

05AB1E (레거시) , 58 50 49 52 바이트

턴 플레이어에 칩이 0 개 남았을 때 ( 50 49 52 바이트 ) 동일한 상태를 출력하는 버전 :

и[=ÐO_#¾è3‚Ws\F5ÝΩ©3‹iε¾¹%NQ-}®≠iε®<¾+¹%NQ+}}}}D0›*¼

온라인으로 사용해보십시오.

칩이 0 인 플레이어를 건너 뛰는 버전 ( 58 57 60 바이트 ) :

и[=DO_#[D¾èDĀ#\¼}3‚Ws\F5ÝΩ©3‹iε¾¹%NQ-}®≠iε®<¾+¹%NQ+}}}}D0›*¼

온라인으로 사용해보십시오.

새로운 05AB1E 버전에는 이상한 버그가 있기 때문에 레거시 버전을 사용하여 +3 바이트 모두. 이 작동한다 Ws\(; 스왑; 펑없이 푸시 최소 폐기리스트)로 대체 ß(POP에서 푸시 최소) 및 0›교체 (0보다 큰 경우에 선택) d(0이보다 더 많이 또는 체크 음수 / IF)에있는 새 버전이지만 어떤 이유로 든 목록 순서는 후행 ¼! .. : S 후에 변경됩니다 (그리고 새 버전도 매우 느리고 60 초 후에 결과가 완료되기 전에 시간이 초과됩니다 ..>.>)

첫 번째 입력은 플레이어의 양이고, 두 번째 입력은 플레이어 당 칩의 양입니다.

설명 (두 번째 버전) :

и                    # Create a list with a size of the (first) implicit input,
                     # filled with the second (implicit) input
[                    # Start an infinite loop:
 =                   #  Print the list with trailing newline, without popping the list
 DO_#                #  If the total amount of chips is 0: stop the infinite loop
 [                   #  Start an inner infinite loop:
  D¾è                #   Get the chips of the I'th player (I is 0 by default)
     D               #   Duplicate this
      Ā#             #   If it is NOT 0: stop the inner infinite loop
        \            #   Remove the duplicated chips for the next iteration
         ¼           #   And increase I by 1
 }                   #  After the inner infinite loop:
 3‚Ws\               #  If the amount of chips is larger than 3: use 3 instead
      F              #  Loop that many times:
       5ÝΩ           #   Roll a random dice in the range [0,5]
       ©3‹i          #   If the dice-roll is 0, 1, or 2:
           ε¾¹%NQ-}  #    Remove a chip from the I'th player
           ®≠i       #    If the dice-roll is NOT 1:
              ε®<¾+  #     Go to the player left if 0; or right if 2
              ¹%NQ+} #     And increase that player's chips by 1
      }}}            #  Close both if-statements and the loop
         D0›*        #  Make any negative amount of chips 0
             ¼       #  Increase I by 1