एक तार में इलेक्ट्रॉन उछलते हुए

Question

एक "तार" की कल्पना करें जिसमें nरिक्त स्थान हों। आगे कल्पना कीजिए कि उस तार में "इलेक्ट्रॉन" हैं। ये इलेक्ट्रॉन केवल एक इकाई समय के लिए रहते हैं। तार में कोई भी रिक्त स्थान जो एक इलेक्ट्रॉन के बिल्कुल समीप होता है, एक इलेक्ट्रॉन बन जाता है। गेम ऑफ लाइफ शब्दावली में, यह है B1/S।

उदाहरण के लिए, यह 62 की अवधि के साथ लंबाई 10 का एक तार है।

नियम

• इनपुट, nएक एकल, धनात्मक पूर्णांक है।
• आउटपुट एक एकल पूर्णांक होना चाहिए जो लंबाई n के एक तार की अवधि को दर्शाता है।
• प्रारंभिक अवस्था तार के एक छोर पर एक एकल इलेक्ट्रॉन है।
• अवधि में आवश्यक रूप से प्रारंभिक राज्य शामिल नहीं है । कुछ लंबाई प्रारंभिक अवस्था में कभी नहीं लौटती हैं, लेकिन वे सभी आवधिक हैं।
• एक स्थिर तार (यानी, इलेक्ट्रॉनों के बिना एक) की अवधि 1 है।
• सीमा की स्थिति आवधिक नहीं हैं । यही है, तार किसी भी तरह से toroidal नहीं है।

परीक्षण के मामलों

इस सूची का निर्माण करने के लिए विशेष धन्यवाद। (मैंने इसे n = 27 तक सत्यापित किया है।)

1 1
2 2
3 1
4 6
5 4
6 14
7 1
8 14
9 12
10 62
11 8
12 126
13 28
14 30
15 1
16 30
17 28
18 1022
19 24
20 126
21 124
22 4094
23 16
24 2046
25 252
26 1022
27 56
28 32766
29 60
30 62
31 1
32 62
33 60
34 8190
35 56
36 174762
37 2044
38 8190
39 48
40 2046
41 252
42 254
43 248
44 8190
45 8188

: आप 21 के माध्यम से यहां मेरे खेल-ऑफ-द लाइफ-esque सिम्युलेटर के साथ n = 2 के लिए परीक्षण मामलों को देख सकते हैं जीवन के भिन्न रूप ।

---

EDIT: यहाँ अनुक्रम A268754 के रूप में प्रकाशित किया गया है !

Comments

वे सभी आवधिक हैं और यह अवधि अपर-बाउंड है 2^n-1, क्योंकि यह "वायर" के संभावित नॉनज़रो स्टेट्स की संख्या है

— लुइस मेंडो

@LuisMendo: वास्तव में, ऊपरी सीमा कम होती है क्योंकि इलेक्ट्रॉन कभी भी आसन्न नहीं होते हैं। वास्तव में कितना कम है, मुझे नहीं पता।

— एल'एंडिया स्ट्रैटन

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 का एक तार सबसे छोटा उदाहरण है।

— एल'एंडिया स्ट्रैटन

अधिक दृढ़ता से, इलेक्ट्रॉनों को विषम और समान स्थितियों के बीच वैकल्पिक किया जाता है, इसलिए यह अवधि अधिकतम 2 ^ (n / 2 + 1) है।

— xnor

Answer 1

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

(जिस्ट को डाउनलोड करने और दौड़ने से पहले कोड का निरीक्षण करने के लिए स्वतंत्र महसूस करें।) आप कल्पना की जा रही n को बढ़ाने / घटाने के लिए + और - कुंजी दबा सकते हैं।

---

और अंत में, इस संख्या अनुक्रम को आगे बढ़ाने में रुचि रखने वालों के लिए, यहां एक पठनीय संस्करण है (इसका उपयोग उपरोक्त परीक्षण मामलों को उत्पन्न करने के लिए किया गया था):

# 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

Comments

मैं जानता हूँ कि यह एक वर्ष से अधिक हो गया है, लेकिन अगर HashLife का उपयोग कर सभी पर यह भी बढ़ा दी हैं मैं सोच रहा हूँ

— ASCII-केवल

Answer 2

गणितज्ञ, 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} *)

Answer 3

पायथन 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, अद्यतन को kएक के साथ छोड़ दिया /2और एक के साथ दाएं स्थानांतरित XOR के रूप में लिया जा सकता है *2, फिर nबाइट्स के रूप में छोटा कर दिया जाता है %2**n।

Answer 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)

मूल रूप से मेरे पाइथ के उत्तर के समान है , लेकिन पायथन में कुछ अंतर्निहित कार्यों की कमी के कारण इसे कुछ हद तक अनुकूलित किया है।

Ungolfed संस्करण:

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)

Answer 5

पायथ, 39 36 बाइट्स

L++Zmx@[e-mail].[,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] ) ) )

परीक्षण सूट में बहुत अधिक समय लगता है कि सर्वर इसे मार देगा, इसलिए आपको नियमित कार्यक्रम का उपयोग करना होगा और एक-एक करके परीक्षण करना होगा, या इसे स्थापित करने के लिए पाइथ (यदि आपने नहीं किया है) और एक स्क्रिप्ट का उपयोग करें।

Answer 6

जेली, 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 ^{n पर} लागू किया जाता है , जो एक वैध स्थिति को एन्कोड नहीं करता है। हालांकि, ((2 ^एन ) 2) ^ (2 ^एन × 2))% 2 ^एन = (2 ^{एन - 1} + 2 ^{एन + 1} )% 2 ^एन = 2 ^{एन - 1} , जो संभावित शुरुआती राज्यों में से एक है।

चूंकि हम 2 ^एन + 1 बार लूप करते हैं, इसलिए हम दो बार राज्य का सामना करने की गारंटी देते हैं, जिससे लूप डिटेक्शन सफल हो जाता है।

Answer 7

CJam, 41 34 31 27 25 बाइट्स

3 बाइट बचाने के लिए डेनिस के लिए धन्यवाद। अपने जेली जवाब से एक विचार उधार एक और 4 बचा लिया।

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

इसका परीक्षण यहां करें।

व्याख्या

मैं तार को केवल एक पूर्णांक के रूप में प्रस्तुत कर रहा हूं (जिनके बिट्स इलेक्ट्रॉनों की स्थिति दर्शाते हैं) बिट्स की वास्तविक सूची का उपयोग करने के बजाय। राज्य काफी सरल बिटवाइस संगणना के माध्यम से अद्यतन किया जाता है।

उस अवधि को खोजने के लिए जब हम स्टैक पर सभी मध्यवर्ती परिणाम एकत्र करते हैं, 2 ^n-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.

Answer 8

जावास्क्रिप्ट (ईएस 6) 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>

Answer 9

हास्केल, 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]

(नोट: हग दुभाषिया वाले फोन से पोस्ट किया गया, जो पूर्ण रूप से चित्रित नहीं है, इसलिए टाइपो हो सकता है।)

Answer 10

MATL , 38 37 36 35 बाइट्स

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

यह एक लूप का उपयोग करता है जो नए राज्यों की गणना करता रहता है जब तक कि नया राज्य किसी भी पूर्ववर्ती के बराबर न हो। प्रत्येक राज्य शून्य और लोगों का एक सदिश है। ये वैक्टर बढ़ते 2D सरणी की पंक्तियों के रूप में संग्रहीत हैं।

प्रत्येक नए राज्य की गणना अनुक्रम के साथ वर्तमान स्थिति को हल करके [1,0,1], केवल केंद्रीय भाग को रखते हुए, और 0किसी भी प्रविष्टि के लिए सेट किया जाता है जो कि नहीं है 1।

EDIT (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)

Answer 11

पर्ल 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]ऑप का उपयोग करके सूची को कम करता है। उदाहरण के लिए [+] @listयोग होगा@list
• Rएक मेटा-ऑप है जो एक ऑप को दिए गए तर्कों को उलट देता है। उदाहरण के लिए 1 R- 32 में परिणाम होगा।

Answer 12

सी ++, 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);
}

C ++ के बिटसेट के लिए अच्छा अभ्यास; और ब्रेंट के चक्र का पता लगाने वाले एल्गोरिथ्म के बारे में एक महान शिक्षा (जैसा कि @orlp द्वारा उपयोग किया जाता है)

Answer 13

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

आप इसे यहाँ आज़मा सकते हैं ।

Answer 14

पायथ, 29 बाइट्स

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

• इसे ऑनलाइन आज़माएं!
• परीक्षण सूट

एल्गोरिथ्म का उपयोग करता है a(n+1) = ((a(n) << 1)^(a(n) >> 1)) % (2 ** N)।

Answer 15

रूबी, 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}