फिर भी अप्रयुक्त जोड़े

Question

चलो सकारात्मक पूर्णांक के एक अनुक्रम को परिभाषित करते हैं। हम पिछले संख्या को दोगुना करने के लिए सम संख्याओं पर अनुक्रम को परिभाषित करेंगे। अनुक्रम के विषम सूचकांक सबसे छोटे धनात्मक पूर्णांक होंगे जो अभी तक अनुक्रम में दिखाई नहीं दे रहे हैं।

यहाँ पहले युगल शब्द हैं।

1,2,3,6,4,8,5,10,7,14,9,18,11,22,12,24,13,26,15,30

आप इसे संक्षिप्त जोड़े (n, 2n) की सूची के रूप में भी सोच सकते हैं जहां n अब तक का सबसे कम अप्रयुक्त सकारात्मक पूर्णांक है।

कार्य

इस क्रम में n n पद की गणना के रूप में संख्या n को देखते हुए ।

यह कोड-गोल्फ है इसलिए आपको अपने स्रोत कोड के आकार को न्यूनतम करने का लक्ष्य रखना चाहिए जैसा कि बाइट्स में मापा जाता है।

OEIS A036552

Comments

तथ्य यह है कि अनुक्रम के विषम सूचकांक सबसे छोटे सकारात्मक पूर्णांक होंगे जो अभी तक अनुक्रम में दिखाई नहीं दे रहे हैं। अप्रासंगिक है, है ना?

— 14

इसके अलावा, क्या जोड़े ?

— 14

@ Adám नहीं यह मामला नहीं है। मुझे यकीन नहीं है कि आपको क्या आभास मिलता है कि शायद मैंने इसे खराब तरीके से कहा है।

— गेहूं जादूगर

@ अनुक्रम के बारे में सोचने का एक और तरीका यह है कि इसमें समसामयिक जोड़े शामिल हैं (n,2n)और प्रत्येक संख्या केवल एक बार दिखाई देती है। बाद वाली बाधा का पालन करते हुए प्रत्येक जोड़ी को सबसे छोटा संभव चुना जाता है।

— मार्टिन एंडर

श्रृंखला के विषम तत्वों का 2-एडिक मूल्यांकन हमेशा भी होता है। किसी के लिए उपयोगी हो सकता है।

— कैलक्यूलेटरफ़्लीन

Answer 1

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

l(a:r)=a:2*a:l[x|x<-r,x/=2*a]
(l[1..]!!)

शून्य आधारित। lवृद्धिशील रूप से शेष पूर्णांक की एक आलसी सूची से अनुक्रम बनाता है।

Answer 2

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

n=>(F=i=>i^n?F(a[b=i&1?2*b:(g=k=>a[k]?g(k+1):k)(1)]=-~i):b)(a={})

कैसे?

हम इस पर नज़र रखते हैं:

• अंतिम सम्मिलित मान b ।
• लुकअप तालिका में पहले से मौजूद सभी मानों में a ।

आंतरिक रूप से, हम 0-आधारित इंडेक्स i का उपयोग कर रहे हैं । अजीब और यहां तक ​​कि व्यवहार इसलिए उलटे हैं:

• विषम स्थिति में, अगला मान बस है 2 * b।

• यहां तक कि पदों में, हम पुनरावर्ती क्रिया का उपयोग ग्राम () और लुकअप तालिका एक छोटी से छोटी मिलान मूल्य पहचानने के लिए:

  (g = k => a[k] ? g(k + 1) : k)(1)

कुछ बाइट्स को बचाने के लिए, मुझे{} इसके बजाय इनिशियलाइज़ किया जाता है 0। यह हमें उपयोग करने के लिए मजबूर करता है:

• i^nक्योंकि मैं मूल्यांकन करता है, जबकि n के साथ तुलना करने के लिए ।({}) ^ n === n({}) - nNaN
• -~iवेतन वृद्धि के लिए , क्योंकि मैं({}) + 1 एक स्ट्रिंग उत्पन्न होगा।

डेमो

let f =

n=>(F=i=>i^n?F(a[b=i&1?2*b:(g=k=>a[k]?g(k+1):k)(1)]=-~i):b)(a={})

for(n = 1; n <= 20; n++) {
  console.log('a[' + n + '] = ' + f(n));
}

Comments

60 बाइट्स

— झबरा

Answer 3

पायथन 3 , 80 72 69 बाइट्स

^{-7 बाइट्स मिस्टर एक्सकोडर की बदौलत !}

f=lambda n:n and[f(n-1)*2,min({*range(n+1)}-{*map(f,range(n))})][n%2]

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

Comments

आप 78 बाइट्स केset(...) लिए `{* ...} के साथ

— रिप्लेस कर सकते हैं

@ Zacharý क्या आप मेरी टिप्पणी पर विश्वास कर रहे थे? यदि हां, तो पायथन 3 का एक सेट {*...}इसके बजाय हो सकता है set(...)।

— श्री Xcoder

मैं बिना सोचे-समझे टिप्पणी कर रहा था, मुझे कुछ ही क्षणों के बाद एहसास हुआ कि {...for...in...}बहुत अधिक बायोस होना चाहिए।

— Zacharý

वास्तव में, यह 4 बाइट्स को बचाएगा, क्योंकि आप इसे दो बार उपयोग करते हैं

— श्री एक्सकोडर

69 बाइट्स। (और यह True1 के लिए उपयोग नहीं करता है )

— गेहूं जादूगर

Answer 4

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

Jḟ⁸ḢðḤṭṭ
0Ç¡Ḋị@

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

Answer 5

मैथिक्स , 56 53 बाइट्स

^{-3 बाइट्स धन्यवाद जंगवान मिन !}

(w={};Do[w~FreeQ~k&&(w=w~Join~{k,2k}),{k,#}];w[[#]])&

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

OEIS लिंक में दिए गए Mathematica अभिव्यक्ति के आधार पर।

Comments

इसके अलावा 53 बाइट्स:Nest[k=0;If[#~FreeQ~++k,#~Join~{k,2k},#]&,{},#][[#]]&

— जुंगह्वान मिन

Answer 6

PHP , 64 बाइट्स

for(;$argn-$i++;)if($i&$$e=1)for(;${$e=++$n};);else$e*=2;echo$e;

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

PHP , 77 बाइट्स

for(;$argn-$i++;$r[]=$e)if($i&1)for(;in_array($e=++$n,$r););else$e*=2;echo$e;

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

PHP , 78 बाइट्स

for(;$argn-$i++;)$e=$r[]=$i&1?end(array_diff(range($i,1),$r?:[])):2*$e;echo$e;

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

Answer 7

PHP, 56 बाइट्स

while($$n=$i++<$argn)for($n*=2;$i&$$k&&$n=++$k;);echo$n;

PHP, 75 72 बाइट्स

for($a=range(1,$argn);$i++<$argn;)$a[~-$n=$i&1?min($a):2*$n]=INF;echo$n;

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

Answer 8

05AB1E , 16 15 14 बाइट्स

1 अनुक्रमित।
इस तथ्य का उपयोग करता है कि अनुक्रम में विषम सूचकांक में तत्वों का द्विआधारी प्रतिनिधित्व शून्य संख्या में समाप्त होता है: A003159 ।

Lʒb1¡`gÈ}€x¹<è

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

व्याख्या

L                 # range [1 ... input]
 ʒ      }         # filter, keep only elements whose
  b               # ... binary representation
   1¡             # ... split at 1's
     `gÈ          # ... ends in an even length run
         €x       # push a doubled copy of each element in place
           ¹<è    # get the element at index (input-1)

Answer 9

पायथन 2 , 59 51 49 बाइट्स

f=lambda n,k=2:2/n%-3*(1-k)or f(n+~(k&-k)%-3,k+1)

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

पृष्ठभूमि

प्रत्येक सकारात्मक n पूर्णांक को n = 2 ^{o (n)} c (n) के रूप में विशिष्ट रूप से व्यक्त किया जा सकता है , जहां c (n) विषम है।

चलो ⟨a _n ⟩ _{n> 0} चुनौती कल्पना से अनुक्रम हो।

हम दावा करते हैं कि, सभी सकारात्मक पूर्णांकों के लिए n , o (a _2n-1 ) सम है। चूंकि ओ (एक _{2 एन} ) = ओ (2 ए _{2 एन -1} ) = ओ (एक _{2 एन -1} ) + 1 , यह दावा करने के बराबर है कि ओ ( _{2 एन} ) हमेशा विषम होता है।

दावे को झूठा मानें और 2m-1 को अनुक्रम का पहला विषम सूचकांक मान लें, जैसे o ( _2m-1 ) विषम है। ध्यान दें कि यह 2m अनुक्रम का पहला सम अनुक्रमणिका है जैसे o ( _2m-1 ) सम है।

ओ (एक _{2 एम -1} ) विषम है और 0 हां, तो भी है एक _{2 एम -1} से विभाज्य है 2 । परिभाषा के अनुसार, एक _{2 एम -1} है सबसे छोटी सकारात्मक पूर्णांक अभी तक अनुक्रम में प्रदर्शित नहीं हो जिसका अर्थ है कि, एक _{2 एम -1} / 2 के समक्ष पेश किया जाना चाहिए। चलो कश्मीर (प्रथम) के सूचकांक होना एक _{2 एम -1} / 2 में एक ।

चूँकि o (a _k ) = o (a _2m-1 /2) = o (a _2m-1 ) - 1 सम है, n का तात्पर्य यह है कि k विषम है। बदले में, इसका मतलब है कि एक _{k + 1} = 2 ए _{कश्मीर} = एक _{2 एम -1} , की परिभाषा का खंडन एक _{2 एम -1} ।

यह काम किस प्रकार करता है

अभी आने वाला है

Answer 10

आर , 70 69 65 बाइट्स

function(n){for(i in 2*1:n)F[i-1:0]=which(!1:n%in%F)[1]*1:2
F[n]}

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

एक अनाम फ़ंक्शन जो एक तर्क लेता है। या तो Fचूक FALSEया 0एल्गोरिथ्म सही ढंग से आकलन करता है कि कोई भी सकारात्मक पूर्णांक अभी तक अनुक्रम में नहीं है।

एल्गोरिथ्म एक में जोड़े उत्पन्न करता है forनिम्नलिखित तरीके (जहां में पाश iसे चला जाता है 2के लिए 2nद्वारा 2):

           which(!1:n%in%l)[1]     # the missing value
                              *1:2 # keep one copy the same and double the next
l[i-1:0]=                         # store into l at the indices i-1 and i

Answer 11

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

g x=[2*g(x-1),[a|a<-[1..],a`notElem`map g[1..x-1]]!!0]!!mod x 2

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

यह हास्केल के आलसी मूल्यांकन का पूरी तरह से दुरुपयोग करता है।

Answer 12

पर्ल 6 , 50 बाइट्स

{(1,{@_%2??2*@_[*-1]!!first *∉@_,1..*}...*)[$_]}

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

• 1, { ... } ... *एक आलसी जनित अनंत अनुक्रम है, जहां पहले के बाद प्रत्येक शब्द ब्रेस-सीमांकित कोड ब्लॉक द्वारा प्रदान किया जाता है। चूंकि ब्लॉक @_सरणी को संदर्भित करता है, इसलिए यह उस सरणी में संपूर्ण वर्तमान अनुक्रम प्राप्त करता है।
• यदि तत्वों की वर्तमान संख्या विषम है ( @_ % 2), तो हम एक समान-अनुक्रमित तत्व उत्पन्न कर रहे हैं, इसलिए अगला तत्व हमारे द्वारा अब तक किए गए अंतिम तत्व से दोगुना है 2 * @_[*-1]:।
• अन्यथा, हमें पहला सकारात्मक पूर्णांक मिलता है जो अभी तक अनुक्रम में दिखाई नहीं देता है first * ∉ @_, 1..*:।
• $_बाहरी फ़ंक्शन का तर्क है। यह फ़ंक्शन के रिटर्न वैल्यू को देते हुए अनंत अनुक्रम में अनुक्रमित होता है।

Answer 13

गणितज्ञ, 82 बाइट्स

(s={};a=1;f=#;While[f>0,If[s~FreeQ~a,s~AppendTo~{a,2a}];a++;f--];Flatten[s][[#]])&

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

Comments

Mathematica में 58 बाइट्स (हालांकि मुझे शायद एक अलग उत्तर पोस्ट करना चाहिए क्योंकि विचार बहुत अलग है)।

— नजगन

क्या आपने OEIS लिंक से कॉपी किया है?

— J42161217

मैंने इसे कार्य को फिट करने और अधिक गोल्फ होने के लिए संशोधित किया, लेकिन यह कम या ज्यादा OEIS लिंक के समान है।

— नॉटगन

@ यदि आप चाहते हैं और लेखक को श्रेय दें तो एक नया उत्तर न दें

— 15:42 पर J42161217

Answer 14

के , 27 बाइट्स

*|{x,*(&^x?!y;|2*x)2!y}/!2+

1 अनुक्रमित। इसे ऑनलाइन आज़माएं!

कामों के (!y)^xबजाय &^x?!yभी उपयोग करना ।

Answer 15

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 82 बाइट्स

x=>{int y=1;for(var s="";x>2;x-=2)for(s+=2*y+":";s.Contains(++y+""););return x*y;}

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

-6 बाइट्स @ASCIIOnly को धन्यवाद!

Comments

C # 8 अब के लिए ऑनलाइन दुभाषियों पर आम होने के लिए बहुत नया हो सकता है, इस तथ्य में जोड़ा गया कि csi एक मोनो चीज़ है इसलिए आपको मोनो को लागू करने और इसे एक स्थिर बिल्ड में जोड़ने के लिए इंतजार करना होगा (यदि यह hasn है) t पहले से ही)

— ASCII-only

दुर्भाग्य से यह नहीं आसान के लिए जाँच करने के लिए है इस सी # में

— ASCII-केवल

इसे शुरू करने के लिए उपयोग करें? लेकिन हाँ, सीधी सी बात नहीं लगती। docs.microsoft.com/en-us/dotnet/api/…

— dana

86? - नहीं लगता कि :s की जरूरत है क्योंकि यह सूची में सबसे बड़ी संख्या होगी

— ASCII- केवल

इसके अलावा 2.0>>2f

— दाना

Answer 16

क्लोजर, 102 बाइट्स

#(nth(loop[l[0 1 2 3]i %](if(= i 0)l(recur(conj l(*(last l)2)(nth(remove(set l)(range))0))(dec i))))%)

nअनुक्रम को बनाने के लिए बार-बार बताता है और nवें आइटम को लौटाता है , 1-अनुक्रमित।

Answer 17

रूबी, 60 बाइट्स

->n,*a{eval"v+=1while a[v];a[v]=a[2*v]=v+v*n%=2;"*(n/2+v=1)}

0 अनुक्रमित। हम n/2+1हर बार दो मान उत्पन्न करते हैं और उनके सूचकांकों में एक सरणी को पॉप करके स्टोर करते हैं। v+v*n%2उत्पादन देता है, या तो vया v*2की समता के आधार पर n।

Answer 18

माणिक , 49 बाइट्स

->n{*s=t=0;s|[t+=1]==s||s<<t<<t*2until s[n];s[n]}

[0] से शुरू करें, जोड़े को सरणी में जोड़ें जब तक कि हमारे पास कम से कम n + 1 तत्व न हों, तब n + 1th (1-आधारित) लें

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

Answer 19

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

एक पुनरावृत्त समाधान।

n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

कम गोल्फ वाला

n=>{
  s = {}; //hashtable for used values
  for(i=0; n; )
  {
    if ( ! s[++i] )
    {
      s[i*2] = 1; // remember i*2 is already used
      if (--n)
        if (--n)
          0;
        else
          result = i*2;
      else
        result = i;
    }
  }
  return result;  
}

परीक्षा

F=
n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

for (a=1; a < 50; a++)
  console.log(a,F(a))

Answer 20

जेली , 13 12 10 बाइट्स

ḤRọ2ḂĠZFị@

यह मेरे पायथन उत्तर से अवलोकन का उपयोग करता है ।

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

यह काम किस प्रकार करता है

ḤRọ2ḂĠZFị@  Main link. Argument: n

Ḥ           Unhalve; yield 2n.
 R          Range; yield [1, ... , 2n].
  ọ2        Compute the order of 2 in the factorization of each k in [1, ..., 2n].
    Ḃ       Bit; compute the parity of each order.
     G      Group the indices [1, ..., 2n] by the corresponding values.
      Z     Zip/transpose the resulting 2D array, interleaving the indices of 0
            with the indices of 1, as a list of pairs.
       F    Flatten. This yields a prefix of the sequence.
        ị@  Take the item at index n.