गोलमबोल का लच्छेदार क्रम

Question

OEIS में परिवर्तन होता है पर (A111439) Golomb के अनुक्रम । जैसा कि गोलमब के अनुक्रम में A(n)बताया गया है कि कितनी बारn अनुक्रम में दिखाई देता है। लेकिन इसके अलावा, कोई भी लगातार दो संख्याएँ समान नहीं हो सकती हैं। अनुक्रम का निर्माण करते समय, A(n)हमेशा सबसे छोटे धनात्मक पूर्णांक के रूप में चुना जाता है जो इन दो गुणों का उल्लंघन नहीं करता है। लगातार समान संख्याओं को रोकने के कारण, श्रृंखला बढ़ने के साथ-साथ थोड़ा ऊपर-नीचे हो जाती है। यहां पहले 100 शब्द हैं:

1, 2, 3, 2, 3, 4, 3, 4, 5, 6, 5, 6, 5, 6, 7, 6, 7, 8, 7, 8, 9, 8, 9, 8, 9, 
10, 9, 10, 9, 10, 11, 10, 11, 10, 11, 10, 11, 12, 11, 12, 13, 12, 13, 12, 
13, 12, 13, 12, 13, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 16, 15, 
16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 18, 17, 18, 17, 18, 19, 18, 19, 18, 
19, 18, 19, 18, 19, 18, 19, 20, 19, 20, 21, 20, 21, 20, 21, 20, 21, 20

पहले 10,000 नंबरों की पूरी सूची OEIS पर देखी जा सकती है ।

चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो गणना करता है A(n), दिया जाता हैn । nयह 1सुनिश्चित करने के लिए आधारित है कि स्व-वर्णन करने वाली संपत्ति काम करती है।

नियम

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

n     A(n)
1     1
4     2
10    6
26    10
100   20
1000  86
1257  100
10000 358

Comments

सम्बंधित।

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

मैं उत्सुक था इसलिए मैंने इसका रेखांकन किया । Neato।

— इंजीनियर टोस्ट

@EngineerToast का ग्राफ OEIS पर भी है। मैं देख रहा था कि आप अपने ग्राफ़ में "रन" कितने समय तक देखते हैं और यह वास्तव में अजीब है । (यह ग्राफ दिखाता है कि Nअंतिम घटना के बाद कितनी बार प्रकट होता है, N-1जिससे विकट संख्या घट जाती है N।)

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

Answer 1

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

f k|k<4=k|p<-k-1=[n|n<-[1..],n/=f p,sum[1|a<-[1..p],f a==n]<f n]!!0

एक फ़ंक्शन को परिभाषित करता है f । इसे ऑनलाइन आज़माएं!यह बहुत धीमा है, f 15टीआईओ पर बार-बार गणना करना ।

व्याख्या

बस परिभाषा के साथ जा रहा है: हर चरण में, न्यूनतम सकारात्मक संख्या चुनें nजो बाधाओं को संतुष्ट करता है (पिछली प्रविष्टि के बराबर नहीं है, और f nअभी तक नहीं हुआ है)।

f k             -- Define f k:
 |k<4=k         -- If k < 4, it's k.
 |p<-k-1=       -- Otherwise, bind k-1 to p,
  [n|           -- compute the list of numbers n where
   n<-[1..],    -- n is drawn from [1,2,3,...],
   n/=f p,      -- n is not equal to f p, and
   sum[1|       -- the number of
    a<-[1..p],  -- those elements of [1,2,3,...,p]
    f a==n]     -- whose f-image equals n
   <f n]        -- is less than f n,
  !!0           -- and take the first element of that list.

Answer 2

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

मेरे लिए एक अतिरिक्त 1 बाइट पाने के लिए मार्टिन एंडर को धन्यवाद!

Last@Nest[{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&,{},#]&

nइनपुट के रूप में एक सकारात्मक पूर्णांक ले रहा है और एक सकारात्मक पूर्णांक लौटा रहा है। हम पहले की पूरी सूची का निर्माण करते हैंn इस अनुक्रम तत्वों की , फिर Lastतत्व लेते हैं । सूची का निर्माण खाली सूची के साथ शुरू किया गया है {}और nएक पंक्ति में फ़ंक्शन समय के साथ (इसके माध्यम से) संचालित किया गया हैNest ) ।

विचाराधीन फ़ंक्शन वह है {##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&, जो अनुक्रम मानों (अनिवार्य रूप से ##&@@#) की एक आंशिक सूची लेता है और इसके लिए अगले मूल्य को जोड़ता है। अगले मूल्य की गणना शुरू करने के साथ की जाती है x=1, फिर बार-बार बदलने xसे x+1जब तक कि शर्त x==Last@#||#~Count~x==#[[x]]पूरी नहीं हो जाती है - दूसरे शब्दों में, यदि या तो xपिछला तत्व है, या फिर xपहले से ही सूची में सही संख्या है। यह फ़ंक्शन कुछ त्रुटियों को फैलाता है, क्योंकि (उदाहरण के लिए) हमें xप्रारंभिक सूची के वें तत्व को कॉल नहीं करना चाहिए {}; हालाँकि, मान सभी सही हैं।

Answer 3

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

13 बाइट्स के लिए कई सुधारों के लिए @ डेनिस का धन्यवाद!

s=0,1,2,3
exec't=1\nwhile t==s[-1]or s.count(t)/s[t]:t+=1\ns+=t,;'*input()
print s[-4]

यह कार्यक्रम बहुत अच्छी तरह से आगे बढ़ता है: यह उन मूल्यों की सूची का ट्रैक रखता है जो अब तक निर्धारित है, और अगले मूल्य को जोड़ते हुए दिखता है। यह 1सूची के अंत में संलग्न करने की कोशिश करता है यदि यह हो सकता है; यदि नहीं, तो यह तब 2तक कोशिश करता है जब तक कि कुछ की अनुमति न हो।

अब, हम परिणाम के लिए बीजारोपण करके शुरू 1,2,3करते हैं 1,2,3। यह पहले से गणना किए गए मूल्यों की सूची के साथ किसी भी समस्या से बचने के लिए किया जाता है: मैं अनुमान लगाता हूं कि यदि nकम से कम है 4तो a(n)सख्ती से कम है n। (इस कार्यक्रम में, s[n]इसके बराबर है a(n)। हमारी सूची वास्तव में होने के [0,1,2,3]कारण आरंभिक है क्योंकि सूची 0पायथन में -indexed हैं । इसलिए उदाहरण के लिए।a(1)=s[1]=1 , औरa(2)=s[2]=2 )

तो, मान लें कि हम यह निर्धारित करने का प्रयास कर रहे हैं s[m], जिसका अर्थ है कि हमारी सूची में पहले से ही शामिल है s[0], s[1], ..., s[m-1]। हम शुरू करेंगे t=1और सेट करने का प्रयास करेंगे s[m]=1। जब वह काम नहीं करता है, तो हम जाकर t=2सेट करने की कोशिश करते हैं s[m]=2। हर बार जब हम वेतन वृद्धि करते हैं t, तो हम यह जांचते हैं कि क्या s.count(t)==s[t]... लेकिन दाहिने हाथ की ओर एक त्रुटि पैदा नहीं होगी, जब तक कि हमें कभी भी उतनी ऊंचाई पर नहीं जाना पड़े t=m। अनुमान कहता है कि हमें कभी भी ऐसा नहीं करना है, क्योंकि पहला मूल्य जो हम गणना करते हैं वह वास्तव में है s[4]।

यह कार्यान्वयन अनुक्रम के 3 और मानों की तुलना में इसकी आवश्यकता है। यदि nहै तो उदाहरण के लिए 8, यह s[11]मान देने से पहले गणना करेगा s[8]।

मुझे अनुमान का प्रमाण देखकर खुशी होगी। मेरा मानना ​​है कि यह (मजबूत?) प्रेरण द्वारा सिद्ध किया जा सकता है।

संपादित करें: यहाँ अनुमान का एक प्रमाण है । हम वास्तव में बयान के एक छोटे से मजबूत रूप को साबित करते हैं, क्योंकि इसमें कोई अतिरिक्त काम शामिल नहीं है।

प्रमेय: सभी के लिए nअधिक से अधिक या इसके बराबर 4, अवधि a(n)कम से कम या बराबर है (n-2)।

पत्र (मजबूत प्रेरण द्वारा): (आधार n=4): बयान के लिए सच है n=4, के बाद से a(4) = 2 = 4-2।

अब मान a(k)से कम या बराबर है k-2सभी के लिए kसे 4के माध्यम से n, समावेशी (और मान लेते हैं nकम से कम है 4)। विशेष रूप से, इसका मतलब है कि अनुक्रम के सभी पिछले शब्द सबसे अधिक थे (n-2)। हमें यह दिखाने की जरूरत है कि a(n+1)यह सबसे ज्यादा होगा (n-1)। अब, परिभाषा के अनुसार, a(n)सबसे छोटा धनात्मक पूर्णांक है जो किसी भी स्थिति का उल्लंघन नहीं करता है, इसलिए हमें केवल उस मूल्य को दिखाने की आवश्यकता है(n-1) किसी भी स्थिति का उल्लंघन नहीं करेगा।

मान (n-1)"कोई लगातार दोहराता" स्थिति का उल्लंघन नहीं करेगा, क्योंकि प्रेरण परिकल्पना द्वारा पिछली प्रविष्टि अधिकतम थी (n-2)। और यह " a(m)समय की संख्या mप्रकट होने वाली स्थिति है " का उल्लंघन नहीं करेगा , जब तक (n-1)कि पहले से ही a(n-1)समय पर नहीं पहुंचा गया था । लेकिन मजबूत प्रेरण धारणा के द्वारा, (n-1)पहले से पहुँच गया है 0बार, और a(n-1)के बराबर नहीं है 0के बाद से a(m)सभी के लिए सकारात्मक है m।

इसलिए इच्छानुसार a(n+1)कम या बराबर है n-1 = (n+1)-2। QED।

Answer 4

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

Ṭ€S<;1Tḟ®Ḣ©ṭ
⁸Ç¡Ṫ

पिछले तीन परीक्षण मामले TIO के लिए बहुत अधिक हैं। मैंने स्थानीय रूप से 1000 और 1257 का सत्यापन किया है ।

इसे ऑनलाइन आज़माएं! या पहले 100 शब्दों को सत्यापित करें ।

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

⁸Ç¡Ṫ          Main link. No arguments.

⁸             Yield [].
 Ç¡           Execute the helper link n times (where n is an integer read from
              STDIN), initially with argument [], then with the previous return
              value as argument. Yield the last return value.
              Tail; yield the last element of the result.


Ṭ€S<;1Tḟ®Ḣ©ṭ  Helper link. Argument: A (array)

Ṭ€            Untruth each convert each k into an array of k-1 zeroes and one 1.
  S           Sum; column-wise reduce by +, counting the occurrences of all
              between 1 and max(A).
   <          Compare the count of k with A[k] (1-indexed), yielding 1 for all
              integers that still have to appear once or more times.
    ;1        Append a 1 (needed in case the previous result is all zeroes).
      T       Truth; find all indices of ones.
       ḟ®     Filter-false register; remove the value of the register (initially 0)
              from the previous result.
         Ḣ©   Head copy; yield the first (smallest) value of the result and save
              it in the register.
           ṭ  Tack; append the result to A.

Answer 5

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

f=lambda n,k=1:n*(n<4)or map(f,range(n)+k*[n-1]).count(k)<f(k)or-~f(n,k+1)

यह @ मैथमंडन के एल्गोरिदम का पुनरावर्ती कार्यान्वयन है ।

कार्यान्वयन हे (पागल) है : इनपुट 9 स्थानीय रूप से 2 सेकंड, इनपुट 10 52 सेकंड और इनपुट 11 17 मिनट और 28 सेकंड लेता है । हालांकि, यदि लंबोदा के बजाय एक नियमित कार्य के रूप में घोषित किया जाता है, तो परीक्षण मामलों को सत्यापित करने के लिए मेमोइज़ेशन का उपयोग किया जा सकता है।

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

ध्यान दें कि संस्मरण के साथ भी, TIO f (1257) या f (10000) (दोनों स्थानीय रूप से सत्यापित ) की गणना नहीं कर सकता है ।

Answer 6

05AB1E , 32 31 बाइट्स

XˆXˆG[N¯2(è<›¯¤NÊsN¢¯Nè‹&&#]N.ˆ

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

व्याख्या

XˆXˆ                             # initialize global list as [1,1]
    G                            # input-1 times do:
     [                    #]     # loop until expression is true     
      N¯2(è<›                    # n > list[-2]-1
             ¯¤NÊ                # list[-1] != N
                 sN¢¯Nè‹         # count(list, N) < list[N]
                        &&       # logical AND of the 3 expressions
                            N.ˆ  # add N to global list 
                                   and output last value in list and end of program

Gजब हम N को वैश्विक सूची में जोड़ते हैं, तो हम तकनीकी रूप से लूप में होते हैं , लेकिन 05AB1E में सभी लूप्स एक ही वैरिएबल N का उपयोग इंडेक्स के रूप में करते हैं, इसलिए इनर लूप [...]ने N को ओवरराइट कर दिया है Gजिसका अर्थ है कि हम इसे लूप के बाहर जोड़ सकते हैं।

नेस्टेड लूप और सशर्त के मुद्दे हमें लूप के अंदर ऐसा करने से रोकता है।

Answer 7

Befunge, 141 136 बाइट्स

<v9\0:p8\2:*2:-1<9
v>p1+:3\8p0\9p:#^_&
>1-:#v_1.@>$8g.@
*+2%\>1-:!|>$!:::9g!\!9g!*\:8g\!8g`
9\+1g9::< \|`g9\g8+2::p
g2+\8p2+^:<>:0\9p::8

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

Befunge की मेमोरी सीमाओं के कारण, अनुक्रम में पिछली सभी प्रविष्टियों की सूचनाओं को ट्रैक करना वास्तव में व्यावहारिक नहीं है, इसलिए यह समाधान एक कम मेमोरी फ़ुटप्रिंट के साथ एक एल्गोरिथ्म का उपयोग करता है जो मूल्यों को अधिक सीधे गणना करता है।

उस ने कहा, हम अभी भी सेल आकार द्वारा सीमित हैं, जो कि Befunge-93 संदर्भ दुभाषिया में एक हस्ताक्षरित 8-बिट मूल्य है, इसलिए अनुक्रम A(1876) = 126में उच्चतम समर्थित सम संख्या है, और उच्चतम समर्थित विषम संख्या है A(1915) = 127।

यदि आप बड़े मूल्यों का परीक्षण करना चाहते हैं, तो आपको एक बड़े सेल आकार के साथ दुभाषिया का उपयोग करने की आवश्यकता होगी। इसमें अधिकांश Befunge-98 कार्यान्वयन शामिल हैं ( इसे ऑनलाइन आज़माएं! )।

Answer 8

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

भावहीन। वह छोटा नहीं है। सरल पुनरावृत्त समाधान।

L=[1,2,3]
n=input()
while len(L)<n:
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:L+=[i];break
print L[n-1]

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

यहां एक पुनरावर्ती समाधान (129 बाइट्स) पर वास्तव में बुरा प्रयास है:

def f(n,L=[1,2,3]):
 if len(L)>=n:print L[n-1];exit(0)
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:f(n,L+[i])
 f(n,L)

Comments

फिक्स्ड। मुझे लगा कि मैं बाइट बचाने -1के n-1लिए इस्तेमाल कर सकता हूं, मुझे नहीं लगता।

— mbomb007