На вечірці мене познайомили з грою LCR. Зараз це не чудова гра, оскільки немає майстерності, а лише випадковий шанс. Але це змусило мене задуматися, я можу це кодувати, і я зробив швидку програму в R, щоб моделювати гру.

Правила гри, змінені з Вікіпедії, щоб відповідати тому, як ми грали:

Кожен гравець отримує щонайменше 3 фішки. Гравці приймають його по черзі, щоб розгорнути три шестигранні кубики, кожен з яких позначений символами "L", "C", "R" на одній стороні, і одна крапка на трьох сторонах, що залишилися. За кожен кинутий "L" або "R", гравець повинен передавати один чіп гравцеві відповідно зліва або справа. "С" позначає мікросхему до центру (горщика). Крапка не має ефекту.

Якщо у гравця залишилось менше трьох фішок, вони все ще в грі, але їх кількість фішок - це кількість кісток, які вони роблять на черзі, а не прокатування всіх трьох фішок. Коли у гравця нульові фішки, вони передають кістки на свою чергу, але можуть отримувати фішки від інших і відповідно робити наступний хід. Переможець - останній гравець, який поставив фішки в центр.

Конкурс: складіть програму своєю мовою, яка вибирає, яка приймає дані про кількість гравців та кількість стартових фішок та імітує гру 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: ДжонатанАллан

Вихідні дані не повинні виглядати точно так, але слід легко розрізати рулон з кістки, скільки фішок у кожного гравця і скільки фішок має центр за кожен крок.

Це код гольфу, тому найкоротший код виграє.

Emacs Lisp , 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)

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

Починається від першого гравця в масиві.

Спробуйте в Інтернеті.

-7 байт завдяки @ OlivierGrégoire .

Пояснення (другої версії):

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 байт

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)

Якщо ми можемо визначити вихідні списки будуть повернені мати фішки , що належать гравцеві , який діяв раніше зліва ми можемо позбутися від самої правої 6 байт по 33 байти (проте, на мою думку, читати це дещо незручно).</sup>

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

Діадичне посилання, що приймає фішки на гравця зліва та кількість гравців праворуч, що дає список підрахунків гравців як на початку гри, так і після кожного ходу (включаючи повороти, де 0 фішок змушує пройти) .

Спробуйте в Інтернеті!

Як?

Кожен гравець, по черзі, до трьох разів, залежно від їх кількості, обертає монету. Коли гравець перевертає голови, вони нічого не роблять, але якщо вони перевертають хвости, вони згортають тристоронній штамп, втрачаючи фішку на L, C або R. (Зверніть увагу, що 0 переворотів, коли у гравця 0 фішок, еквівалент проходження.)
Це повторюється поки сума фішок гравців не дорівнює 0.
Реалізація обертає гравців, залишених на одне місце, кожен виток, а потім повертає отримані стани назад, щоб усі вирівнялися так, ніби їх не було.

ẋµ’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 байт для коду, показаного нижче, якщо мені потрібно це порахувати. Інакше просто розмістіть його в будь-якому класі та зателефонуйте 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≔﹪⊕ηＬθη⟦⪫θ,

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Замінники між виведенням рулону з кістки та залишеними чіпами (ні вихідна кількість фішок, ні кількість фішок у центрі не включаються у вихід). Пояснення:

≔⁰η

Почніть з першого гравця.

ＷΣθ«

Повторюйте, поки ні в кого не залишилося жодної фішки.

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

Згорніть до трьох кубиків для поточного гравця. Ці кубики мають позначку 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›*¼

Спробуйте в Інтернеті.

Обидва +3 байти, використовуючи застарілу версію, оскільки нова версія 05AB1E має дивну помилку. Він повинен працювати з Ws\(натиснути мінімум без спливання; swap; список відміни), замінений на ß(поп-список та мінімум натискань) та 0›(перевірити, чи більший за 0), замінити на d(перевірити, якщо негативний / більший або дорівнює 0) у нова версія, але чомусь порядок списку змінюється після закінчення ¼! .. : 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