Na imprezie zapoznałem się z grą LCR. Teraz nie jest to świetna gra, ponieważ nie ma umiejętności, a jedynie losowa szansa. Ale przyszło mi do głowy, że mogę to kodować i stworzyłem szybki program w R do modelowania gry.

Zasady gry zmodyfikowane z Wikipedii, aby pasowały do ​​naszego sposobu gry:

Każdy gracz otrzymuje co najmniej 3 żetony. Gracze po kolei rzucają trzema sześciokątnymi kostkami, z których każda jest oznaczona „L”, „C”, „R” po jednej stronie i pojedynczą kropką po trzech pozostałych stronach. Za każde rzucone „L” lub „R” gracz musi przekazać jeden żeton graczowi odpowiednio po lewej lub prawej stronie. „C” oznacza żeton do środka (puli). Kropka nie ma wpływu.

Jeśli graczowi pozostało mniej niż trzy żetony, nadal jest w grze, ale ich liczba żetonów to liczba kości, które rzucają w swojej turze, zamiast rzucić wszystkimi trzema. Kiedy gracz ma zero żetonów, przekazuje kości w swojej turze, ale może otrzymywać żetony od innych i odpowiednio wykonywać następną turę. Zwycięzca jest ostatnim graczem, który umieścił żetony na środku.

Konkurs: napisz program w wybranym języku, który pobiera dane dotyczące liczby graczy i liczby początkowych żetonów i symuluje grę LCR, pokazując stan gry po wyrzuceniu każdego gracza.

Na przykład gra może być wyświetlana jako:

[[[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

Wynik nie musi wyglądać dokładnie tak, ale powinno być łatwo rozpoznać rzut kości, ile żetonów ma każdy gracz i ile żetonów ma środek na każdą turę.

To kod golfowy, więc wygrywa najkrótszy kod.

Emacs Lisp , 279 bajtów

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

Użyj tej funkcji jako (f 4 3).

Wersja lepiej czytelna:

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

Przykład wyjściowy:

(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 bajtów

Wersja, która wyświetla ten sam stan, gdy gracz ma 0 żetonów:

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

Zaczyna się od trzeciego gracza w szeregu.

Wypróbuj online.

Wersja, która pomija graczy, gdy pozostało 0 żetonów (274 bajty):

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

Zaczyna się od pierwszego gracza w szeregu.

Wypróbuj online.

-7 bajtów dzięki @ OlivierGrégoire .

Objaśnienie (drugiej wersji):

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 bajtów

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

Wypróbuj online!

Drukuje żetony wszystkich graczy po każdym rzucie

Galaretka , 39 bajtów

<sup>+2, aby naprawić zachowanie powtarzania ( ¡musi być poprzedzone przez nilad, więc «3Ḣ$-> ⁸FḢ«3)

Jeśli możemy zdefiniować listy wyników, które mają zostać obrócone, aby żetony należały do ​​gracza, który działał wcześniej po lewej, możemy wyeliminować skrajnie prawą 6 bajtów na 33 bajty (jednak moim zdaniem przeczytanie tego jest nieco niewygodne).</sup>

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

Dyadyczny link akceptujący żetony na gracza po lewej stronie i liczbę graczy po prawej stronie, który daje listę liczby żetonów graczy na początku gry i po każdej turze (w tym turach, w których 0 żetonów wymusza podanie) .

Wypróbuj online!

W jaki sposób?

Każdy gracz kolejno, do trzech razy, w zależności od liczby żetonów, rzuca monetą. Kiedy gracz odwraca głowy, nie robi nic, ale jeśli odwraca ogony, rzuca trójstronną kostką tracąc żeton do L, C lub R. (Zauważ, że 0 rzutów, gdy gracz ma 0 żetonów, odpowiada przepuszczeniu.)
To się powtarza dopóki suma żetonów graczy nie wyniesie 0.
Implementacja obraca graczy pozostawionych o jedno miejsce w każdej turze, a następnie obraca powstałe stany z powrotem, tak aby wszystkie były wyrównane, jakby nie były.

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

Wymaga using System;łącznie +13 bajtów do kodu pokazanego poniżej, jeśli muszę to policzyć. W przeciwnym razie po prostu połóż go w dowolnej klasie i zadzwoń 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;}

Przykładowe dane wyjściowe dla gry 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

Wersja mniej golfowa:

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 # (interaktywny kompilator Visual C #) , 201 199 bajtów

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

Wypróbuj online!

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

Węgiel drzewny , 61 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Na przemian wyrzucanie rzutów kostką i pozostałych żetonów (ani wyjściowa liczba żetonów, ani liczba żetonów na środku nie są uwzględniane na wyjściu). Wyjaśnienie:

≔⁰η

Zacznij od pierwszego gracza.

ＷΣθ«

Powtarzaj, aż nikt nie pozostanie żetonom.

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

Rzuć do trzech kości dla bieżącego gracza. Te kości są oznaczone jako 0-5, gdzie 0-2 oznacza kropkę, 3 oznacza przejście w lewo, 4 oznacza środek, 5 oznacza prawo.

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

Dodaj liczbę żetonów, które gracz po prawej stronie przekazał w lewo i liczbę żetonów, którą gracz po lewej stronie przekazał w prawo, ale odejmij liczbę żetonów, którą sam gracz przekazał.

≔﹪⊕ηＬθη

Przejdź do następnego gracza.

⟦⪫θ,

Wyjście nowej liczby żetonów posiadanych przez graczy.

W rzeczywistości wszystkim jest łatwiej rzucić kostką jednocześnie, co można zrobić w 50 bajtach, w tym wydrukować rzuty kostką, a także pozostałe żetony:

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

Wypróbuj online! Link jest do pełnej wersji kodu.

05AB1E (starsza wersja) , 58 50 49 52 bajtów

Wersja, która wyświetla ten sam stan, gdy gracz ma 0 żetonów ( 50 49 52 bajtów ):

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

Wypróbuj online.

Wersja, która pomija graczy, gdy pozostało 0 żetonów ( 58 57 60 bajtów ):

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

Wypróbuj online.

Oba +3 bajty przy użyciu starszej wersji, ponieważ nowa wersja 05AB1E ma dziwny błąd. Powinien działać z Ws\(push minimum bez popping; swap; lista odrzuconych) zastąpiony ß(pop list i push minimum) i 0›(sprawdź, czy jest większy niż 0) zastąpiony przez d(sprawdź, czy nie jest ujemny / większy niż lub równy 0) w nowa wersja, ale z jakiegoś powodu kolejność listy zmienia się po zakończeniu ¼!! : S (nowa wersja jest również bardzo wolna i kończy się po 60 sekundach przed ukończeniem wyniku ..>.>)

Pierwszy wkład to ilość graczy, drugi wkład to ilość żetonów na gracza.

Objaśnienie (drugiej wersji):

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