Auf einer Party wurde ich in das Spiel LCR eingeführt. Jetzt ist es kein großartiges Spiel, da es keine Fertigkeiten gibt, sondern nur zufällige Chancen. Aber es brachte mich zum Nachdenken, ich könnte das codieren, und ich machte ein schnelles Programm in R, um das Spiel zu modellieren.

Die Spielregeln wurden von Wikipedia an unsere Spielweise angepasst:

Jeder Spieler erhält mindestens 3 Chips. Die Spieler würfeln abwechselnd drei sechsseitige Würfel, von denen jeder auf einer Seite mit "L", "C", "R" und auf den drei verbleibenden Seiten mit einem einzelnen Punkt markiert ist. Für jedes geworfene "L" oder "R" muss der Spieler einen Chip links oder rechts an den Spieler weitergeben. Ein "C" zeigt einen Chip in der Mitte (Topf) an. Ein Punkt hat keine Wirkung.

Wenn ein Spieler weniger als drei Chips übrig hat, ist er noch im Spiel, aber die Anzahl der Chips entspricht der Anzahl der Würfel, die er in seinem Zug würfelt, anstatt alle drei zu würfeln. Wenn ein Spieler keine Chips hat, gibt er die Würfel in seinem Zug weiter, kann aber Chips von anderen erhalten und den nächsten Zug entsprechend machen. Der Gewinner ist der letzte Spieler, der Chips in die Mitte legt.

Wettbewerb: Schreiben Sie ein Programm in der Sprache Ihrer Wahl, das Eingaben für die Anzahl der Spieler und die Anzahl der Startchips enthält und ein LCR-Spiel simuliert, das den Status des Spiels anzeigt, nachdem jeder Spieler gewürfelt hat.

Ein Spiel kann beispielsweise wie folgt ausgegeben werden:

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

Die Ausgabe muss nicht genau so aussehen, aber es sollte leicht zu erkennen sein, wie viele Chips jeder Spieler hat und wie viele Chips das Zentrum für jede Runde hat.

Es ist Code Golf, also gewinnt der kürzeste Code.

Emacs Lisp , 279 Bytes

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

Verwenden Sie diese Funktion als (f 4 3).

Besser lesbare Version:

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

Ausgabebeispiel:

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

Version, die den gleichen Status ausgibt, wenn ein Turn-Spieler noch 0 Chips hat:

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

Beginnt mit dem dritten Player im Array.

Probieren Sie es online aus.

Version, bei der Spieler mit 0 verbleibenden Chips (274 Byte) übersprungen werden:

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

Beginnt beim ersten Spieler im Array.

Probieren Sie es online aus.

-7 Bytes dank @ OlivierGrégoire .

Erklärung (der zweiten Version):

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 Bytes

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

Probieren Sie es online aus!

Druckt alle Spielerchips nach jedem Wurf

Gelee , 39 Bytes

<sup>+2, um das Wiederholungsverhalten zu korrigieren ( ¡muss ein Nullzeichen vorangestellt werden, damit «3Ḣ$-> ⁸FḢ«3)

Wenn wir die Ausgabelisten definieren können, die gedreht werden sollen, damit die Chips des Spielers, der zuvor links gehandelt hat, ganz rechts sind 6 Bytes für 33 Bytes (meiner Meinung nach ist es jedoch etwas umständlich, das zu lesen).</sup>

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

Ein dyadischer Link, der links Chips pro Spieler und rechts Spieleranzahl akzeptiert, der eine Liste der Chipzählungen der Spieler zu Beginn des Spiels und nach jeder Runde ergibt (einschließlich Runden, in denen 0 Chips einen Pass erzwingen). .

Probieren Sie es online aus!

Wie?

Jeder Spieler wirft seinerseits bis zu dreimal, abhängig von seiner Chipanzahl, eine Münze. Wenn ein Spieler die Köpfe dreht, tut er nichts, aber wenn er die Schwänze dreht, würfelt er einen dreiseitigen Würfel und verliert einen Chip gegen L, C oder R. (Beachten Sie, dass 0 Flips, wenn ein Spieler 0 Chips hat, dem Pass entsprechen.)
Dies wird wiederholt bis die Summe der Spielerchips 0 ist.
Die Implementierung dreht die Spieler in jeder Runde um eine Stelle nach links und dreht dann die resultierenden Zustände zurück, um alle auszurichten, als ob sie es nicht wären.

ẋµ’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 & le; +13 & le; Bytes

Benötigt using System;insgesamt +13 Bytes für den unten gezeigten Code, wenn ich das zählen muss. Ansonsten einfach in eine Klasse stecken und anrufen 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;}

Beispielausgabe für ein 2,2-Spiel:

|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

Weniger Golfversion:

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 # Interactive Compiler) , 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);}

Probieren Sie es online aus!

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

Holzkohle , 61 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Wechselt zwischen der Ausgabe der Würfelwürfe und der verbleibenden Chips (weder die anfängliche Anzahl der Chips noch die Anzahl der Chips in der Mitte sind in der Ausgabe enthalten). Erläuterung:

≔⁰η

Beginnen Sie mit dem ersten Spieler.

ＷΣθ«

Wiederholen, bis niemand mehr Chips hat.

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

Wirf bis zu drei Würfel für den aktuellen Spieler. Diese Würfel sind mit 0-5 gekennzeichnet, wobei 0-2 den Punkt darstellt, 3 nach links geht, 4 zur Mitte geht, 5 nach rechts ist.

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

Addieren Sie die Anzahl der Chips, die der Spieler rechts links und die Anzahl der Chips, die der Spieler links rechts übergeben hat, aber subtrahieren Sie die Anzahl der Chips, die der Spieler selbst weitergegeben hat.

≔﹪⊕ηＬθη

Zum nächsten Spieler vorrücken.

⟦⪫θ,

Geben Sie die neue Anzahl der von den Spielern gehaltenen Chips aus.

Tatsächlich ist es für jeden einfacher, gleichzeitig zu würfeln. Dies kann in 50 Bytes erfolgen, einschließlich des Druckens der Würfelwürfe sowie der verbleibenden Chips:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes.

05AB1E (Legacy) , 58 50 49 52 Byte

Version, die den gleichen Status ausgibt, wenn ein Turn-Spieler noch 0 Chips hat ( 50 49 52 Bytes ):

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

Probieren Sie es online aus.

Version, die Spieler mit 0 verbleibenden Chips überspringt ( 58 57 60 Bytes ):

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

Probieren Sie es online aus.

Beide +3 Bytes bei Verwendung der Legacy-Version, da die neue 05AB1E-Version einen seltsamen Fehler aufweist. Es sollte funktionieren mit Ws\(Minimum drücken ohne zu knallen; tauschen; Liste verwerfen) ersetzt durch ß(Popliste und Minimum drücken) und 0›(prüfen, ob größer als 0) ersetzt durch d(prüfen, ob nicht negativ / größer oder gleich 0) in der neue Version, aber aus irgendeinem Grund wird die Listenreihenfolge nach dem Trailing geändert ¼! .. : S (und die neue Version ist auch extrem langsam und läuft nach 60 Sekunden ab, bevor das Ergebnis beendet wird ..>.>)

Die erste Eingabe ist die Anzahl der Spieler, die zweite Eingabe die Anzahl der Chips pro Spieler.

Erklärung (der zweiten Version):

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