लेफ्ट सेंटर राइट (LCR) कोड गोल्फ

10

एक पार्टी में, मुझे खेल LCR से परिचित कराया गया था। अब यह कोई बढ़िया खेल नहीं है क्योंकि कोई कौशल नहीं है लेकिन केवल यादृच्छिक मौका है। लेकिन यह मुझे सोच रहा था, मैं इसे कोड कर सकता था, और मैंने खेल को मॉडल करने के लिए आर में एक त्वरित कार्यक्रम बनाया।

खेल के नियम विकिपीडिया से संशोधित होकर हम कैसे खेले:

प्रत्येक खिलाड़ी को कम से कम 3 चिप्स मिलते हैं। खिलाड़ी तीन छह-पक्षीय पासा को रोल करने के लिए इसे लेते हैं, जिनमें से प्रत्येक को एक तरफ "एल", "सी", "आर" के साथ चिह्नित किया जाता है, और तीन शेष पक्षों पर एक एकल डॉट। प्रत्येक "एल" या "आर" फेंकने के लिए, खिलाड़ी को खिलाड़ी को क्रमशः उनके बाएं या दाएं एक चिप को पास करना होगा। एक "सी" एक चिप को केंद्र (पॉट) को इंगित करता है। डॉट का कोई प्रभाव नहीं है।

यदि किसी खिलाड़ी के पास तीन से कम चिप्स बचे हैं, तो वे अभी भी खेल में हैं, लेकिन उनके चिप्स की संख्या तीनों को लुढ़काने के बजाए उनकी बारी है। जब किसी खिलाड़ी के पास शून्य चिप्स होते हैं, तो वे अपनी बारी पर पासा पास करते हैं, लेकिन दूसरों से चिप्स प्राप्त कर सकते हैं और उसके अनुसार अपना अगला मोड़ ले सकते हैं। विजेता केंद्र में चिप्स डालने वाला अंतिम खिलाड़ी है।

प्रतियोगिता: अपनी पसंद की भाषा में एक प्रोग्राम लिखें जो खिलाड़ियों की संख्या और शुरुआती चिप्स की संख्या के लिए इनपुट लेता है और एलसीआर के एक गेम का अनुकरण करता है, प्रत्येक खिलाड़ी के रोल करने के बाद गेम की स्थिति दिखा रहा है।

उदाहरण के लिए, एक गेम आउटपुट हो सकता है: 

[[[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: जोनाथनअलन

आउटपुट को बिल्कुल इस तरह नहीं देखना है, लेकिन डाइस रोल को डिस्कनेक्ट करना आसान होना चाहिए, प्रत्येक खिलाड़ी के पास कितने चिप्स हैं और प्रत्येक मोड़ के लिए केंद्र में कितने चिप्स हैं।

यह कोड गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

code-golf  random 
— सीटी हॉल
स्रोत
3
"पासा रोल को डिस्कनेक्ट करना आसान होना चाहिए" - यह चिप राज्यों से अंतर्निहित (इसलिए आसान है), जैसा कि खिलाड़ी है जो लुढ़का है, क्योंकि यह बारी आधारित है। मेरा तर्क है कि इस उदाहरण के उत्पादन में सब कुछ आवश्यक है: [[[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]]- क्या यह मामला है?
— जोनाथन एलन
1
@JonathanAllan, जो मेरे लिए काम करता है।
— सीटी हॉल
1
@ केविनक्रूजसेन, अच्छा सवाल, मुझे लगता है कि मैं किसी भी तरह से अनुमति दूंगा।
— सीटी हॉल
1
@CTHall उस मामले में मैंने अपने उत्तर (जावा और 05AB1E) दोनों को संपादित किया है और इसमें बिना और दोनों शामिल हैं। :)
— केविन क्रूज़सेन
1
मैं लगभग रूनिक पर ऐसा करना चाहता हूं जहां प्रत्येक निर्देश सूचक एक दिए गए खिलाड़ी के रूप में कार्य करता है। यकीन नहीं है कि मैं (यहां तक ​​कि खिलाड़ियों के इनपुट की संख्या की भी अनदेखी कर सकता हूं), लेकिन अगर मैं ऐसा कर सका तो यह साफ-सुथरा होगा।
— Draco18s अब

जवाबों:

4

एमएसीएस लिस्प , 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)
— ADL
स्रोत
3

जावा 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
— केविन क्रूज़सेन
स्रोत
1
एक (छोटे) गोल्फ के बिना मेरे उत्थान को छोड़ सकता है: D s=0;for(int C:c)s+=C;(21 बाइट्स) को s=A.stream(c).sum();(20 बाइट्स) द्वारा बदला जा सकता है
— ओलिवियर ग्राएगॉयर
इसके अलावा, यकीन नहीं पूरी तरह से ठीक है, तो: c[i%p]-=r<3?1:0→ c[i%p]-=1-r/3। इससे 2 बाइट बचती हैं।
— ओलिवियर ग्राईगोइरे
1
@ OlivierGrégoire आह, का स्मार्ट तरीका पुनः उपयोग Aसे java.util.Arrays। : D और अर्ध-कोलन पर बचाने के लिए इसे लूप में रखकर -2 बाइट्स। और 1-r/3वास्तव में सही है ( यहां देखें )। धन्यवाद।
— केविन क्रूज़सेन
लूप तुलना घटने के साथ अच्छी चाल। मैं चोरी कर सकता हूँ।
— स्टैकस्टक
1
मेरी पिछली हटाई गई टिप्पणी पर ध्यान न दें: मेरी सत्य तालिका बंद थी। यह एक निश्चित है: s=c[u=(i+r-1+p)%p]+=1-r&1-r/4(2 बाइट्स बचाता है, की तुलना में s=c[u=(i+r%2*2-1+p)%p]+=r<2?1:0)
— ओलिवियर ग्राईगोइयर
2

पायथन 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

इसे ऑनलाइन आज़माएं!

हर रोल के बाद सभी खिलाड़ियों के चिप्स प्रिंट करता है

— TFeld
स्रोत
अच्छा प्रयास है, लेकिन कोड केंद्र में चिप्स की मात्रा नहीं दिखाता है।
— सीटी हॉल
3
@CTHall केंद्र में चिप्स हमेशा बराबर होते हैं n*c - sum(players)। अगर मुझे इसे स्पष्ट रूप से लिखने की आवश्यकता है, तो मैं
— TFeld
यह सच है। मैं इसकी अनुमति दूंगा।
— सीटी हॉल
2

जेली , 39 बाइट्स

पुनरावृत्ति व्यवहार को ठीक करने के लिए +2 ( ¡एक निलाड से पहले होना चाहिए «3Ḣ$-> ⁸FḢ«3)

अगर हम आउटपुट सूचियों को परिभाषित करने के लिए घुमाए जाने वाले खिलाड़ी से संबंधित चिप्स को परिभाषित कर सकते हैं जो पहले बाईं ओर काम करते थे, हम सबसे सही के साथ दूर कर सकते हैं 33 बाइट्स के लिए 6 बाइट्स (हालांकि, मेरी राय में, यह पढ़ने के लिए कुछ अजीब है)। 

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

दाईं ओर चिप्स-प्रति-खिलाड़ी और दाएं पर नंबर-ऑफ-प्लेयर्स को स्वीकार करने वाला एक डाइएडिक लिंक, जो खेल की शुरुआत में और प्रत्येक मोड़ के बाद खिलाड़ियों की एक सूची गिना जाता है (जिसमें घुमाव जहां 0 चिप्स एक पास को शामिल करता है) ।

इसे ऑनलाइन आज़माएं!

कैसे?

प्रत्येक खिलाड़ी बदले में, तीन बार तक, उनकी चिप गणना के आधार पर, एक सिक्का फ़्लिप करता है। जब कोई खिलाड़ी सिर फड़फड़ाता है तो वे कुछ नहीं करते हैं लेकिन अगर वे पलटते हैं तो वे तीन तरफा मर जाते हैं, जिससे L, C या R. की चिप खो जाती है (ध्यान दें कि जब खिलाड़ी के पास 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, ...)
— जोनाथन एलन
स्रोत
मैं थोड़ा प्रभावित हूं कि कैसे लोग इन भाषाओं में कोड करते हैं जो लाइन शोर की तरह दिखते हैं। :) लेकिन फिर मैं केवल थोड़े भाषाओं को जानता हूं, इसलिए शायद अधिक अनुभव के साथ यह आएगा।
— सीटी हॉल
2
आप विकी पर ट्यूटोरियल देख सकते हैं , यह बहुत अच्छा है। एक बार जब मैं कोड ब्रेकडाउन पोस्ट करता हूं, तो आप उम्मीद करेंगे कि मैंने जो किया है, उसका पालन करें ...
— जोनाथन एलन
... यह सूक्ष्म रूप से गलत व्यवहार है, हालांकि? प्रति युक्ति, आपको केवल एक सिक्का फ्लिप नहीं, बल्कि सभी तीन पासा रोल करने की आवश्यकता है। जब तक विवरण त्रुटि में है और कोड ठीक नहीं है।
— स्टैकस्टक
@Stackstuck - विवरण अवलोकन थोड़ा भ्रामक है, सिक्का हर बार फ़्लिप किया जाता है; मैं इसे ठीक कर दूंगा - धन्यवाद FWIW कोड टूटने विवरण सही है - सिक्का फ्लिप शाखाओं में बंटी, Ø.X¤?दोहराएँ-अप-टू-3-बार निर्देश के अंदर नेस्टेड है, ⁸«3Ḣ¤¡।
— जोनाथन एलन
आह ठीक है। मैं खुशी से मदद कर सकता है।
— स्टैकस्टक
1

सी #, 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;
}
— Stackstuck
स्रोत
खैर, यह मेरा यहां पहला जवाब है। कृपया मुझे मत खाओ।
— स्टैकस्टक
आह, डीआरएटी। मुझे मेरा सरणी मुद्रण व्यवहार जावा से उलझा हुआ मिला। मैं अभी हूँ ... एक संशोधन के साथ सही वापस।
— स्टैकस्टक
ठीक है, यह तय है, आउटपुट निश्चित रूप से काम करना चाहिए।
— स्टैकस्टक
... ओह, नहीं, एक और त्रुटि है।
— स्टैकस्टक
जब व्यवहार वास्तव में शेष है तो मोडुलो कहने वाले लोगों को ... ऐसा नहीं करना चाहिए। वहाँ, मुझे 90% यकीन है कि यह अब काम करता है।
— स्टैकस्टक
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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);}
— अज्ञान का अवतार
स्रोत
1

चारकोल , 61 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। डाइस रोल और चिप्स के आउटपुट के बीच वैकल्पिक (न तो चिप्स की प्रारंभिक संख्या और न ही केंद्र में चिप्स की संख्या आउटपुट में शामिल है)। स्पष्टीकरण:

≔⁰η

पहले खिलाड़ी से शुरू करें।

ＷΣθ«

तब तक दोहराएं जब तक किसी के पास कोई चिप्स न बचा हो।

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

वर्तमान खिलाड़ी के लिए तीन पासा तक रोल करें। इन पासा को 0-5 पर लेबल किया जाता है, जहां 0-2 डॉट का प्रतिनिधित्व करता है, 3 बाईं ओर से गुजरता है, 4 केंद्र में है, 5 दाईं ओर है।

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

चिप्स की संख्या खिलाड़ी को दायीं तरफ से जोड़े और बायीं तरफ से खिलाड़ी के चिप्स की संख्या दाईं ओर से गुजरती है, लेकिन जिस खिलाड़ी ने खुद को पास किया है उसकी संख्या को घटाएं।

≔﹪⊕ηＬθη

अगले खिलाड़ी के लिए अग्रिम।

⟦⪫θ,

खिलाड़ियों द्वारा आयोजित चिप्स की नई संख्या का उत्पादन।

यह वास्तव में सभी के लिए अपने पासा को एक साथ रोल करने के लिए सरल है, जिसे 50 बाइट्स में किया जा सकता है, जिसमें डाइस रोल को प्रिंट करने के साथ-साथ चिप्स भी शामिल हैं:

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

— नील
स्रोत
मुझे यकीन नहीं है, लेकिन ऐसा नहीं लगता कि यह प्रत्येक भूमिका के बाद आयोजित चिप्स की संख्या के लिए है, प्रत्येक दौर में नहीं।
— सीटी हॉल
@CTHall ओह, आपका मतलब है कि प्रत्येक खिलाड़ी व्यक्तिगत रूप से रोल करता है, और फिर चिप्स की संख्या अपडेट की जाती है? क्षमा करें, मैंने इसे अनदेखा कर दिया। जैसे ही मेरे पास समय होगा मैं अपना जवाब अपडेट कर दूंगा।
— नील
1

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\(पॉपिंग के बिना न्यूनतम धक्का; स्वैप सूची छोड़ें) को प्रतिस्थापित किया गया ß(पॉप सूची और न्यूनतम धक्का) और 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
— केविन क्रूज़सेन
स्रोत
मुझे यकीन नहीं है कि यह सही ढंग से काम कर रहा है। ऐसा लगता है कि खिलाड़ी अपनी बारी पर चिप्स हासिल कर सकते हैं जो कि नहीं होना चाहिए।
— सीटी हॉल
क्या आप निश्चित हैं? आपने कौन से चार टीआईओ संस्करणों में इसे देखा? मैंने केवल अंतिम (लीगेसी संस्करण की जाँच की है जो खिलाड़ियों को 0 चिप्स के साथ छोड़ता है), लेकिन एक खिलाड़ी के बढ़ने का एकमात्र समय ऐसा होता है जब दूसरे खिलाड़ी की बारी होती है। यह है कि अंतिम डिबग-लाइन के साथ अंतिम एक है ताकि आप देख सकें कि (0-अनुक्रमित) खिलाड़ी किस मोड़ पर है।
— केविन क्रूज़सेन
1
विरासत सही प्रतीत होती है, लेकिन गैरकानूनी त्रुटि मुझे बताई गई है।
— सीटी हॉल
@CTHall आह, आप वास्तव में सही हैं। मुझे एक पंक्ति दिखाई दे रही [2, 3, 3, 3]है [2, 2, 2, 6]..: एस मैं देखूंगा कि क्या मैं इसका कारण ढूंढ सकता हूं और इसे ठीक कर सकता हूं। यदि नहीं, तो मैं इसे हमेशा हटा सकता हूं और केवल विरासत का उपयोग कर सकता हूं, क्योंकि यह किसी भी तरह से बहुत अधिक आउटपुट देता है .. नया संस्करण किसी कारण के लिए जटिल छोरों के साथ बहुत धीमा है ..>।>
— केविन क्रूज़सेन
@CTHall मैं इस मुद्दे को इंगित करने में सक्षम है, लेकिन इसे ठीक करने में असमर्थ है। किसी कारण से सूची का क्रम वैश्विक बढ़ने के बाद सही बदल गया है counter_variable.. मैंने इस मुद्दे को एक सरल उदाहरण में पुन: पेश करने की कोशिश की, लेकिन करने में असमर्थ रहा। यह नेस्टेड लूप-इन-स्टेटमेंट और अनंत लूप के अंदर के नक्शे के साथ कुछ करने के लिए है, लेकिन यह निश्चित रूप से अजीब है। वैसे भी, मैंने उस संस्करण को हटा दिया है और अब केवल विरासत (और तेज) संस्करण बना हुआ है, जो इच्छित के रूप में काम करता है।
— केवि क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.