Lors d'une soirée, j'ai découvert le jeu LCR. Maintenant, ce n'est pas un grand jeu car il n'y a aucune compétence mais seulement une chance aléatoire. Mais ça m'a fait réfléchir, je pouvais coder cela, et j'ai fait un programme rapide en R pour modéliser le jeu.

Règles du jeu modifiées à partir de Wikipedia pour correspondre à la façon dont nous avons joué:

Chaque joueur reçoit au moins 3 jetons. Les joueurs à leur tour lancent trois dés à six faces, chacun étant marqué d'un "L", "C", "R" d'un côté et d'un seul point des trois côtés restants. Pour chaque "L" ou "R" lancé, le joueur doit passer une puce au joueur à sa gauche ou à sa droite, respectivement. Un "C" indique une puce au centre (pot). Un point n'a aucun effet.

S'il reste moins de trois jetons à un joueur, il est toujours dans le jeu mais son nombre de jetons est le nombre de dés qu'il lance à son tour, plutôt que de lancer les trois. Lorsqu'un joueur n'a aucun jeton, il passe les dés à son tour, mais peut recevoir des jetons des autres et prendre son prochain tour en conséquence. Le gagnant est le dernier joueur à avoir placé des jetons au centre.

Concours: écrivez un programme dans la langue de votre choix qui prend en compte le nombre de joueurs et le nombre de jetons de départ et simule un jeu de LCR, montrant l'état du jeu après que chaque joueur a lancé.

Par exemple, un jeu peut être sorti en tant que:

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

La sortie ne doit pas ressembler exactement à ceci, mais il devrait être facile de discerner le lancer de dés, le nombre de jetons que chaque joueur a et le nombre de jetons que le centre a pour chaque tour.

C'est le golf de code, donc le code le plus court gagne.

Emacs Lisp , 279 octets

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

Utilisez cette fonction comme (f 4 3).

Meilleure version lisible:

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

Exemple de sortie:

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

Version qui affiche le même état lorsqu'un joueur au tour n'a plus de jetons:

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

Commence avec le troisième joueur du tableau.

Essayez-le en ligne.

Version qui saute les joueurs avec 0 jeton restant (274 octets):

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

Commence par le premier joueur du tableau.

Essayez-le en ligne.

-7 octets grâce à @ OlivierGrégoire .

Explication (de la deuxième 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 octets

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

Essayez-le en ligne!

Imprime tous les jetons des joueurs après chaque lancer

Gelée , 39 octets

<sup>+2 pour corriger le comportement de répétition ( ¡doit être précédé d'un nilad donc «3Ḣ$-> ⁸FḢ«3)

Si nous pouvons définir les listes de sortie à faire tourner pour avoir les jetons appartenant au joueur qui a agi précédemment à gauche, nous pouvons supprimer le plus à droite 6 octets pour 33 octets (cependant, à mon avis, il est quelque peu gênant de lire cela).</sup>

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

Un lien dyadique acceptant les jetons par joueur à gauche et le nombre de joueurs à droite qui donne une liste de jetons comptant les joueurs au début de la partie et après chaque tour (y compris les tours où 0 jeton force une passe) .

Essayez-le en ligne!

Comment?

Chaque joueur à son tour, jusqu'à trois fois, en fonction de son nombre de jetons, lance une pièce. Lorsqu'un joueur retourne la tête , ils ne font que si elles queues à feuilles mobiles , ils roulent alors un dé à trois côtés perdre une puce à L, C ou R. (Notez que 0 flips lorsqu'un joueur a 0 jetons est équivalent à passer.)
Cette opération est répétée jusqu'à ce que la somme des jetons des joueurs soit de 0.
L'implémentation fait tourner les joueurs à gauche d'une place à chaque tour, puis fait pivoter les états résultants pour qu'ils soient tous alignés comme s'ils ne l'étaient pas.

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

Requiert using System;un total de +13 octets pour le code ci-dessous, si je suis tenu de le compter. Sinon, plonk juste dans n'importe quelle classe et appelez 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;}

Exemple de sortie pour un jeu 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

Version moins golfée:

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 octets

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

Essayez-le en ligne!

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

Fusain , 61 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Alternance entre la sortie des dés et des jetons restants (ni le nombre initial de jetons ni le nombre de jetons au centre ne sont inclus dans la sortie). Explication:

≔⁰η

Commencez avec le premier joueur.

ＷΣθ«

Répétez jusqu'à ce qu'il ne reste plus de jetons.

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

Lancez jusqu'à trois dés pour le joueur actuel. Ces dés sont étiquetés 0-5, où 0-2 représente le point, 3 est passé à gauche, 4 est au centre, 5 est à droite.

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

Additionnez le nombre de jetons que le joueur de droite a passé à gauche et le nombre de jetons que le joueur de gauche a passé à droite, mais soustrayez le nombre de jetons que le joueur lui-même a transmis.

≔﹪⊕ηＬθη

Passez au joueur suivant.

⟦⪫θ,

Sortez le nouveau nombre de jetons détenus par les joueurs.

Il est en fait plus simple pour tout le monde de lancer leurs dés simultanément, ce qui peut être fait en 50 octets, y compris l'impression des rouleaux de dés ainsi que des jetons restants:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code.

05AB1E (hérité) , 58 50 49 52 octets

Version qui affiche le même état quand un joueur au tour n'a plus de jetons ( 50 49 52 octets ):

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

Essayez-le en ligne.

Version qui saute les joueurs avec 0 jeton restant ( 58 57 60 octets ):

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

Essayez-le en ligne.

Les deux octets +3 en utilisant la version héritée, car la nouvelle version 05AB1E a un bug bizarre. Il devrait fonctionner avec Ws\(push minimum sans popping; swap; discard list) remplacé par ß(pop list and push minimum) et 0›(vérifier si supérieur à 0) remplacé par d(vérifier si non négatif / supérieur ou égal à 0) dans le nouvelle version, mais pour une raison quelconque, l'ordre de la liste est modifié après la fin ¼! .. : S (et la nouvelle version est également extrêmement lente et expire après 60 secondes avant de terminer le résultat ..>.>)

La première entrée est la quantité de joueurs, la deuxième entrée la quantité de jetons par joueur.

Explication (de la deuxième 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