বাম কেন্দ্র ডান (LCR) কোড গল্ফ

10

একটি পার্টিতে আমার গেম এলসিআর-এর সাথে পরিচয় হয়। দক্ষতা নেই কেবলমাত্র এলোমেলো সুযোগ হওয়ায় এখন এটি দুর্দান্ত খেলা নয়। তবে এটি আমাকে ভেবে পেয়েছে, আমি এটি কোড করতে পারি এবং গেমটির মডেল করার জন্য আমি আর একটি দ্রুত প্রোগ্রাম তৈরি করেছি।

আমরা কীভাবে খেলেছি তার সাথে মিলের জন্য গেমের বিধিগুলি উইকিপিডিয়া থেকে পরিবর্তিত হয়েছে:

প্রতিটি খেলোয়াড় কমপক্ষে 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]]

এইচটি: জনাথন অ্যালান

আউটপুটটিকে ঠিক এর মতো দেখতে হবে না, তবে ডাইস রোলটি সনাক্ত করা সহজ হওয়া উচিত, প্রতিটি খেলোয়াড়ের কতগুলি চিপ রয়েছে এবং প্রতিটি বারের জন্য কেন্দ্রের কতগুলি চিপ রয়েছে।

এটি কোড গল্ফ তাই সংক্ষিপ্ততম কোড জিততে পারে।

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
@ জোনাথান অ্যালান, এটি আমার পক্ষে কাজ করে।
— সিটি হল
1
কেভিন ক্রুইজসেন, ভাল প্রশ্ন, আমি মনে করি আমি যে কোনও উপায়ে অনুমতি দেব।
— সিটি হল
1
@ সিটিএল সমস্ত ক্ষেত্রে আমি আমার উত্তরগুলি (জাভা এবং 05 এবি 1 ই) সম্পাদনা করেছি এবং এর সাথে এবং বাইরে উভয়কেই অন্তর্ভুক্ত করেছি। :)
— কেভিন ক্রুইজসেন
1
আমি প্রায় এটি রুনিকে করতে চাই যেখানে প্রতিটি নির্দেশ পয়েন্টার একটি প্রদত্ত খেলোয়াড় হিসাবে কাজ করে। আমি নিশ্চিত (এমনকি প্লেয়ারদের সংখ্যার ইনপুটকেও উপেক্ষা করে) পারছি না, তবে আমি যদি পারতাম তবে এটি ঝরঝরে হবে।
— ড্রাকো 18 গুলি আর এসই

উত্তর:

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 বাইটস @ অলিভিগ্রগ্রোয়ারকে ধন্যবাদ ।

ব্যাখ্যা (দ্বিতীয় সংস্করণের):

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
কোনও (ক্ষুদ্র) গল্ফ ছাড়াই আমার উচ্ছেদটি ছেড়ে 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
@ অলিভিগারগ্রোওরে আহ, এর Aথেকে পুনরায় ব্যবহারের স্মার্ট উপায় java.util.Arrays। : ডি এবং সেমি-কোলনে এটি -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
@ সিটিএল সমস্ত কেন্দ্রের চিপগুলি সর্বদা সমান n*c - sum(players)। যদি আমার স্পষ্টভাবে এটি লেখার প্রয়োজন হয় তবে আমি করব
— টিফিল্ড
সেটা সত্য. আমি এটি অনুমতি দেব।
— সিটি হল
2

জেলি , 39 বাইট

পুনরাবৃত্তি আচরণ ঠিক করার জন্য +2 ( ¡অবশ্যই নীলদ দিয়ে আগে হওয়া উচিত «3Ḣ$-> ⁸FḢ«3)

যদি আমরা আউটপুট তালিকাগুলি ঘোরানো সংজ্ঞা দিতে পারি যে খেলোয়াড়ের বামদিকে আগে অভিনয় করেছিলেন এমন চিপগুলি আমরা ডান-মোস্ট দিয়ে সরিয়ে ফেলতে পারি 33 বাইটের জন্য 6 বাইট (তবে আমার মতে এটি পড়তে কিছুটা বিশ্রী হয়)। 

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

একটি ডায়াডিক লিঙ্ক খেলতে বামে এবং খেলোয়াড়ের সংখ্যা অনুসারে খেলোয়াড়দের চিপস-প্রতি খেলোয়াড় গ্রহণ করে যা খেলার শুরুতে এবং প্রতিটি টার্নের পরে খেলোয়াড়দের চিপ গণনার একটি তালিকা দেয় (যেখানে মোড় যেখানে 0 চিপস পাস দেয়) ।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

প্রতিটি খেলোয়াড় তাদের চিপ গণনার উপর নির্ভর করে তিন বার পর্যন্ত একটি কয়েন ফ্লিপ করে। যখন কোনও খেলোয়াড় মাথা ফেরা করে তারা কিছুই না করে তবে যদি তারা লেজগুলি ফ্লিপ করে তবে তারা এল, সি বা আর এর কাছে একটি চিপ হারিয়ে তিন পার্শ্বযুক্ত মারা যায় (নোট করুন যে কোনও খেলোয়াড়ের 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, ...)
— জোনাথন অ্যালান
সূত্র
আমি এই ভাষাতে লোকেরা কীভাবে কোডের শোরগোলের মতো দেখায় কোড করে সে সম্পর্কে আমি কিছুটা মুগ্ধ হয়েছি। :) তবে আমি কেবল বেশ কয়েকটি ভাষা কিন্ডা জানি, তাই সম্ভবত আরও অভিজ্ঞতার সাথে এটি আসবে।
— সিটি হল
2
আপনি উইকিতে টিউটোরিয়ালটি পরীক্ষা করে দেখতে পারেন , এটি বেশ ভাল। আমি একবার কোড ব্রেকডাউন পোস্ট করার পরে আপনি আশা করি আমি যা করেছি তা অনুসরণ করব ...
— জোনাথন অ্যালান
... এটি সাবটলি ভুল আচরণ, যদিও? প্রতি বৈশিষ্ট অনুসারে, আপনাকে কেবল একটি কয়েন ফ্লিপ নয়, সমস্ত তিনটি ডাইস রোল করতে হবে। বর্ণনামূলক ত্রুটি না থাকলে এবং কোডটি ঠিক না থাকে।
— স্ট্যাকস্টাক
@ স্ট্যাকস্টাক - বিবরণ ওভারভিউটি কিছুটা বিভ্রান্তিকর, মুদ্রাটি প্রতিবার উল্টানো হয়; আমি এটি ঠিক করব - ধন্যবাদ। কোড বিচ্ছেদের বিবরণ 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;}

২,২ গেমের জন্য নমুনা আউটপুট:

|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⟦⪫ι,⪫θ,

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ।

— নিল
সূত্র
আমি নিশ্চিত নই, তবে এটি মনে হয় না যেন এটি প্রতিটি রাউন্ডের নয়, প্রতিটি চরিত্রের পরে অনুষ্ঠিত চিপের সংখ্যার জন্য অ্যাকাউন্ট করে।
— সিটি হল
@ সিটিএল সমস্ত ওহ, আপনার অর্থ প্রতিটি প্লেয়ার স্বতন্ত্রভাবে রোল করে এবং তারপরে চিপের সংখ্যা আপডেট হয়? দুঃখিত, আমি এটি উপেক্ষা করেছি। আমি সময় পেলেই আমার উত্তর আপডেট করব।
— নীল
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 সমান কিনা তা পরীক্ষা করুন) নতুন সংস্করণ, তবে কোনও কারণে তালিকার ক্রম পরিবর্তনের পরে তালিকাটি পরিবর্তন করা হয়েছে ¼! .. : এস (এবং নতুন সংস্করণটি ফলাফলটি শেষ করার আগে 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
উত্তরাধিকারের বিষয়গুলি সঠিক বলে মনে হচ্ছে, তবে এই লিখিতভাবে আমার উল্লেখ করা ত্রুটি বলে মনে হচ্ছে।
— সিটি হল
@ সিটি সব আহ, আপনি সত্যিই ঠিক বলেছেন। আমি [2, 3, 3, 3]এরপরে একটি লাইন দেখছি [2, 2, 2, 6]..: এস আমি কারণটি খুঁজে পেতে এবং এটি ঠিক করতে পারি কিনা তা আমি দেখতে পাচ্ছি। যদি তা না হয় তবে আমি সর্বদা এটি মুছতে পারি এবং কেবলমাত্র উত্তরাধিকারটিই ব্যবহার করতে পারি, যেহেতু এটি কোনওভাবেই আরও অনেক বেশি ফলাফল দেয় .. কোনও কারণে জটিল লুপগুলির সাথে নতুন সংস্করণটি বেশ ধীরে ধীরে ..
— >>>
@ সিটিএল সমস্ত আমি ইস্যুটি চিহ্নিত করতে সক্ষম হয়েছি, তবে এটি সমাধান করতে অক্ষম। কোনও কারণে তালিকার ক্রমটি বিশ্বব্যাপী বৃদ্ধির পরে ঠিক পরিবর্তিত হয় counter_variable.. আমি একটি সহজ উদাহরণে বিষয়টি পুনরুত্পাদন করার চেষ্টা করেছি, কিন্তু আমি অক্ষম। এটি অসীম লুপের ভিতরে নেস্টেড if-বিবৃতি এবং মানচিত্রের সাথে কিছু করার আছে তবে এটি অবশ্যই অদ্ভুত .. যাইহোক, আমি সেই সংস্করণটি সরিয়েছি এবং এখন কেবলমাত্র উত্তরাধিকার (এবং দ্রুত) সংস্করণটি রয়ে গেছে, যা ইচ্ছাকৃতভাবে কাজ করে।
— কেভিন ক্রুইজসেন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.