এমন একটি "তার" কল্পনা করুন যাতে nস্পেস রয়েছে। আরও কল্পনা করুন যে সেই তারে "ইলেকট্রন" রয়েছে। এই ইলেক্ট্রনগুলি কেবলমাত্র এক ইউনিটের জন্য বেঁচে থাকে। ঠিক একটি ইলেক্ট্রন সংলগ্ন তারের কোনও স্থান ইলেক্ট্রন হয়ে যায়। গেম অফ লাইফের পরিভাষায়, এটি B1/S।

উদাহরণস্বরূপ, 62 পিরিয়ড সহ এটি 10 দৈর্ঘ্যের একটি তারের।

বিধি

ইনপুট,, nএকটি একক, ধনাত্মক পূর্ণসংখ্যা।
আউটপুট অবশ্যই একক পূর্ণসংখ্যার দৈর্ঘ্যের তারের সময়কাল নির্দেশ করে।
আরম্ভের অবস্থাটি তারের এক প্রান্তে একক ইলেকট্রন।
পিরিয়ডটি অগত্যা শুরুর রাষ্ট্রটিকে অন্তর্ভুক্ত করে না । কিছু দৈর্ঘ্য কখনই প্রারম্ভিক অবস্থায় ফিরে আসে না, তবে সেগুলি সমস্ত পর্যায়ক্রমিক।
একটি স্ট্যাটিক তার (যেমন, ইলেকট্রনবিহীন একটি) এর সময়কাল 1 থাকে।
সীমানা পরিস্থিতি পর্যায়ক্রমিক হয় না । যে, তারের কোনওভাবেই টরওডিয়াল নয়।

পরীক্ষার মামলা

এই তালিকাটি তৈরির জন্য অর্পলকে বিশেষ ধন্যবাদ। (আমি এটি এন = 27 পর্যন্ত যাচাই করেছি))

আপনি আমার গেম অফ অফ লাইফ-এস্কিও সিমুলেটারটি দিয়ে এখানে n = 2 থেকে 21 এর জন্য পরীক্ষার কেসগুলি দেখতে পান: জীবনের বিভিন্নতা ।

সম্পাদনা: সিকোয়েন্সটি এ 268754 হিসাবে প্রকাশিত হয়েছে !

code-golf cellular-automata

— এল'ইনিয়া স্টারম্যান
সূত্র

এগুলির সবগুলি পর্যায়ক্রমিক এবং পিরিয়ডটি উপরের সীমানা দ্বারা আবদ্ধ 2^n-1, কারণ এটি "তারের" এর সম্ভাব্য নানজারো রাষ্ট্রগুলির সংখ্যা

— লুইস মেন্ডো

@ লুইসমেডো: আসলে, উপরের গণ্ডি কম কারণ ইলেকট্রনগুলি কখনও সংলগ্ন হয় না। ঠিক কতটা কম, জানি না।

— এল'েন্ডিয়া স্টারম্যান

The period does not necessarily include the starting state. Some lengths never return to the starting state, but all of them are periodic.

আপনার কি উদাহরণ আছে?

— edc65

@ edc65: 5 দৈর্ঘ্যের একটি তারতমতম উদাহরণ।

— এল'ইনিয়া স্টারম্যান

1

আরও দৃ strongly়তার সাথে, বৈদ্যুতিনগুলি বিজোড় এবং এমনকি পজিশনের মধ্যে বিকল্প, সুতরাং সময়কাল সর্বোচ্চ 2 ^ (এন / 2 + 1) হয়।

— xnor

10

পাইথন 2, 148 142 87 বাইট

n=input()
p=l=1
t=1
h=2
while t!=h:
 if p==l:t,l,p=h,0,p*2
 h=h/2^h*2%2**n;l+=1
print l

ব্রেন্টের চক্র সনাক্তকরণ অ্যালগরিদম ব্যবহার করে এবং এইভাবে দ্রুত দ্রুত চলে।

আমি পাইথনে একটি অ্যানিমেশনও লিখেছি (2 এবং 3 কাজ উভয়)। এটি pygletচালানো প্রয়োজন। আপনি চালিয়ে অ্যানিমেশনটি দেখতে পারেন:

python -m pip install --user pyglet
curl -s https://gist.githubusercontent.com/orlp/f32d158130259cbae0b0/raw/ | python

(চালানোর আগে বাক্সটি ডাউনলোড করতে এবং কোডটি নির্দ্বিধায় নির্দ্বিধায় অনুভব করুন)) এন ভিজ্যুয়ালাইজডকে বাড়ানো / হ্রাস করতে আপনি + এবং - কীগুলি টিপতে পারেন ।

এবং পরিশেষে, এই সংখ্যা ক্রমটি আরও অন্বেষণ করতে আগ্রহীদের জন্য, এখানে একটি পাঠযোগ্য সংস্করণ (এটি উপরের পরীক্ষার কেসগুলি তৈরি করতে ব্যবহৃত হয়েছিল):

# Brent's cycle detection, modified from wikipedia.
def electron_period(n):
    wire_mask = (1 << n) - 1
    power = lam = 1
    tortoise, hare = 1, 2
    while tortoise != hare:
        if power == lam:
            tortoise = hare
            power *= 2
            lam = 0
        hare = ((hare << 1) ^ (hare >> 1)) & wire_mask
        lam += 1
    return lam

— orlp
সূত্র

আমি জানি এটি এক বছর কেটে গেছে, তবে আমি ভাবছিলাম যে হ্যাশলাইফ ব্যবহার করা যদি একেবারেই বাড়িয়ে দিতো

— ASCII-

7

গণিত, 127 বাইট

p@n_:=Tr[#2-#]&@@Position[#,Last@#]&@NestWhileList[1~Table~n~ArrayPad~1*18~CellularAutomaton~#&,{1}~ArrayPad~{1,n},Unequal,All]

ব্যাখ্যা

বিধি 18 :

{0,0,0} -> 0
{0,0,1} -> 1
{0,1,0} -> 0
{0,1,1} -> 0
{1,0,0} -> 1
{1,0,1} -> 0
{1,1,0} -> 0
{1,1,1} -> 0

পরীক্ষার মামলা

p/@Range[10]
(* {1,2,1,6,4,14,1,14,12,62} *)

— njpipeorgan
সূত্র

7

পাইথন 2, 68 বাইট

f=lambda n,k=1,l=[]:k in l and-~l.index(k)or f(n,k/2^k*2%2**n,[k]+l)

চক্র সনাক্তকরণ আরও ভাল হতে পারে, তবে পুনরাবৃত্তির ধাপটি দুর্দান্ত।

k -> k/2^k*2%2**n

একটি বাইনারি সংখ্যা হিসাবে অ্যারে প্রতিনিধিত্বমূলক দ্বারা k, আপডেট এর XOR যাও গ্রহণ করে কাজ করা যেতে পারে kএক স্থানান্তরিত অবশিষ্ট /2এবং সঙ্গে এক অধিকার *2, তারপর ছিন্ন nযেমন বাইট %2**n।

— xnor
সূত্র

4

পাইথন 3 2, 134 121 118 বাইট

Q=input()
h=[]
n=[0,1]+Q*[0]
while n not in h:h+=[n];n=[0]+[n[d]^n[d+2] for d in range(Q)]+[0]
print len(h)-h.index(n)

মূলত আমার পাইথের উত্তরের মতোই , তবে পাইথনে কিছু বিল্ট-ইন ফাংশন না থাকার কারণে এটি কিছুটা মানিয়ে নিয়েছিল ।

অবরুদ্ধ সংস্করণ:

length = input()
history = []
new = [0] + [1] + length*[0]
while new not in history:
    history += [new]
    new = [0] + [new[cell]^new[cell+2] for cell in range(length)] + [0]
print len(history) - history.index(new)

— busukxuan
সূত্র

4

পাইথ, 39 36 বাইট

L++Zmx@bd@bhhdQZ-lJ.uyN.[,Z1ZQ)xJyeJ

কোনও কনফিগারেশন পুনরাবৃত্তি হওয়ার ঠিক আগে পর্যন্ত পুনরাবৃত্তি করতে "সংশ্লেষিত স্থির-পয়েন্ট" ফাংশনটি ব্যবহার করে এবং সমস্ত মধ্যবর্তী কনফিগারেশনগুলিকে তালিকাগুলির তালিকা হিসাবে ফিরিয়ে দেয়। এটি কাজ করে কারণ নিয়মগুলি নির্বিচারক এবং পরবর্তী প্রজন্মের কনফিগারেশন বর্তমান কনফিগারেশনের একটি কাজ। এর অর্থ হ'ল একবার একই কনফিগারেশনটি আবার উপস্থিত হলে অটোমেটা একটি চক্র সম্পন্ন করে।

(চক্রের শেষ পুনরাবৃত্তি) পৌঁছানোর পরে, এটি পরবর্তী ইতিহাস (যা একটি চক্রের সূচনা কনফিগারেশন) পাওয়ার জন্য, "ইতিহাস" তালিকার শেষ উপাদানটিতে একটি শেষ বারের পরের-জেন ফাংশনটিকে কল করে এবং ইতিহাসে এর সূচকটি সন্ধান করুন। এখন সময়কালটি দৈর্ঘ্যটি (চক্র সমাপ্তির 1+ সূচক) মাইনাসটি চক্র শুরুর সূচকে।

পাইথোনিক সিউডোকোডে:

                  Z = 0
                  Q = eval(input())
L                 def y(b):                # generates next-gen from current(param)
  ++Zm                return [Z] + map(    # adds head zero padding
    x@bd@bhhd             lambda d: b[d] ^ b[1+ 1+ d],  # xor the states of adjacent cells
    Q                     range(Q))        # implicit range in map
    Z                     + [Z]            # adds end zero padding
-lJ.uyN.[,Z1ZQ)   J = repeatTilRecur(lambda N,Y:y(N), padRight([Z,1],Z,Q)); print( len(J) -
                  # N:value; Y:iteration count
  JxJyeJ              J.index( y( J[-1] ) ) )

পরীক্ষার স্যুটটিতে সার্ভার এটি মেরে ফেলবে এমন অনেক বেশি সময় নেয়, সুতরাং আপনাকে নিয়মিত প্রোগ্রামটি ব্যবহার করতে হবে এবং একে একে পরীক্ষা করতে হবে, বা পাইথ ইনস্টল করতে হবে (যদি না থাকে) এবং এটি পরীক্ষা করার জন্য একটি স্ক্রিপ্ট ব্যবহার করতে হবে।

— busukxuan
সূত্র

4

জেলি, 19 18 17 বাইট

H^Ḥ%®
2*©Ç‘Ð¡UµiḢ

এই কোড প্রথম নির্ণয় 2 ^এন রাজ্যের, তাই এটি বিশেষ করে ফাস্ট বা মেমরি দক্ষ না ...

এটি অনলাইন চেষ্টা করুন! বা প্রথম 16 পরীক্ষার কেস যাচাই করুন ।

বিকল্প সংস্করণ, 13 বাইট (প্রতিযোগী নয়)

এই চ্যালেঞ্জ পরবর্তী পোস্টের জেলি এর সংস্করণগুলিতে অন্তর্নির্মিত লুপ সনাক্তকরণ রয়েছে, এটি একটি সমাধান সক্ষম করে যা উভয় খাটো এবং আরও দক্ষ।

H^Ḥ%®
2*©ÇÐḶL

এটি সহজেই শেষ পরীক্ষার কেস পরিচালনা করে। এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

2*©Ç‘Ð¡UµiḢ    Main link. Input: n (integer)

2*             Compute 2 ** n.
  ©            Store the result in the register.
     Ð¡        Do the following:
   Ç             Apply the helper link, which updates the state, ...
    ‘            2 ** n + 1 times.
               Collect all 2 ** n + 2 intermediate results in a list.
       U       Upend; reverse the list of results.

        µ      Begin a new, monadic chain. Argument: R (list of results)
          Ḣ    Yield and remove the first element of R (final state).
         i     Find its first index in the remainder or R.
               This is the length of the loop.

H^Ḥ%®        Helper link. Argument: s (state, integer)

H            Halve s. This yields a float, but ^ will cast to integer.
  Ḥ          Double s.
 ^           Compute (s ÷ 2) ^ (s × 2).
    ®        Retrieve the value stored in the register (2 ** n).
   %         Compute ((s ÷ 2) ^ (s × 2)) % (2 ** n).

মনে রাখবেন যে সহায়তার লিঙ্কটি প্রথম পুনরাবৃত্তিতে 2 ^এন প্রয়োগ করা হয়েছে , যা কোনও বৈধ রাষ্ট্রকে এনকোড করে না। তবে, ((2 ^এন ÷ 2) ^ (2 ^এন × 2))% 2 ^এন = (2 ^{এন - 1} + 2 ^{এন + 1} )% 2 ^এন = 2 ^{এন - 1} , যা সম্ভাব্য আরম্ভের অন্যতম একটি অবস্থা।

যেহেতু আমরা 2 ^এন + 1 বার লুপ করেছি, তাই লুপ সনাক্তকরণকে সফল করে তুলতে আমাদের একটি রাষ্ট্রের সাথে দু'বার মুখোমুখি হওয়ার গ্যারান্টিযুক্ত।

— ডেনিস
সূত্র

3

সিজেম, 41 34 31 27 25 বাইট

3 বাইট সঞ্চয় করার জন্য ডেনিসকে ধন্যবাদ। তার জেলি উত্তর থেকে ধার নেওয়া আরও 4 টি সংরক্ষণ করেছে।

2ri#_){__4*^2/W$%}*]W%(#)

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

ব্যাখ্যা

আমি তারের বিটগুলির প্রকৃত তালিকা ব্যবহার না করে কেবল একটি পূর্ণসংখ্যা হিসাবে (যার বিটগুলি ইলেকট্রনের অবস্থান নির্দেশ করে) হিসাবে প্রতিনিধিত্ব করছি। মোটামুটি সরল বিটওয়াইজ গণনার মাধ্যমে রাজ্যটি আপডেট করা হয়।

আমরা স্ট্যাকের সমস্ত মধ্যবর্তী ফলাফল সংগ্রহ করার সময়কালটি সন্ধান করতে, 2 ^{এন -1} +1 পদক্ষেপের জন্য সিমুলেশনটি চালনা করি এবং তারপরে চূড়ান্ত রাষ্ট্রের শেষ সংঘটিত (প্লাস 1) থেকে উপাদানগুলির সংখ্যা হিসাবে সময়কাল নির্ধারণ করি।

কোডটির একটি বিচ্ছেদ এখানে রয়েছে:

2ri#   e# Compute 2^n. This has a 1 in the n+1-th bit and zeroes below it. This is
       e# itself not a valid state but will be turned into 2^(n-1) by the first
       e# update.
_)     e# Duplicate and increment to get number of steps to simulate.
{      e# Repeat that many times...
  __   e#   Duplicate the last state twice.
  4*   e#   Multiply by 4, shifting all bits to the left by two positions.
  ^    e#   XOR - we only keep keep those cells where we have exactly one 1-bit
       e#   between both copies, i.e. those that neighboured a single electron
       e#   but shifted up by one position. We don't need handle the survival rule
       e#   explicitly, since electrons can never be adjacent in the first place.
  2/   e#   Divide by 2 shifting all bits back to the right again.
  W$   e#   Copy the initial number 2^n.
  %    e#   Modulo - this simply sets the first bit to 0.
}*
]      e# Wrap all states in an array.
W%     e# Reverse it.
(      e# Pull off the latest state.
#      e# Find its position in the remainder of the array.
)      e# Increment.

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

2

জাভাস্ক্রিপ্ট (ES6) 99 104

n=>eval("a=[...Array(n)];k={};for(a[0]=i=1;!k[a=a.map((v,i)=>v?0:a[i-1]^a[i+1])];k[a]=i++);i-k[a]")

পরীক্ষা

f = n=>eval("a=[...Array(n)];k={};for(a[0]=i=1;!k[a=a.map((v,i)=>v?0:a[i-1]^a[i+1])];k[a]=i++);i-k[a]")

console.log = x => O.textContent += x + '\n';

;[...Array(45)].map((_, i) => console.log(++i + ' ' + f(i)))

<pre id=O></pre>

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

— edc65
সূত্র

2

হাস্কেল, 170 বাইট

x!pসীমাতে থাকলে সূচক পিতে উপাদানটি দেয়, অন্যথায় 0. nপরবর্তী পদক্ষেপ গণনা করে। ধাপ g iদেয় i। c xসময় দিয়ে দেয়, যদি শুরু হয় x। fসব একসাথে আবৃত।

n x|l<-length x-1=[mod(x!(p-1)+x!(p+1))2|p<-[0..l],let y!q|q<0=0|q>=l=0|1<2=y!!p]
c x=[i-j|i<-[1..],j<-[0..i-1],let g k=iterate n x!!k,g i==g j]!!0
f n=c$1:map(*0)[2..n]

(দ্রষ্টব্য: হগস দোভাষী রয়েছে এমন ফোন থেকে পোস্ট করা, যা পুরো বৈশিষ্ট্যযুক্ত নয়, তাই টাইপস থাকতে পারে))

— মাইকেল ক্লিন
সূত্র

2

এমএটিএল , 38 37 36 35 বাইট

1Oi(`t0Y)5BX+8L)1=vt6#Xut0)=fdt?w}A

এটি এমন একটি লুপ ব্যবহার করে যা নতুন রাজ্যগুলির পূর্বের যে কোনওটির সমান না হওয়া অবধি নতুন রাজ্যগুলির গণনা চালিয়ে যায়। প্রতিটি রাজ্য হ'ল শূন্য এবংগুলির একটি ভেক্টর। এই ভেক্টরগুলি ক্রমবর্ধমান 2D অ্যারের সারি হিসাবে সংরক্ষণ করা হয়।

প্রতিটি নতুন রাষ্ট্রের গণনা বর্তমান রাষ্ট্রটিকে অনুক্রমের সাথে সংশ্লেষ করে [1,0,1], কেবলমাত্র কেন্দ্রীয় অংশ রেখে এবং 0যে কোনও প্রবেশিকাতে সেট করা যায় না 1।

সম্পাদনা (মে 13, 2016) নিম্নলিখিত লিঙ্কে কোডটি উত্তরটি লেখার পরে ভাষায় প্রবর্তিত পরিবর্তনগুলির সাথে সামান্য পরিবর্তন করা হয়েছে

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

1Oi(            % create initial vector [1,0,0,...,0], with size equal to input
`               % do...while loop
  t0Y)          %   duplicate. Get last row of array: most recent vector
  5BX+8L)       %   compute new vector by convolving the most recent one
                %   with [1,0,1] and keeping only the central part
  1=            %   set ones to 1, rest to 0
  v             %   append to 2D array
  t6#Xu         %   compute vector of unique numeric labels, so that equal rows
  t0)=f         %   indices of entries whose value equals that of the last entry.
                %   This will contain the index of the last entry and possibly
                %   another index, in which case we've found a repetition
  d             %   this will either be empty (which is falsy) or contain the
                %   period, which is a nonzero number (and thus truthy)
  t?            %   duplicate. If non-empty (and nonzero)
    w           %     swap to put the 2D-array at the top of the stack. This is
                %     falsy, because it contains at least one zero, even in the
                %     n=1 case (the array is initiallized to 0 in that case)
                %     So the loop will terminate, with the period left on the stack
  }             %   else
    A           %     this transforms the empty array at the top of the stack
                %     into a true value, so that the loop will continue
                %   implicitly end if
                % implicitly end loop
                % implicitly display stack contents (period)

— লুইস মেন্ডো
সূত্র

1

পার্ল 6, 81 বাইট

{my@h=my$w=2;@h.push($w=$w/2+^$w*2%2**$_)while 2>@h.grep($w);[R-] @h.grep($w,:k)}

কিছুটা প্রসারিত এবং ungolfed

-> $n {
    my @history = my $wire = 2;
    while 2 > @history.grep($wire) {
        @history.push($wire = $wire/2 +^ $wire*2 % 2**$n)
    }
    [R-] @history.grep($wire,:k)
}

কিছুটা ব্যাখ্যা:

[op]বিকল্প ব্যবহার করে তালিকা হ্রাস করে reduces উদাহরণস্বরূপ [+] @listযোগফল হবে@list
Rএমন একটি মেটা-অফ যা কোনও বিকল্পকে দেওয়া আর্গুমেন্টকে বিপরীত করে। উদাহরণস্বরূপ 1 R- 32 ফলাফল হবে।

— হট
সূত্র

1

সি ++, 211 বাইট

Golfed

#include <bitset>
#include <cstdio>
#define B std::bitset<1<<10>
B m,t(1),h(2);int main() {int p,l;for(scanf("%d",&p);p--;m.set(p));
for(p=l=1;t!=h;h=(h>>1^h<<1)&m,l++)p==l?t=h,p*=2,l=0:0;return !printf("%d",l);}

পঠনযোগ্যতার জন্য যুক্ত হোয়াইটস্পেস সহ

#include <bitset>
#include <cstdio>
#define B std::bitset<1<<10>
B m,t(1),h(2);
int main() {    
    int p,l;
    for(scanf("%d",&p);p--;m.set(p));
    for(p=l=1;t!=h;h=(h>>1^h<<1)&m,l++)p==l?t=h,p*=2,l=0:0;    
    return !printf("%d",l);
}

সি ++ এর বিটসেটের জন্য ভাল অনুশীলন; এবং ব্রেন্টের চক্র সনাক্তকরণ অ্যালগরিদম সম্পর্কে একটি দুর্দান্ত শিক্ষা শিখছে (@ অরপাল দ্বারা ব্যবহৃত হিসাবে)

— tucuxi
সূত্র

0

পাইথ, 95 বাইট

J.[ZQ[1)K_1=bYW<K0=NY aN?hJZ?htJ1ZFTr1tlJ aN?@JTZ?x@JhT@JtT1Z) aN?eJZ?@J_2 1Z=JN=KxbJ abJ;-tlbK

আপনি এটা চেষ্টা করে দেখতে পারেন এখানে ।

— Rhyzomatic
সূত্র

0

পাইথ, 29 বাইট

J^2QL%x/b2*b2JK.uyN1;-lKxKyeK

অ্যালগরিদম ব্যবহার করে a(n+1) = ((a(n) << 1)^(a(n) >> 1)) % (2 ** N)।

— ফুটো নুন
সূত্র

0

রুবি, 72 বাইট

বেনামে ফাংশন।

->n{s=[w=1];c=p
(j=s.index w=w*2%2**n^w/2
j ?c=s.size-j:s<<w)while !c
c}

— মান কালি
সূত্র

বৈদ্যুতিন একটি তারের মধ্যে বাউন্স