नया आदेश # 2: मेरा रास्ता बदलो

Question

परिचय (नजरअंदाज किया जा सकता है)

अपने नियमित क्रम (1, 2, 3, ...) में सभी सकारात्मक संख्याओं को डालना थोड़ा उबाऊ है, है ना? इसलिए यहां सभी सकारात्मक संख्याओं के क्रमपरिवर्तन (फेरबदल) के आसपास चुनौतियों की एक श्रृंखला है। यह इस श्रृंखला की दूसरी चुनौती है। यहां पहली चुनौती मिल सकती है ।

इस चुनौती में, हम प्राकृतिक संख्याओं को फिर से व्यवस्थित करने के लिए ग्रे कोड का उपयोग करते हैं। एक ग्रे कोड, या "प्रतिबिंबित बाइनरी कोड" एक द्विआधारी एन्कोडिंग है इस तरह से कि दो क्रमिक मान केवल एक बिट में भिन्न होते हैं। इस एन्कोडिंग का एक व्यावहारिक अनुप्रयोग इसे रोटरी एनकोडर में उपयोग करना है , इसलिए "टर्न माई वे" का मेरा संदर्भ है ।

ध्यान दें कि यह एन्कोडिंग स्वतंत्रता की कुछ डिग्री छोड़ देता है। उदाहरण के लिए, बाइनरी 1100 का अनुसरण करते हुए, चार संभावित निम्नलिखित कोड हैं: 1101, 1110, 1000 और 0100। यही कारण है कि मैं $a(n)$ को सबसे छोटे के रूप में परिभाषित करूंगा , पहले इस्तेमाल किए गए मूल्य जो बाइनरी एन्कोडिंग में केवल एक वर्ण को अलग करता है। यह क्रम A163252 से मेल खाता है ।

चूंकि यह एक "शुद्ध अनुक्रम" चुनौती है, कार्य उत्पादन के लिए है $a(n)$ के लिए एक दिया $n$ इनपुट, जहां के रूप में $a(n)$ है A163252 ।

कार्य

पूर्णांक इनपुट $n$ को देखते हुए , पूर्णांक प्रारूप ( बाइनरी प्रारूप में नहीं ) में $a(n)$ आउटपुट ।

$a(n)$ के रूप में कम से कम सकारात्मक पूर्णांक अनुक्रम ऐसा है कि में पहले होने वाली नहीं परिभाषित किया गया है$a(n-1)$ और$a(n)$ केवल एक बिट में मतभेद है जब द्विआधारी में लिखा है।

नोट: 1-आधारित अनुक्रमण यहाँ माना जाता है; आप 0-आधारित अनुक्रमण का उपयोग कर सकते हैं, इसलिए $a(0) = 1; a(1) = 3$ , आदि कृपया अपने उत्तर में इसका उल्लेख करें यदि आप इसका उपयोग करना चाहते हैं।

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

Input | Output
--------------
1     | 1
5     | 4
20    | 18
50    | 48
123   | 121
1234  | 1333
3000  | 3030
9999  | 9997

नियम

• इनपुट और आउटपुट पूर्णांक हैं (आपके प्रोग्राम को कम से कम इनपुट और आउटपुट का समर्थन करना चाहिए 1 से 32767 तक की सीमा में)
• अमान्य इनपुट (0, फ़्लोट्स, स्ट्रिंग्स, नकारात्मक मान, आदि) अप्रमाणित आउटपुट, त्रुटियों या (बिना परिभाषित) व्यवहार को जन्म दे सकता है। में A163252 , $a(0)$ इस चुनौती के लिए 0. के रूप में परिभाषित किया गया है, हम इस पर ध्यान नहीं देगा।
• डिफ़ॉल्ट I / O नियम लागू होते हैं।
• डिफ़ॉल्ट कमियां निषिद्ध हैं।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है

अंतिम नोट

निम्नलिखित संबंधित (लेकिन बराबर नहीं) पीपी और सीजी प्रश्न देखें:

• अगला ग्रे कोड ढूँढना (बाइनरी में इनपुट और आउटपुट)
• लंबाई n के सभी ग्रे कोड जनरेट करें

Answer 1

स्टैक्स , 19 17 बाइट्स

êÑ{╚α8è╙mc┼σ▀»É▲ü

इसे चलाएं और डीबग करें

यह हार्डकोड बिट इंडेक्स इटरेशन के कारण निर्दिष्ट डोमेन के बाद कुछ बिंदु पर काम करना बंद कर देता है। (32767)

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

z0,         push an empty array, literal zero, and the input, in that order
             - the zero represents the last calculated value in the sequence
             - the array contains all the previous ones
D           repeat the rest of the program n times (from input)
  +         append the last calculated value to the array
  17r       [0 .. 16] (these are the bit indices necessary to cover the input range)
  {|2nH|^m  calculate candidate values; previous value with each of these bits toggled 
  n-        remove all values previously calculated
  |m        keep the minimum candidate remaining

इसको चलाओ

Comments

आप सबसे कम 05AB1E उत्तर के पीछे 1 बाइट करते हैं। क्या आप इसे और अधिक अनुकूलित करने की योजना बना रहे हैं? अन्यथा मैं केविन के जवाब को स्वीकार करेंगे ...

— agtoever

यदि मेरे पास अवसर है तो मैं आज इस पर काम करूंगा, अगले 14 घंटों में।

— पुनरावर्ती

ठीक है। मैं इसे एक और दिन के लिए खुला रखूंगा। सौभाग्य!

— 19

@agtoever: धन्यवाद। अब मैं काम कर रहा हूँ।

— पुनरावर्ती

बहुत बढ़िया! तुम जीते! बधाई हो!

— २19

Answer 2

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

1 अनुक्रमित।

n=>{for(o=p=[k=1];o[k]|~-(i=p^k)&i?k++:k=o[p=k]=!!n--;);return p}

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

टिप्पणी की गई

n => {                  // n = index of requested term
  for(                  // for loop:
    o =                 //   o = storage object for the terms of the sequence
    p =                 //   p = last term found in the sequence
      [k = 1];          //   k = current term
    o[k] |              //   if k was already encountered
    ~-(i = p ^ k) & i ? //   or (p XOR k) has more than 1 bit set:
      k++               //     increment k
    :                   //   else:
      k = o[p = k]      //     set o[k], set p to k
        = !!n--;        //     stop if n is equal to 0 or set k to 1; decrement n
  );                    // end of for()
  return p              // return p
}                       // end

Comments

TIO पर, मुझे n> ~ 1024 के लिए स्टैक ओवरफ्लो मिलता है। कैसे अबू अन्य वातावरण में उस से निपटने के लिए पर कोई सुझाव? नियम: " आपके कार्यक्रम को कम से कम इनपुट और आउटपुट का समर्थन करना चाहिए, जो कि 1 अप

— टोटक

@ जब भी मैंने इसे गैर-पुनरावर्ती संस्करण में अपडेट किया है।

— अरनुलद

Answer 3

जेली , 26 20 बाइट्स

ṀBLŻ2*^1ị$ḟ⁸Ṃ;
0Ç⁸¡Ḣ

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

एक पूर्ण कार्यक्रम जो एकल तर्क के रूप में n लेता है। सभी परीक्षण मामलों के लिए काम करता है। यह भी ध्यान दें, हालांकि आवश्यक नहीं है, यह n = 0 को संभालता है।

व्याख्या

हेल्पर लिंक: अगले पद और पूर्व-निर्धारण का पता लगाएं

Ṁ              | maximum of list so far
 B             | convert to binary
  L            | number of binary digits
   Ż           | 0..above number
    2*         | 2 to the power of each of the above
      ^        | exclusive or with...
       1ị$     | ... the most recent term in the list so far
          ḟ⁸   | filter out anything used already
            Ṃ  | find the minimum
             ; | prepend to existing list

मुख्य लिंक

0              | start with zero
 Ç             | call the above link
  ⁸¡           | and repeat n times
    Ḣ          | take the last term added

Answer 4

जावा (JDK) , 142 138 124 123 132 130 98 बाइट्स

• आयात के लिए खाते में वृद्धि हुई, @ केविन-क्रूज़सेन के लिए एक बाइट को धन्यवाद दिया
• @ olivier-grégoire के लिए int सरणी के लिए संग्रह को बंद कर दिया

n->{int s[]=new int[9*n],j,k=0;for(;n-->0;s[k=j]++)for(j=0;s[++j]>0|n.bitCount(j^k)>1;);return k;}

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

Comments

मुझे डर है कि आयात को बाइट-काउंट में शामिल करना होगा। आप हालांकि import java.util.*;+ Set s=new HashSet();को गोल्फ कर सकते हैं var s=new java.util.HashSet();। इसके अलावा, आराम करने के लिए golfed जा सकता है: Integer i=0,j,k=0;for(;i++<n;s.add(k=j))for(j=0;s.contains(++j)|i.bitCount(j^k)>1;);return k;। फिर भी अच्छा जवाब है, इसलिए मेरी तरफ से +1। :)

— केविन क्रूज़सेन

के Stackबजाय का उपयोग कर 2 और बाइट्स बचाता है HashSet। बहुत धीमा लेकिन काम करता है!

— डैनियल विदिस

$O(n)$$O(n^n)$

आप अभी भी इसे अपनी पहली टिप्पणी में सुझाए गए दूसरे गोल्फ के साथ 126 बाइट्स में गोल्फ कर सकते हैं । :)

— केविन क्रूज़सेन

98 बाइट्स ।

— ओलिवियर ग्रेगोइरे

Answer 5

पायथन 2 , 81 बाइट्स

1-आधारित अनुक्रमण

l=[0];p=0
exec"n=0\nwhile(p^n)&(p^n)-1or n in l:n+=1\np=n;l+=p,;"*input()
print p

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

---

पायथन 2 , 79 बाइट्स

इसमें बहुत समय लगता है (9999 स्थानीय रूप से 7 मिनट तक चलने के बाद समाप्त नहीं हुआ था)

l={0};p=0;n=input()
exec'p=min({p^2**k for k in range(n)}-l);l|={p};'*n
print p

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

Comments

अधिकतम इनपुट 32767 समर्थित नहीं है (डिफ़ॉल्ट पुनरावृत्ति गहराई सिस्टम-निर्भर नहीं है)।

— एर्ग आउटफोलर

यहां तक ​​कि दिए गए परीक्षण का मामला 9999 समर्थित नहीं है। :)

— डैनियल विदिस

@EriktheOutgolfer ने इसे पुनरावृत्त दृष्टिकोण में बदल दिया, शायद अभी भी TIO पर समय पर समाप्त नहीं होता है, लेकिन स्थानीय रूप से ठीक चलता है।

— १

@ ओह, अकेले टाइमआउट कोई मायने नहीं रखते।

— को आउटगोल्फ

ठंडा! मैंने इसे केवल n = 9999 के लिए आज़माया और यह लगभग एक घंटे के बाद सफलतापूर्वक पूरा हुआ। +1। वाह! ;-)

— agtoever

Answer 6

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 74 बाइट्स

Last@Nest[#~Join~{Min[BitXor[Last@#,2^Range[0,20]]~Complement~#]}&,{0},#]&

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

Answer 7

एपीएल (डायलॉग एक्सटेंडेड) , 46 बाइट्स

{⍵⌷2∘{(~⍺∊⍵)∧1=≢⍸≠⌿↑⌽∘⊤¨⍺,⊃⌽⍵:⍵,⍺⋄⍵∇⍨⍺+1}⍣⍵⊢1}

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

Answer 8

चारकोल , 65 बाइट्स

≔⁰θＦＮ«⊞υθ≔¹ηＷ¬‹θ⊗η≦⊗ηＷ∧›η¹∨¬＆θη№υ⁻θη≧÷²ηＷ№υ⁻｜θη＆θη≦⊗η≔⁻｜θη＆θηθ»Ｉθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁰θ

परिणाम को प्रारंभ में 0।

ＦＮ«

लूप nसमय।

⊞υθ

पिछला परिणाम सहेजें ताकि हम उसका दोबारा उपयोग न करें।

≔¹ηＷ¬‹θ⊗η≦⊗η

पिछले परिणाम में उच्चतम बिट का पता लगाएं।

Ｗ∧›η¹∨¬＆θη№υ⁻θη≧÷²η

जबकि वह बिट 1 से अधिक है, यदि बिट पिछले परिणाम में सेट है, तो उस बिट को घटाकर देखें कि क्या परिणाम एक अनदेखी परिणाम है। यह सुनिश्चित करता है कि संभावित परिणाम मूल्य के आरोही क्रम में आजमाए गए हैं।

Ｗ№υ⁻｜θη＆θη≦⊗η

अब पिछले परिणाम के साथ उस बिट को XOR करने का प्रयास करें, जब तक कि एक अनदेखी परिणाम न मिल जाए, तब तक बिट को दोगुना कर दें। यह उन मामलों को संभालता है जब थोड़ा सेट करने की आवश्यकता होती है, फिर से मूल्य के बढ़ते क्रम में, लेकिन यह भी मामला है जब कम से कम महत्वपूर्ण बिट को टॉगल करने की आवश्यकता होती है, जो पिछले लूप को परीक्षण करने के लिए परेशान नहीं करता है (क्योंकि यह परीक्षण करने के लिए गोल्फ खिलाड़ी है वह यह है)। यदि पिछले लूप को एक अनदेखी परिणाम मिला, तो यह लूप कभी नहीं चलता है; यदि ऐसा नहीं होता तो यह लूप बेकार में उन परिणामों को फिर से बना देगा।

≔⁻｜θη＆θηθ

इसके साथ वास्तव में XORing करके परिणाम को अपडेट करें।

»Ｉθ

लूप के अंत में अंतिम परिणाम आउटपुट करें।

Answer 9

05AB1E , 21 20 18 बाइट्स

ÎFˆ∞.Δ¯θy^bSO¯yå_*

सुंदर अक्षम, इतना बड़ा इनपुट, परिणाम प्राप्त करने में जितना अधिक समय लगता है। इनपुट के लिए भी काम करता है 0, हालांकि।

इसे ऑनलाइन आज़माएं या पहले सत्यापित करें$n$शर्तें ।

स्पष्टीकरण:

Î                # Push 0 and the input
 F               # Loop the input amount of times:
  ˆ              #  Pop the current number and add it to the global_array
  ∞.Δ            #  Inner loop starting at 1 to find the first number which is truthy for:
     ¯θy^        #   XOR the last number of the global_array with the loop-number `y`
         b       #   Convert it to binary
          SO     #   Sum it's binary digits
     ¯yå_        #   Check if the loop-number `y` is NOT in the global_array yet
            *    #   Multiply both (only if this is 1 (truthy), the inner loop will stop)
                 # (after the loops, output the top of the stack implicitly)

Answer 10

हास्केल , 101 बाइट्स

import Data.Bits
(u!n)0=n
(u!n)m|q<-minimum[x|r<-[0..62],x<-[xor(2^r)n],notElem x u]=(n:u)!q$m-1
[]!0

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

यह सिर्फ एक आयात के लिए शर्म की बात है xor, लेकिन मुझे एक अच्छा काम नहीं मिला है। मुझे आश्चर्य है कि क्या पाश को व्यक्त करने का एक बेहतर तरीका है।

Answer 11

आर , 90 बाइट्स

function(n){A=1
while(sum(A|1)<n)A=c(min((x=bitwXor(A[1],2^(0:30)))[x>0&!x%in%A]),A)
A[1]}

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