हाइपरक्यूब पर चलना

Question

मैंने हाल ही में ग्राफ सिद्धांत पर पढ़ा, विशेष रूप से हाइपरक्यूब्स और उन पर पथ के निर्माण के दिलचस्प तरीकों के बारे में सोचा। यहाँ मैं क्या लेकर आया हूँ।

आप जानते होंगे, आप से मिलकर सभी एन-tuples लेने के द्वारा एक n आयामी hypercube निर्माण कर सकते हैं 1और 0कोने के रूप में और कनेक्ट उन्हें, iff वे एक अंक में मतभेद है। यदि आप इन द्विआधारी अंकों को पूर्णांक संख्या के रूप में व्याख्या करते हैं, तो आप अच्छी तरह से संख्यात्मक अंक के साथ एक ग्राफ के साथ समाप्त होते हैं। उदाहरण के लिए n=3:

मान लें कि आप इस हाइपरक्यूब पर चलना चाहते हैं और शीर्ष पर शुरू करना चाहते हैं 0। अब, आप यह कैसे निर्धारित करते हैं कि आप किस शीर्ष पर जाना चाहते हैं? जिस नियम के साथ मैं आया हूं a, आप जिस शीर्ष पर हैं, उसकी संख्या mod(a,n)(शून्य-आधारित अनुक्रमणिका) फ्लिप करें और परिणामी शीर्ष पर जाएं। औपचारिक रूप से इस नियम को पुन: परिभाषित किया जा सकता है

a[m+1] = xor(a[m], 2^mod(a[m],n)).

इस नियम का पालन करके, आप हमेशा क्यूब पर रहेंगे और किनारों के साथ यात्रा करेंगे। परिणामी पथ इस तरह दिखता है

जैसा कि आप देख सकते हैं, आप एक सर्कल में चलेंगे! वास्तव में, सभी आयामों में और सभी शुरुआती बिंदुओं के लिए आपका मार्ग एक लूप में समाप्त हो जाएगा। उदाहरण के लिए n=14और a[0]=0यह इस तरह दिखता है

शौकीन चावला राजदूत के लिए, उसके नियोजित मार्ग की लंबाई काफी महत्वपूर्ण जानकारी है। तो, आपका काम एक फ़ंक्शन या एक प्रोग्राम लिखना है जो कि हाइपरक्यूब आयाम को इनपुट के रूप में nएक प्रारंभिक शीर्ष पर ले a[0]जाता है और परिणामी लूप में कोने की संख्या को आउटपुट करता है।

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

n   a[0]   Output
-----------------
3   0      6
14  0      50
5   6      8
17  3      346

नियम

• मानक खामियों को मना किया जाता है
• आउटपुट / इनपुट किसी भी उपयुक्त प्रारूप में हो सकता है
• आप a[0]एक मान्य शीर्ष मान सकते हैं

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

यदि आपके पास इस विषय पर कोई अतिरिक्त जानकारी है, तो मुझे सुनकर खुशी होगी!

Comments

नियम को देखते हुए a[m+1] = xor(a[m], 2^mod(a[m],n)), यह अप्रासंगिक है यदि कोने हाइपरक्यूब से संबंधित हैं, है ना?

— लुइस मेन्डो

सही। यदि a[m]हाइपरक्यूब पर था, a[m+1]तो भी होगा। और जैसा कि आप a[0]एक मान्य शीर्ष मान सकते हैं , आपको किसी भी हाइपरक्यूब सामान की देखभाल करने की आवश्यकता नहीं है और बस नियम का पालन करें।

— मर्फी

हाइपर चींटियां कहां हैं?

— बैसड्रॉप कंबरवुबवबूब

Answer 1

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

%⁴2*^µÐḶL

दो कमांड-लाइन तर्क देता है।

%⁴2*^µÐḶL        A monadic link. Inputs: a_0. b also taken from command line.
%⁴2*^              Variadic link. Input: a
%⁴                   a modulo b. ⁴ is second input, b.
  2*                 Get 2 to that power
    ^                and bitwise xor with a.
     µ             Start a new, monadic link (input: a_0)
      ÐḶ             All elements of the cycle created when the preceding link
                     is applied repeatedly, starting with a_0.
        L            Length.

इसे यहाँ आज़माएँ ।

Answer 2

हास्केल, 124

import Data.Bits
(y:z:w)%(x:s)|x==y||x==z=[i|(i,r)<-zip[1..]s,r==x]!!0|0<1=w%s
g n=(tail>>=(%)).iterate(\a->xor a$2^mod a n)

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

gवह कार्य है जो उत्तर की गणना करता है। इसे nऔर तब दें a[0]और यह आपको नंबर वापस कर देगा (ध्यान दें कि टाइप अस्पष्टता से बचने के nलिए इसे परिभाषित किया जाना चाहिए Int)।

Answer 3

जावास्क्रिप्ट (ईएस 6), 69 बाइट्स

(n,a)=>{g=m=>m^1<<m%n;for(c=1,b=a;(b=g(g(b)))!=(a=g(a));)c++;return c}

(23, 10) के लिए 18812 रिटर्न।

Answer 4

MATL , 38 37 28 बाइट्स

xi`vt0)2y1G\^Z~yywP=fn~]2M1$

यह भाषा के वर्तमान संस्करण (15.0.0) में काम करता है ।

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

व्याख्या

x       % take first input: n. Delete (gets copied into clipboard G)
i       % take second input: initial value of a
`       % do...while loop
  v     %   concatenate all stack contents vertically
  t0)   %   duplicate. Get last element of that array: current a
  2     %   push 2
  y     %   duplicate second-top element in stack: current a
  1G    %   push first input (n)
  \     %   a modulo n
  ^     %   2 raised to that
  Z~    %   xor of that with current a
  yy    %   duplicate top two elements in stack: array of old a's and new a
  w     %   swap: move array of old a's to top
  P     %   reverse that array. So first entry is most recent a (before current)
  =f    %   indices of old values that equal current value. There may be 0 or 1
  n~    %   is it empty?
]       % if so, continue with a new iteration
2M      % push array of indices. It contains exactly 1 index
1$      % set 1 input for implicit display function, so it only displays the index

Comments

@lirtosiast सच! धन्यवाद। संपादित

— लुइस मेंडो

Answer 5

पायथ, 22 17 बाइट्स

Lx^2%bQbl.uyNuyGE

स्पष्टीकरण:

Lx^2%bQbl.uyNuyGE     Implicit: Q=first line n. E=second line a[0].
Lx^2%bQb              y = lambda b: do one iteration
                      Then
             uyGE     Apply y until a previous result is found.
                      This makes sure we're in the cycle.
         .uyN         Then apply y again until a previous result is found.
                      Keep all intermediate values but not the repeat.
        l             Get the length; i.e. the length of the cycle.

इसे यहाँ आज़माएँ ।