পটভূমি

হ্যাঁ, বিটস্ট্রিং ফিজিক্স একটি আসল জিনিস । ধারণাটি কেবলমাত্র বিটগুলির স্ট্রিংগুলি ব্যবহার করে যা একটি সম্ভাব্য নিয়মের ... বা কোনও কিছুর অধীনে বিকশিত হয়ে পদার্থবিজ্ঞানের একটি নতুন তত্ত্ব তৈরি করা। এটি সম্পর্কে বেশ কয়েকটি কাগজপত্র পড়া সত্ত্বেও আমি এখনও বেশ বিভ্রান্ত। তবে বিটস্ট্রিং মহাবিশ্ব একটি সুন্দর ছোট কোড গল্ফ তৈরি করে for

প্রোগ্রাম ইউনিভার্স

বিটস্ট্রিং পদার্থবিজ্ঞান একটি তথাকথিত প্রোগ্রাম মহাবিশ্বের মধ্যে স্থান নেয় । মহাবিশ্বের বিবর্তনের প্রতিটি ধাপে, Lকয়েকটি দৈর্ঘ্যের বিটস্ট্রিংগুলির একটি সীমাবদ্ধ তালিকা রয়েছে যেখানে kদুটি উপাদানগুলির তালিকা দিয়ে শুরু হয় । এক টাইমস্টেপ নিম্নরূপে প্রক্রিয়া করা হয় (পাইথনের মতো সিউডোকোডে)।[10,11]k = 2

A := random element of L
B := random element of L
if A == B:
    for each C in L:
        append a random bit to C
else:
    append the bitwise XOR of A and B to L

সমস্ত এলোমেলো পছন্দগুলি একে অপরের তুলনায় অভিন্ন এবং এলোমেলো।

উদাহরণ

4 টি ধাপের উদাহরণের বিবর্তনটি নীচের মতো হতে পারে। প্রাথমিক তালিকা দিয়ে শুরু করুন L:

10
11

আমরা এলোমেলোভাবে চয়ন করি A := 10এবং B := 10, যা একই সারি, যার অর্থ আমাদের প্রতিটি স্ট্রিং Lএলোমেলো বিট দিয়ে প্রসারিত করা প্রয়োজন :

101
110

এরপরে, আমরা চয়ন করি A := 101এবং B := 110, এবং সেগুলি সমান না হওয়ায় আমরা তাদের এক্সওআর যুক্ত করি L:

101
110
011

এর পরে, আমরা নির্বাচন A := 011এবং B := 110, এবং আবার তাদের XOR যাও সংযোজন:

অবশেষে, আমরা A := 101(শেষ সারি) এবং B := 101(প্রথম সারি) যা সমান, তা বেছে নিই, তাই আমরা এলোমেলো বিটগুলি দিয়ে প্রসারিত করি:

কাজটি

আপনার কাজটি হ'ল একটি অণুগঠিত পূর্ণসংখ্যাকে tইনপুট হিসাবে গ্রহণ করা , tটাইমস্টেপের জন্য প্রোগ্রামের মহাবিশ্বকে অনুকরণ করা , এবং ফলাফলটি ফিরে আসা বা মুদ্রণ করা L। t = 0প্রাথমিক তালিকায় ফলাফলটি নোট করুন [10,11]। আপনি Lপূর্ণসংখ্যার তালিকার তালিকা, বুলিয়ান মানগুলির তালিকার তালিকা বা স্ট্রিংগুলির তালিকা হিসাবে আউটপুট করতে পারেন ; যদি আউটপুট STDOUT এ যায়, আপনি কিছু যুক্তিসঙ্গত বিন্যাসে প্রতি লাইন বিটস্ট্রিংগুলি মুদ্রণ করতে পারেন। বিটস্ট্রিংয়ের ক্রমটি উল্লেখযোগ্য; বিশেষত, প্রাথমিক তালিকায় থাকতে পারে না [11,10], [01,11]বা যে মত কিছু। ফাংশন এবং সম্পূর্ণ প্রোগ্রাম উভয়ই গ্রহণযোগ্য, মানক লুফোলগুলি অনুমোদিত নয় এবং সর্বনিম্ন বাইট গণনা জিতেছে।

code-golf array-manipulation random

— Zgarb
সূত্র

আমরা কি বিট স্ট্রিংয়ের দৈর্ঘ্য সীমাবদ্ধ করতে পারি (এটি: আমি কি 32 বিট সংখ্যা এবং বিট ক্রিয়াকলাপগুলি ব্যবহার করতে পারি)?

— edc65

1

@ edc65 না, স্ট্রিংগুলির দৈর্ঘ্য নির্বিচারে উচ্চতর হতে পারে।

— জাগারব

3

@ edc65 ৩২ বিট বেশি পাওয়ার জন্য প্রত্যাশিত সময় এবং মেমরির প্রয়োজনীয়তাগুলি জ্যোতির্বিজ্ঞানের, তবে এটি একটি উপযুক্ত কারণ আমরা একটি মহাবিশ্বকে অনুকরণ করছি। ;)

— জাগারব

5

এই কি বিট স্ট্রিং পদার্থবিজ্ঞান একটি ক্র্যাকপট ধারণা? আমি পুরো কাগজটি পড়িনি, তবে বাক্যটি আমরা একটি তত্ত্ব প্রদান করতে বিট-স্ট্রিং পদার্থবিজ্ঞান ব্যবহার করেছি যার মধ্যে আনুমানিক hbar c / e2 = 22 - 1 + 23 - 1 + 27 - 1 = 137 পদার্থটি বোঝায় একটি কম্পিউটার অ্যালগরিদম এবং তথ্য তত্ত্ব আমাকে কিছুটা আঘাত করে ... সংখ্যাতাত্ত্বিক।

— xebtl

1

@ xebtl এটি আমার কাছেও পাগল বলে মনে হচ্ছে। আমার মনে আছে কোথাও অ্যালগরিদমের পক্ষে ন্যায়সঙ্গত পাঠ করা এবং এটি পদার্থবিদ্যার চেয়ে খারাপ ছদ্ম-দর্শন মত মনে হয়েছিল। এছাড়াও, আপনার অ্যালগরিদমের বিবরণটি আমার সংস্করণটির সাথে মিলছে বলে মনে হচ্ছে, সম্ভবত আমি আপনাকে কোনওভাবে ভুল বুঝছি।

— জাগারব

7

পাইথ, 27 26 বাইট

u?+RO2GqFKmOG2aGxVFKQ*]1U2

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা:

                              implicit: Q = input number
                     *]1U2    the initial list [[1,0], [1,1]]
u                   Q         reduce, apply the following expression Q times to G = ^
          mOG2                  take two random elements of G
         K                      store in K
       qF                       check if they are equal
 ?                              if they are equal:
  +RO2G                           append randomly a 0 or 1 to each element of G
                                else:
              aG                  append to G
                xVFK              the xor of the elements in K

— Jakube
সূত্র

xVFKসমতূল্য xMK।

— isaacg

@ আইসাক না, xVFKসমান xMCK, একই বাইট গণনা।

— জাকুব

11

সিজেম, 42 40 38 37 বাইট

স্প 3000 দ্বারা 1 বাইট সংরক্ষণ করা হয়েছে।

B2b2/q~{:L_]:mR_~#L@~.^a+L{2mr+}%?}*p

ব্যাখ্যা

বেস -২ নম্বর হিসাবে প্রাথমিক অবস্থা তৈরি করুন:

B2b e# Push the the binary representation of 11: [1 0 1 1]
2/  e# Split into chunks of 2 to get [[1 0] [1 1]]

এবং তারপরে মূল লুপটি সম্পাদন করুন এবং ফলাফলটি প্রিন্ট করুন-শেষে:

q~       e# Read and eval input t.
{        e# Run this block t times.
  :L     e#   Store the current universe in L.
  _]     e#   Copy it and wrap both copies in an array.
  :mR    e#   Pick a random element from each copy.
  _~     e#   Duplicate those two elements, and unwrap them.
  #      e#   Find the second element in the first. If they are equal, it will be found at
         e#   index 0, being falsy. If they are unequal, it will not be found, giving
         e#   -1, which is truthy.

         e#   We'll now compute both possible universes for the next step and then select
         e#   the right one based on this index. First, we'll build the one where they were
         e#   not equal.

  L@~    e#   Push L, pull up the other copy of the selected elements and unwrap it.
  .^     e#   Take the bitwise XOR.
  a+     e#   Append this element to L.

  L      e#   Push L again.
  {      e#   Map this block onto the elements in L.
    2mr+ e#     Append 0 or 1 at random. 
  }%     
  ?      e#   Select the correct follow-up universe.
}*
p        e# Pretty-print the final universe.

এটি এখানে পরীক্ষা করুন।

— মার্টিন ইন্ডার
সূত্র

6

জুলিয়া, 141 129 বাইট

t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A=L[rand(r)];B=L[rand(r)];A==B?for j=r L[j]=[L[j],rand(0:1)]end:push!(L,A$B)end;L)

চতুর কিছুই না। একটি নামবিহীন ফাংশন তৈরি করে যা কোনও পূর্ণসংখ্যাকে ইনপুট হিসাবে গ্রহণ করে এবং অ্যারের অ্যারে প্রদান করে। এটি কল করার জন্য, এটির একটি নাম দিন f=t->...।

অবহেলিত + ব্যাখ্যা:

function f(t)
    # Start with L0
    L = Any[[1,0], [1,1]]

    # Repeat for t steps
    for i = 1:t
        # Store the range of the indices of L
        r = 1:length(L)

        # Select 2 random elements
        A = L[rand(r)]
        B = L[rand(r)]

        if A == B
            # Append a random bit to each element of L
            for j = r
                L[j] = [L[j], rand(0:1)]
            end
        else
            # Append the XOR of A and B to L
            push!(L, A $ B)
        end
    end

    # Return the updated list
    L
end

উদাহরণ:

julia> f(4)
4-element Array{Any,1}:
 [1,0,1,0]
 [1,1,1,1]
 [0,1,1,0]
 [0,1,0,0]

julia> f(3)
3-element Array{Any,1}:
 [1,0,1,1]
 [1,1,1,0]
 [0,1,0,1]

এমএল ধন্যবাদ 12 বাইট সংরক্ষণ করা!

— অ্যালেক্স এ।
সূত্র

যদি আপনি / অন্যটি পরিবর্তে টের্নে অপারেটর ব্যবহার করেন এবং যদি আপনি পরিবর্তন করেন তবে আপনি এটি 133 টি অক্ষরে শেভ করতে পারেন A=something;B=something else to A,B=something,something else:

t->(L=Any[[1,0],[1,1]];for i=1:t r=1:length(L);A,B=L[rand(r)],L[rand(r)];A==B?(for j=r L[j]=[L[j],rand(0:1)]end):(push!(L,A$B))end;L)

— এমএল

@ এমএমএল: ভাল লাগল, ধন্যবাদ আমি টার্নারি অপারেটরটি ব্যবহার করার কথা ভাবিনি। তবে আপনার প্রকৃতপক্ষে টেনিনারিটিতে প্রথম বন্ধনী প্রয়োজন নেই যা আপনার পরামর্শের চেয়ে আরও 4 টি সাশ্রয় করে। বরাদ্দকরণ Aএবং Bপৃথক করে দেওয়া আসলে তাদের একসাথে নির্ধারণের সমান দৈর্ঘ্য, তাই আমি সেই অংশটি যেমন রেখেছি তেমন রেখেছি। আপনার পরামর্শের জন্য আবার ধন্যবাদ!

— অ্যালেক্স এ

আপনাকে স্বাগতম. আহ আমি দেখি. হ্যাঁ, প্রথম বন্ধনী প্রয়োজনীয় নয়।

— এমএল

4

পাইথন 2, 141

আমি কয়েকটি ভিন্ন পদ্ধতি চেষ্টা করেছি, তবে আমি যেটা অর্জন করতে পারি তা তুলনামূলকভাবে সোজা। ১৫ টি চর বা তার জন্য এবং আমাকে (এবং এর অস্তিত্ব সম্পর্কে শেখানোর জন্য int.__xor__) আপনাকে এসপি 3000 ধন্যবাদ ।

from random import*
L=[[1,0],[1,1]];C=choice
exec"A=C(L);B=C(L);L=[L+[map(int.__xor__,A,B)],[x+[C([1,0])]for x in L]][A==B];"*input()
print L

— KSab
সূত্র

এখানে 141: লিঙ্ক

— Sp3000

4

পাইথন 2, 127 122

ধরে নিই ফর্মের পাইথন বিট স্ট্রিং '0b1'ইত্যাদি ঠিক আছে:

from random import*
C=choice
L=[2,3]
exec"x=C(L)^C(L);L=L+[x]if x else[a*2+C([0,1])for a in L];"*input()
print map(bin,L)

এখানে কেবলমাত্র হালকা উপদ্রবটি XOR (A, B) = 0 iff A = B এ ব্যবহার করা হয়েছে।

সংযুক্তকরণের forলুপটি সংক্ষিপ্ত করার জন্য @ Sp300 কে ধন্যবাদ

— joc
সূত্র

মন্তব্যগুলিতে একবার নজর

— দিলেও

আমি এখনই এই উত্তরটি পরীক্ষা করতে পারছি না, তবে এটি যদি নেতৃস্থানীয় শূন্যগুলি সংরক্ষণ না করে তবে এটি দুর্ভাগ্যক্রমে ভুল।

— জাগারব

3

পাইথ, 34

u?+RO`TGqJOGKOG+Gsm`s!dqVJKQ[`T`11

প্রতিটি পুনরাবৃত্তি প্রয়োগ করতে হ্রাস ব্যবহার করে। আমি যখন গল্ফ করা শেষ করব তখন আমি ব্যাখ্যা করব।

এখানে চেষ্টা করুন

— FryAmTheEggman
সূত্র

2

কে, 46 53 46 বাইট

{x{:[~/t:2?x;{x,*1?2}'x;x,,,/~=/t]}/(1 0;1 1)}

এর আকারের একটি ভাল অংশ (প্রায় 7 বাইট) কে এর কাছে নেই এমনটি করে xor অপারেটর আমাকে নিজেই প্রয়োগ করতে হয়েছিল। মূলত, আমি স্ট্রিংগুলির একটি তালিকা ব্যবহার করেছি, তারপরে বুঝতে পেরেছিলাম যে এটি অত্যন্ত বোকা। তাই এখন আমি আবার 7 বাইট কেটে দিলাম!

আগে:

{x{:[~/t:2?x;{x,*$1?2}'x;x,,,/$~=/(0$')'t]}/$:'10 11}

@ জন এই মন্তব্যগুলিতে উল্লেখ করেছেন যে প্রাথমিক রাষ্ট্রটি হার্ডকোডযুক্ত হওয়ার কথা ছিল, যার দাম extra অতিরিক্ত বাইট। : /

— kirbyfan64sos
সূত্র

সমস্যা সম্পর্কিত আমার পড়াটি হ'ল আপনাকে সর্বদা হার্ডকোডযুক্ত "মহাবিশ্ব" দিয়ে শুরু করা উচিত (1 0;1 1)- আপনার প্রোগ্রাম এটিকে ইনপুট হিসাবে স্বীকার করে।

— জন

@ জন ফিক্সড তবে, এটির কাজ করার কোনও গ্যারান্টি নেই কারণ আমি পরিবর্তনগুলি পরীক্ষা করি নি; আমি কেবল আপনার ওকে পুনর্বাসনের শেষ অংশটি চেষ্টা করেছি ...

— kirbyfan64sos

কোনাতেও ভাল কাজ করার কথা মনে হচ্ছে।

— জন

2

জাভাস্ক্রিপ্ট ( ইএস 6) ) 152

একটি ফাংশন, স্ট্রিংগুলি ব্যবহার করে (সংখ্যার সাথে এটি ছোট হওয়া উচিত, তবে জাভাস্ক্রিপ্টে বিট ক্রিয়াকলাপগুলি 32 বিট পূর্ণসংখ্যার মধ্যে সীমাবদ্ধ)।

ফায়ারফক্সে নীচে স্নিপেট ব্যবহার করে পরীক্ষা করুন।

F=(t,L=['10','11'],l=2,R=n=>Math.random()*n|0,a=L[R(l)],b=L[R(l)])=>
   t--?a==b
     ?F(t,L.map(x=>x+R(2)),l)
     :F(t,L,L.push([...a].map((x,p)=>x^b[p]).join('')))
  :L
  
test=_=>O.innerHTML=F(+I.value).join('\n')

#I{width:3em}

<input id=I value=10><button onclick=test()>-></button><pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

1

কে, 45 41 38 বাইট

{x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}

আমার উত্তরের কাঠামোটি @ কার্বিফ্যান6464 এর সাথে বেশ অনুরূপ, তবে স্ট্রিংয়ের পরিবর্তে আমি 1/0 ভেক্টর ব্যবহার করেছি এবং পরিবর্তে তালিকার সাথে সূচি রেখে শর্তযুক্ত ( :[ ; ; ]) এর প্রয়োজনীয়তা এড়িয়ে চলেছি ।

কয়েকটি রান:

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0 0
 1 1 1 1
 0 1 1 1)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 0 0)

  {x{(x,,~=/t;{x,1?2}'x)@~/t:2?x}/1,'!2}3
(1 0 0
 1 1 0
 0 1 0
 1 1 0)

সম্পাদনা:

প্রাথমিক মহাবিশ্ব তৈরির আরও কমপ্যাক্ট উপায় সহ চারটি বাইট সংরক্ষণ করা:

1,'!2     / new
(1 0;1 1) / old

Edit2:

আমি ভুলে গেছি যে "চয়ন করুন" তার সঠিক যুক্তি হিসাবে একটি তালিকা নিতে পারে:

  2?"abcd"
"dc"
  2?"abcd"
"cc"
  2?"abcd"
"ca"

তাই আমি এর কিছু অংশ সহজ করতে পারি। ক্রেডিট যেখানে এটি নির্ধারিত আছে, কির্বি আমার আগে এই কৌশলটি পেয়েছিল।

2?x    / new
x@2?#x / old

— JohnE
সূত্র

1

ডাং, কখনও কখনও আমি মনে করি আমি কে জানি, তারপরে আমি আপনার উত্তরগুলি দেখতে পাচ্ছি ...: ও

— kirbyfan64sos

আমি মনে করি এই সমাধানটি অবশ্যই একটি দলের প্রচেষ্টা হিসাবে গণ্য হয়েছে!

— 14

1

জাভাস্ক্রিপ্ট, 241 233 বাইট

এ রকম দীর্ঘ।

a=[[1,0],[1,1]];for(b=prompt();b--;)if(c=a.length,d=a[c*Math.random()|0],e=a[c*Math.random()|0],d+""==e+"")for(f=0;f<c;f++)a[f].push(2*Math.random()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}alert(a.join("\n"));

— SuperJedi224
সূত্র

ক্লোজার সংকলক এটি 8 বাইট সংরক্ষণ করে সংকুচিত করেছে

— গুস্তাভো রডরিগস

216 বাইট

for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{for(h=0,g=[];h<d.length;)g.push(d[h]^e[h++]);a.push(g)}}alert(a.join("\n"))

:, সময়ের পছন্দসই আউটপুট 3/5 উত্পাদন করে।

— ইসমাইল মিগুয়েল

217 বাইট:,

for(b=prompt(a=[[1,0],[1,1]]),R=Math.random;b--;){c=a.length;d=a[c*R()|0];e=a[c*R()|0];if(d+""==e+"")for(f=0;f<c;f++)a[f].push(2*R()|0);else{g=[];for(h=0;h<d.length;h++)g.push(d[h]^e[h]);a.push(g)}}alert(a.join("\n"))

90% সময় কাজ করে।

— ইসমাইল মিগুয়েল

1

টি-এসকিউএল (2012+), 1019

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

বাইনারি / পূর্ণসংখ্যার রূপান্তরগুলি পরিচালনা করতে আমাকে বেশ কয়েকটি স্কেলার ফাংশন তৈরি করতে হয়েছিল (বাইটগুলির মধ্যে 513)। Aপূর্ণসংখ্যা থেকে কিছুটা স্ট্রিংয়ে যায়। Bবিপরীত না।

CREATE FUNCTION A(@ BIGINT)RETURNS VARCHAR(MAX)AS
BEGIN
DECLARE @S VARCHAR(MAX);
WITH R AS(SELECT @/2D,CAST(@%2 AS VARCHAR(MAX))M
UNION ALL
SELECT D/2,CAST(D%2 AS VARCHAR(MAX))+M
FROM R
WHERE D>0)SELECT @S=M FROM R WHERE D=0
RETURN @S
END
CREATE FUNCTION B(@ VARCHAR(MAX))RETURNS BIGINT AS
BEGIN
DECLARE @I BIGINT;
WITH R AS(SELECT CAST(RIGHT(@,1)AS BIGINT)I,1N,LEFT(@,LEN(@)-1)S
UNION ALL 
SELECT CAST(RIGHT(S,1)AS BIGINT)*POWER(2,N),N+1,LEFT(S,LEN(S)-1)
FROM R
WHERE S<>''
)SELECT @I=SUM(I)FROM R
RETURN @I
END

তারপরেও পদ্ধতি রয়েছে। @Cপদক্ষেপের সংখ্যা

DECLARE @C INT=9
DECLARE @ TABLE(S VARCHAR(MAX))
DECLARE @R VARCHAR(MAX)
INSERT @ VALUES('10'),('11')
WHILE(@C>=0)
BEGIN
SET @C-=1
SELECT @R=CASE WHEN MAX(S)=MIN(S)THEN''ELSE RIGHT(REPLICATE('0',99)+dbo.A(dbo.B(MAX(S))^dbo.B(MIN(S))),LEN(MAX(S)))END
FROM(SELECT TOP 2S,ROW_NUMBER()OVER(ORDER BY(SELECT\))N FROM @,(VALUES(1),(1),(1))D(D)ORDER BY RAND(CAST(NEWID()AS VARBINARY(50))))A
IF @R=''UPDATE @ SET S=CONCAT(S,ROUND(RAND(CAST(NEWID() AS VARBINARY(50))),0))
ELSE INSERT @ VALUES(@R)
END
SELECT * FROM @

দশ হাজার পুনরাবৃত্তি প্রায় 2 মিনিট সময় নেয় এবং 9991 সারি ফেরত দেয়

1001001100110
1101001001110
0111100100101
1111100001011
1111001010011
0110101001101
...
1110101000100
1111011101100
1100001100010
0110010001001
1110100010100

— MickyT
সূত্র

0

পাইথ - 37 বাইট

স্পষ্টত, স্রেবুডোকোড অনুসরণ করে। সম্ভবত অনেক গল্ফ করতে পারেন।

KPP^,1Z2VQ=K?m+dO1KqFJ,OKOKaKxVhJeJ;K

এটি এখানে অনলাইনে চেষ্টা করে দেখুন ।

— Maltysen
সূত্র

3

O2পরিবর্তে আপনার প্রয়োজন O1। O1আপনাকে পরিসীমা থেকে একটি এলোমেলো নম্বর দেয় U1 = [0]।

— জাকুবে

2

সুতরাং আপনি সর্বদা একটি সংযোজন 0।

— জাকুবে

0

গণিত, 106 বাইট

Nest[If[Equal@@#,Map[#~Append~RandomInteger[]&],Append[BitXor@@#]]&[#~RandomChoice~2]@#&,{{1,0},{1,1}},#]&

— alephalpha
সূত্র

0

পার্ল, 102

#!perl -p
@l=qw(10 11);$_=$l[rand@l]^$l[rand@l],$_|=y//0/cr,@l=/1/?(@l,$_):map{$_.~~rand 2}@l for 1..$_;$_="@l"

আমাকে চেষ্টা করুন ।

— nutki
সূত্র

0

আর, 186

L=list(0:1,c(1,1))
if(t>0)for(t in 1:t){A=sample(L,1)[[1]]
B=sample(L,1)[[1]]
if(all(A==B)){L=lapply(L,append,sample(0:1, 1))}else{L=c(L,list(as.numeric(xor(A,B))))}}
L

এখানে কোন মায়াবী কিছু নেই। tআর কনসোলে মান লিখুন এবং স্ক্রিপ্টটি চালান। এটি "গল্ফ" আর কোড করা কঠিন তবে এখানে আরও পাঠযোগ্য সংস্করণ:

L <- list(0:1, c(1, 1))
if(t > 0) {
  for(t in 1:t) {
    A <- sample(L, 1)[[1]]
    B <- sample(L, 1)[[1]]
    if (all(A == B)) {
      L <- lapply(L, append, sample(0:1, 1))
    } else {
      L <- c(L,list(as.numeric(xor(A, B))))
    }
  }
}
L

— shadowtalker
সূত্র

আপনি sampleএকটি ভেরিয়েবল বরাদ্দ করে বেশ কয়েকটি অক্ষর সংরক্ষণ করতে পারেন । যেমন s=sample, তারপরে নমুনার চেয়ে এস ব্যবহার করুন s দুর্ভাগ্যক্রমে আমি মনে করি আপনার এলোমেলো একটি বিট সংযোজনের পদ্ধতিটি lapplyশেষ হবে তালিকার সমস্ত আইটেমের সাথে একটি করে এলোমেলো নমুনা যুক্ত হবে। lapply(L,function(x)append(x,sample(0:1,1)))কাজ করার জন্য প্রদর্শিত হয়, কিন্তু একটি ব্যয়। আপনি প্রতিস্থাপন করতে পারেন যা as.numericদিয়ে 1*কিছুটা ফিরে পাওয়া উচিত।

— মিকিটি

উভয় পয়েন্টে ভাল ক্যাচ, এবং একটি দুর্দান্ত জবরদস্তি কৌশল

— শ্যাডটলকার

এছাড়াও কেবল আপনার গণনা শেষ হয়েছে লক্ষ্য। আমি এটা 168 ব্যবহার এই

— MickyT

0

রুবি, 82

বেশ সোজা-এগিয়ে। অন্যান্য অ-গল্ফিং ভাষার সাথে তুলনা করাতে রুবি তার বড় স্ট্যান্ডার্ড লাইব্রেরির সাথে বেশ ভাল করেছে বলে মনে হচ্ছে।

->t{l=[2,3]
t.times{a,b=l.sample 2
a.equal?(b)?l.map!{|x|x*2+rand(2)}:l<<(a^b)}
l}

টি = 101010 এর জন্য নমুনা আউটপুট:

[9, 15, 6, 13, 5, 12, 10, 11, 5, 4, 15, 13, 2, 7, 11, 9, 3, 3, 8, 6, 3, 13, 13, 12, 10, 9, 2, 4, 14, 9, 9, 14, 15, 7, 10, 4, 10, 14, 13, 7, 15, 7]

— blutorange
সূত্র