Trong một bữa tiệc, tôi được giới thiệu về trò chơi LCR. Bây giờ nó không phải là một trò chơi tuyệt vời vì không có kỹ năng mà chỉ có cơ hội ngẫu nhiên. Nhưng nó khiến tôi suy nghĩ, tôi có thể viết mã này và tôi đã tạo một chương trình nhanh trong R để mô hình hóa trò chơi.

Luật chơi được sửa đổi từ Wikipedia để phù hợp với cách chúng tôi chơi:

Mỗi người chơi nhận được ít nhất 3 chip. Người chơi lần lượt tung ba con xúc xắc sáu mặt, mỗi con được đánh dấu bằng "L", "C", "R" ở một bên và một dấu chấm duy nhất ở ba mặt còn lại. Đối với mỗi lần ném "L" hoặc "R", người chơi phải chuyển một chip cho người chơi sang trái hoặc phải tương ứng. "C" chỉ ra một con chip đến trung tâm (nồi). Một dấu chấm không có tác dụng.

Nếu một người chơi còn ít hơn ba chip, họ vẫn còn trong trò chơi nhưng số chip của họ là số xúc xắc họ tung ra trong lượt của mình, thay vì lăn cả ba. Khi người chơi không có chip, họ sẽ chuyển xúc xắc trong lượt của mình, nhưng có thể nhận chip từ người khác và lần lượt tiếp theo. Người chiến thắng là người chơi cuối cùng đưa chip vào trung tâm.

Cuộc thi: viết chương trình bằng ngôn ngữ bạn chọn, nhập số lượng người chơi và số chip bắt đầu và mô phỏng trò chơi LCR, hiển thị trạng thái của trò chơi sau khi mỗi người chơi đã lăn.

Ví dụ: một trò chơi có thể là đầu ra như:

[[[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: Jonathan Allan

Đầu ra không nhất thiết phải trông giống như thế này, nhưng sẽ dễ dàng nhận ra cuộn súc sắc, mỗi người chơi có bao nhiêu chip và trung tâm có bao nhiêu chip cho mỗi lượt.

Đó là mã golf nên mã ngắn nhất sẽ thắng.

Emacs Lisp , 279 byte

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

Sử dụng chức năng này như (f 4 3).

Phiên bản dễ đọc hơn:

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

Ví dụ đầu ra:

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

Java 8, 281 277 275 274 253 byte

Phiên bản xuất ra trạng thái tương tự khi trình phát lần lượt còn lại 0 chip:

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

Bắt đầu với người chơi thứ ba trong mảng.

Hãy thử trực tuyến.

Phiên bản bỏ qua người chơi với 0 chip còn lại (274 byte):

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

Bắt đầu ở trình phát đầu tiên trong mảng.

Hãy thử trực tuyến.

-7 byte nhờ @ OlivierGrégoire .

Giải thích (của phiên bản thứ hai):

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

Python 2 , 159 148 byte

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

Hãy thử trực tuyến!

In tất cả chip người chơi sau mỗi lần cuộn

Thạch , 39 byte

<sup>+2 để sửa hành vi lặp lại ( ¡phải được bắt đầu bằng nilad vì vậy «3Ḣ$-> ⁸FḢ«3)

Nếu chúng ta có thể xác định danh sách đầu ra sẽ được xoay để có các chip thuộc về người chơi hành động trước đó ở bên trái, chúng ta có thể loại bỏ phần lớn bên phải 6 byte cho 33 byte (tuy nhiên, theo tôi, hơi khó đọc khi đọc nó).</sup>

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

Liên kết dyadic chấp nhận chip cho mỗi người chơi ở bên trái và số người chơi ở bên phải, tạo ra một danh sách các chip người chơi được tính khi bắt đầu trò chơi và sau mỗi lượt (bao gồm cả lượt mà 0 chip buộc phải vượt qua) .

Hãy thử trực tuyến!

Làm sao?

Mỗi người chơi lần lượt, tối đa ba lần, tùy thuộc vào số lượng chip của họ, lật một đồng xu. Khi một cầu thủ flips đầu họ làm gì, nhưng nếu họ lật đuôi họ sau đó cuộn một ba chết mặt mất một con chip để L, C hoặc R. (Lưu ý rằng 0 flips khi một cầu thủ có 0 chip tương đương với đi qua.)
Này được lặp lại cho đến khi tổng số chip của người chơi bằng 0.
Việc thực hiện xoay người chơi ở một nơi mỗi lượt và sau đó xoay các trạng thái kết quả trở lại tất cả được căn chỉnh như thể họ không.

ẋµ’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? Byte

Yêu cầu using System;tổng cộng +13 byte cho mã được hiển thị bên dưới, nếu tôi bắt buộc phải tính điều đó. Nếu không, chỉ cần plonk nó trong bất kỳ lớp học và gọi 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;}

Đầu ra mẫu cho một trò chơi 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

Phiên bản ít chơi gôn hơn:

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 # (Trình biên dịch tương tác Visual C #) , 201 199 byte

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

Hãy thử trực tuyến!

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

Than , 61 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Thay thế giữa việc xuất các cuộn xúc xắc và chip còn lại (không phải số lượng chip ban đầu cũng như số lượng chip ở trung tâm được bao gồm trong đầu ra). Giải trình:

≔⁰η

Bắt đầu với người chơi đầu tiên.

ＷΣθ«

Lặp lại cho đến khi không còn ai còn chip.

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

Cuộn lên đến ba con xúc xắc cho người chơi hiện tại. Những con xúc xắc này được dán nhãn 0-5, trong đó 0-2 đại diện cho dấu chấm, 3 được chuyển sang trái, 4 là ở giữa, 5 là bên phải.

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

Thêm số chip mà người chơi bên phải đã vượt qua bên trái và số lượng chip mà người chơi bên trái đã vượt qua bên phải, nhưng trừ đi số lượng chip mà người chơi tự truyền vào.

≔﹪⊕ηＬθη

Tiến tới người chơi tiếp theo.

⟦⪫θ,

Xuất ra số lượng chip mới do người chơi nắm giữ.

Thực sự đơn giản hơn cho mọi người khi tung xúc xắc của họ đồng thời, có thể được thực hiện trong 50 byte, bao gồm in các cuộn súc sắc cũng như các chip còn lại:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

05AB1E (di sản) , 58 50 49 52 byte

Phiên bản xuất ra trạng thái tương tự khi trình phát lần lượt còn lại 0 chip ( 50 49 52 byte ):

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

Hãy thử trực tuyến.

Phiên bản bỏ qua người chơi với 0 chip còn lại ( 58 57 60 byte ):

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

Hãy thử trực tuyến.

Cả +3 byte bằng cách sử dụng phiên bản cũ, vì phiên bản 05AB1E mới có một lỗi lạ. Nó nên hoạt động với Ws\(đẩy tối thiểu mà không bật, hoán đổi; loại bỏ danh sách) thay thế bằng ß(danh sách bật và đẩy tối thiểu) và 0›(kiểm tra nếu lớn hơn 0) được thay thế bằng d(kiểm tra nếu không âm / lớn hơn hoặc bằng 0) trong phiên bản mới, nhưng vì một số lý do , thứ tự danh sách bị thay đổi sau khi theo dõi ¼! .. : S (và phiên bản mới cũng cực kỳ chậm và hết thời gian sau 60 giây trước khi kết thúc kết quả ..>.>)

Đầu vào đầu tiên là số lượng người chơi, đầu vào thứ hai số lượng chip trên mỗi người chơi.

Giải thích (của phiên bản thứ hai):

и                    # 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