सबसे छोटी अनदेखी, लेकिन कोई साझाकरण अंक नहीं!

Question

चुनौती

पीपीसीजी में, हमें यकीन है कि हमारे सीक्वेंस पसंद हैं, इसलिए यहां एक मजेदार है ।

के परिभाषित करते हैं a(n)होने के रूप में छोटी से छोटी गैर नकारात्मक पूर्णांक Xहै कि किसी भी बराबर नहीं है a(k)( 0 < k < n), और a(n-1)और Xकिसी भी दशमलव अंक का हिस्सा नहीं है।a(0) = 0

एक इनपुट n > 0, आउटपुट को देखते हुए a(n)।

उदाहरण के लिए, निवेश के लिए n = 13, हमारे पास है a(13) = 20, के बाद से a(12) = 11और 20है सबसे छोटी गैर नकारात्मक पूर्णांक हम अभी तक नहीं देखा है कि के साथ किसी भी दशमलव अंकों के साझा नहीं करता 11।

अनुक्रम

यहां आरंभ करने के लिए पहले 20 शब्द हैं। यह OEIS पर A067581 क्रम है ।

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22, 11, 20, 13, 24, 15, 23, 14, 25

नियम

• इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट करने के लिए ग्रहण किया जा सकता है।
• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
• आप या तो 0-इंडेक्स चुन सकते हैं, जैसा कि मैं अपने उदाहरणों में यहां हूं, या आपके सबमिशन के लिए 1-इंडेक्स। कृपया बताएं कि आप क्या कर रहे हैं।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या हम इनपुट के रूप में n > 1(या n ≥ 2) प्राप्त कर सकते हैं ? (१-इंडेक्सिंग)

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

@EriktheOutgolfer ज़रूर, यह ठीक है। मैं स्पष्ट रूप से कॉपी-पेस्ट करते समय उस बुलेट बिंदु को याद करता था, क्योंकि यह मेरी चुनौतियों का एक मानक है।

— AdmBorkBork

बिखराव साजिश यकीन है कि अच्छा लग रहा है :)

— flawr

Answer 1

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

^{-1 बाइट डेड पॉसम के लिए धन्यवाद}

n=0,
exec"i=0\nwhile set(`i`)&set(`n[-1]`)or i in n:i+=1\nn+=i,;"*input()
print n[-1]

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

Comments

n=0,-1 बाइट के लिए?

— डेड पॉसम

@DeadPossum हाँ, धन्यवाद c:

— रॉड

Answer 2

जाप , 18 बाइट्स

@A{!ZøA «As oX}a}g

इसे ऑनलाइन टेस्ट करें! मैंने अभी-अभी gयहाँ उपयोग की गई सुविधा को जोड़ा है, लेकिन यह कुछ ऐसा है जिसका अर्थ मैं लंबे समय के लिए जोड़ रहा हूँ (और इसने मुझे किनारे पर धकेल दिया, क्योंकि मेरा गैर- gसमाधान 35 बाइट्स के आसपास था)।

व्याख्या

@   A{!ZøA «  As oX}a}g
XYZ{A{!ZøA &&!As oX}a}gU
                           Implicit: U = input integer
   {                 }gU   Starting with [0, 1], return the U'th item generated by
XYZ{                 }     this function: (X = previous item, Y = index, Z = full array)
    A{             }a        Return the smallest non-negative integer A where
      !ZøA &&                  Z does not contain A (A is not yet in the sequence), and
             !As oX            A.toString() does not contain any of the same chars as X.
                           Implicit: output result of last expression

Comments

इससे मेरे सिर में चोट लगी है! लेकिन, तब मैंने जाप्ते में किसी भी फंक्शन मेथड पर मुश्किल से नज़र रखी है।

— झबरा

क्या डिफ़ॉल्ट नियम नहीं है कि आप प्रश्न दिए जाने के बाद भाषा में कुछ जोड़ नहीं सकते? यह हमेशा तुच्छ होगा, क्योंकि हमेशा एक नया बिल्ट-इन बनाया जाता है जो चुनौती को हल करता है, जिससे वे सभी मनमाने ढंग से कम हो जाते हैं।

— trlkly

@trlkly मुझे विश्वास है कि इसे अच्छे निर्णय के भीतर अनुमति दी गई है। बिल्ट-इन I जोड़ा सिर्फ एक जवाब के लिए बहुत अधिक सामान्य-उद्देश्य है। मुझे लगता है कि कोई व्यक्ति सैद्धांतिक रूप से एक अंतर्निहित जोड़ सकता है जो पूरी तरह से चुनौती को हल करता है, लेकिन इस तरह का उत्तर निश्चित रूप से बहुत खराब प्राप्त होगा।

— 13

Answer 3

अजगर , 20 बाइट्स

eu+Gf!|/GT@`eG`T0Q]0

इसे ऑनलाइन आज़माएं! या परीक्षण सूट की कोशिश करो।

Comments

अगर मैं आपके उत्तर के लिए एक परीक्षण सूट जोड़ूं तो मन ?

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

@ Mr.Xcoder आगे बढ़ें।

— लीक नून

Answer 4

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

f 0=0
f x=[i|i<-[1..],all((/=i).f)[1..x-1],all(`notElem`show(f$x-1))$show i]!!0

कोड बहुत ही अक्षम है। बड़े मानों की गणना करने के लिए, अर्थात> 12, f x|x<11=xदोनों लाइनों ( gTIO लिंक में लागू ) के बीच जोड़ें ।

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

Answer 5

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

0 अनुक्रमित।

f=(n,x=[1,p=0])=>n--?f(x[(g=k=>x[k]||(k+'').match(`[${p}]`)?g(k+1):p=k)(0)]=n,x):p

डेमो

f=(n,x=[1,p=0])=>n--?f(x[(g=k=>x[k]||(k+'').match(`[${p}]`)?g(k+1):p=k)(0)]=n,x):p

for(n = 0; n < 50; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Answer 6

हस्क , 18 बाइट्स

!¡₁;0
ḟȯ¬V€d→⁰d-⁰N

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

संपादित करें: +1 बाइट के लिए निश्चित बग।

व्याख्या

हस्क के अंतर्निहित पुनरावृत्ति समारोह ¡के कई अर्थ हैं। यहां, मैं "मौजूदा लोगों से गणना किए गए नए तत्वों को बार-बार जोड़कर अनंत सूची का निर्माण कर रहा हूं"। दूसरी पंक्ति सहायक फ़ंक्शन है जो एक नए तत्व की गणना करता है:

ḟȯ¬V€d→⁰d-⁰N  Takes a list of existing elements, e.g. x = [0,1,...,10]
           N  The positive integers
         -⁰   with elements of x removed:        [11,12,13,...
ḟȯ            Find an element n of this list that satisfies:
        d     Digits of n.
   V          Is any of them
    €         an element of
     d        the digits of
      →⁰      the last element of x?
  ¬           Negate.
              Returns 22.

पहली पंक्ति मुख्य कार्य है:

!¡₁;0  Takes an integer k.
 ¡     Iterate adding new elements to the list
   ;0  [0]
  ₁    using the helper function,
!      take k'th element of result.

Comments

मैंने गोल्फ की भाषा सूची में हस्क जोड़ा है ; कृपया मुझे बताएं कि क्या मुझे कोई विवरण गलत मिला है।

— ETHproductions

Answer 7

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

n!k|r:_<-[j|j<-[1..],all(/=j)k,all(`notElem`show n)$show j]=n:r!(r:k)
(0![]!!)

यह और भी अधिक कुशल होगा यदि दूसरा तर्क !देखा संख्याओं की सूची नहीं होगा बल्कि अनदेखी संख्याओं का होगा। लेकिन मैं अधिक बाइट्स का उपयोग किए बिना ऐसा नहीं कर सकता।

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

Answer 8

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

अभी भी यह नीचे गोल्फ के लिए कमरा - और शायद पुनरावृत्ति का उपयोग करें (इस प्रकार यह तेजी से)।

(For[z={0};i=1,Length@z<#,
For[i=1,!FreeQ[z,i]||!DisjointQ@@IntegerDigits/@{l,i},i++];
z~AppendTo~i;l=Last@z;
];l)&

मूल क्रिया कोड, एक ही मूल विचार के साथ:

MakeSequenceA067581[n_]:=Module[{list={0}, innerCounter=1},

While[Length@list<n,
innerCounter=1;
(* inner loop *)While[Or[MemberQ[list,innerCounter],Intersection[IntegerDigits[Last@list],IntegerDigits[innerCounter]]!={}],innerCounter++];
AppendTo[list,innerCounter];
];
list
]