हॉफ़स्टैटर की आकृति-चित्रा अनुक्रम उत्पन्न करें

Question

में गोडेल, Escher, बाख , डगलस होफस्टैड्टर का परिचय एक पूर्णांक अनुक्रम जो आमतौर पर आंकड़ा-आंकड़ा अनुक्रम के रूप में जाना जाता है:

2, 4, 5, 6, 8, 9, 10, 11, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, ...

आप चुनौती के भाग के रूप में स्वयं अनुक्रम की परिभाषा का उपयोग करने का आनंद ले सकते हैं, लेकिन यदि आप यह पता नहीं लगा सकते हैं या नहीं करना चाहते हैं तो आप इसे OEIS पर अनुक्रम A030124 और विकिपीडिया पर थोड़ी स्पष्ट परिभाषा के रूप में पा सकते हैं ।

एक प्रोग्राम या फ़ंक्शन लिखें, जो nSTDIN, ARGV या फ़ंक्शन तर्क के माध्यम से दिया गया है , nकिसी भी उचित सूची प्रारूप में STDOUT को अनुक्रम के पहले नंबरों की सूची प्रिंट करता है।

यह कोड गोल्फ है, बाइट्स जीत में सबसे छोटा समाधान।

Answer 1

CJam, 38 30 29 21 बाइट्स

li_3*,2>\{(_pX+:X-}*;

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

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

li                     " Read an integer N from STDIN.              ";
  _3*,2>               " Push S := [ 2 3 ... (N * 3 - 1) ].         ";
        \{        }*   " Do the following N times:                  ";
          (            " Shift an integer I from S.                 ";
           _p          " Print a copy of I, followed by a linefeed. ";
             X+:X      " Execute X += I. (X is initialized to 1.)   ";
                 -     " Remove X from S.                           ";
                    ;  " Discard S from the stack.                  ";

उदाहरण चलाते हैं

$ cjam <(echo 'li_3*,2>\{(_pX+:X-}*;') <<< 20
2
4
5
6
8
9
10
11
13
14
15
16
17
19
20
21
22
23
24
25

Comments

जब आप दुभाषिया के लिए url टाइप कर रहे हैं, तो आप aditsu से बाहर हो गए हैं

— Beta Decay

@BetaDecay तब इसे ठीक करने के लिए संपादित क्यों नहीं किया गया;)

— मार्टिन

@ मैं नहीं सोचता था कि मेरे पास पर्याप्त प्रतिनिधि था ...

— बीटा

@BetaDecay आप नहीं करते हैं, लेकिन आप अभी भी उन्हें सुझाव दे सकते हैं (यदि वे स्वीकार किए जाते हैं तो आपको 2 प्रतिनिधि भी देते हैं)।

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

मैंने अपने कोड के 8 अतिरिक्त बाइट्स को बंद करने के लिए इतना चतुर महसूस किया। तब मुझे एहसास हुआ कि यह अब हिस्टोक्रेट, मैट्सजॉय और पीटर टेलर के जवाबों के समान ही है ...

— डेनिस

Answer 2

हास्केल, 67 61 60 56 55 53 वर्ण

g n=take n$2:4:h
a#(x:s)=[a..x-2]++x#s
h=5#scanl(+)8h

पहले एल्गोरिथ्म पर वापस जाएं।

यह समाधान अनुक्रम के शुरुआती तत्वों को संक्षेप में पूरक अनुक्रम की गणना करता है। इसके बाद अनुक्रम को पूरक के अनुक्रम संख्या के बीच सभी संख्याओं के रूप में गणना करता है।

(#)वह कार्य है जो पूरक अनुक्रम के बीच संख्याओं की गणना करता है।
hअनुक्रम ही है।
gवह कार्य है जो प्रश्न का उत्तर देता है।

जी फ़ंक्शन को एच से तत्वों की आवश्यक मात्रा लेने के लिए परिभाषित किया गया है।

बारीकियों:

hवास्तव में पहले 2 तत्वों को छोड़कर आंकड़ा आंकड़ा अनुक्रम है।
पूरक अनुक्रम गणना नहीं है, लेकिन प्रत्येक तत्व के लिए जोड़ा गया 1 के साथ पूरक अनुक्रम।
ये दो सूक्ष्मताएं कारण हैं scanl(+)8h(जो कि पूरक अनुक्रम के लिए कोड है (पहले 2 तत्वों को छोड़कर) जोड़ा 1 के साथ) इसमें 8है। यह 1 के साथ पूरक अनुक्रम के तीसरे तत्व के लिए है।
कारण यह है कि गणना पहले दो तत्वों को याद नहीं कर रही है क्योंकि उन्हें अंदर जोड़ा गया gहै 2:4:h।

उदाहरण:

>g 50
[2,4,5,6,8,9,10,11,13,14,15,16,17,19,20,21,22,23,24,25,27,28,29,30,31,32,33,34,36,37,38,39,40,41,42,43,44,46,47,48,49,50,51,52,53,54,55,57,58,59]

Answer 3

रूबी, ५४ ४ 48

f=->n{x=1
b=*2..n*n
n.times{b-=[x+=p(b.shift)]}}

डेमो

संपादित करें: एक बार फिर यह महसूस किया कि मुझे याद है कि मुझे स्मृति में पूर्ण पूरक अनुक्रम रखने की आवश्यकता नहीं है। यहां बताया गया है कि यह अब कैसे काम करता है: हम xपूरक अनुक्रम में सबसे बड़ी गणना संख्या का ट्रैक रखने के लिए उपयोग करते हैं, और bअनुक्रम के लिए उम्मीदवारों का एक पूल है। nसमय में, हम सबसे छोटे शेष तत्व का उत्पादन करते हैं bऔर xपूरक क्रम में अगली संख्या की गणना करने के लिए इसे जोड़ते हैं । फिर हम उम्मीदवारों के पूल से दोनों नंबरों को हटा देते हैं, इसलिए हम हमेशा सबसे छोटी संख्या को आउटपुट कर रहे हैं जो पहले से ही अनुक्रम में नहीं जोड़ा गया था।

रूबी गोल्फ ट्रिक्स: स्टैबी लैम्बडा सिंटैक्स एक विधि परिभाषा से छोटा है। आवश्यकता यह है कि उत्पादन STDOUT के बजाय वापसी मान के रूप में दिया जाता है मुझे तथ्य यह है कि के रिटर्न मान का उपयोग करने के लिए प्रेरित किया p(x)है xजो मैं सामान्य रूप से याद नहीं है, क्योंकि यह अराजकता गोल्फ में इस्तेमाल रूबी संस्करण में ऐसा नहीं है,।

Comments

यह कैसे काम करता है?

— गर्वित हैकेलर

FWIW आप उपयोग कर सकते हैं 2..2*n। मुझे उपयोग करना है n*nक्योंकि मैं प्रभावी रूप से कर रहा हूं b = [x]^bइसलिए मुझे सबसे बड़े तत्व की bसबसे बड़ी कीमत की तुलना में बड़ा होने की आवश्यकता है x, लेकिन आपके लिए इसकी b -= [x]आवश्यकता हैb के लिए आउटपुट अनुक्रम का सबसे बड़ा संभव मूल्य शामिल है।

— पीटर टेलर

Answer 4

GolfScript ( 24 21 बाइट्स)

~.3*,1>\{(\(.p@+\|}*;

ऑनलाइन डेमो

यह काफी अलग तरीके से शुरू हुआ, लेकिन डेनिस के कुछ सुझाव देने से पहले हिस्टोक्रेट के रूबी समाधान के एक गोल्फस्क्रिप्ट पोर्ट पर परिवर्तित करना समाप्त कर दिया, जो इसे थोड़ा अलग दिशा में ले जाता है। विशेष रूप से, संख्याओं की छपाई करना, जैसा कि हम उन्हें पहचानते हैं, अंत में छपाई के लिए एक सरणी में उन्हें इकट्ठा करने में काफी कुछ बचाते हैं; कारण यह है कि इसका मतलब यह है कि किसी भी बिंदु पर हमें स्टैक पर 3 से अधिक वस्तुओं के बारे में चिंता नहीं करनी है।

विच्छेदन

~.3*,           # Eval input n, dup, multiply by 3, make list [0 1 ... 3n-1]
1>              # Discard 0, which is part of neither sequence
\{              # Execute n times: stack contains pool of numbers not yet seen
                # in either sequence and the first element of it is the next element of the
                # complement sequence
  (\(           #   Pop two numbers from the start of the pool: stack is
                #     pool[0] pool[2..max] pool[1]
  .p            #   Print pool[1]
  @+            #   Rotate pool[0] to top and add to pool[1]
  \|            #   Place pool[0]+pool[1] at the start of the pool and
                #   (this is the clever bit) remove it from later in the pool
}*
;               # Discard the unused remainder of the pool

Comments

यदि आप के ^साथ प्रतिस्थापित करते हैं \-, तो आप के ).*साथ बदल सकते हैं 3*। यह किसी भी बाइट को नहीं बचाएगा, लेकिन यह रन टाइम और मेमोरी उपयोग को काफी कम कर देता है। - आपको पूर्णांक को सरणी के शीर्ष पर रखकर एक बाइट को बचाने में सक्षम होना चाहिए। लूप में एक ही बाइट काउंट होगा, लेकिन आरंभीकरण एक बाइट कम होगा।

— डेनिस

सेट यूनियन अंतर से भी बेहतर काम करता है:~.3*,1>\{(\(.p@+\|}*;

— डेनिस

Answer 5

जे - 28 चार

nतर्क के रूप में कार्य करना ।

($+/\(-.~2+i.)&:>:+/)^:_&2 4

हम एक फंक्शन चलाते हैं n बाएं तर्क के रूप में, इसके सही तर्क पर बार-बार जब तक यह कोई परिवर्तन नहीं पैदा करता है। शुरू करने का तर्क सूची है 2 4।

फ़ंक्शन में ही, हम आंशिक रकम +/\और पूर्ण राशि लेते हैं +/, और फिर दोनों के साथ वेतन वृद्धि करते हैं &:>:। फिर हम पूर्णांक ( 2+i.) से 2 से प्रत्येक पूर्णांक को एक से अधिक उत्पन्न करते हैं , और घटाते हैं (-. आंशिक रकमों को , परिभाषा के अनुसार एक लंबी आकृति-आकृति अनुक्रम छोड़ते हैं। अंत में, हम सूची को लंबाई में छोटा या चक्रीय रूप से बढ़ाते हैं n।

परिणाम यह है कि 2 4बन जाता है 3 7, और इसे 2..8छोड़ने से हटा दिया जाता है 2 4 5 6 8। एक और दौर के बाद, 2 4 5 6 8बन 3 7 12 18 26जाता है

2 4 5 6 8 9 10 11 13 14 15 16 17 19 20 21 22 23 24 25 27

इस तरह, हम बार-बार फिगर-फिगर सीक्वेंस को बढ़ाते हैं। $लंबाई व्यवहार के लिए अनुक्रम लंबाई करने के लिए विकसित करने के लिए इंतजार कर के सिर्फ एक गैर तुच्छ चरित्र बचत तरीका है nया अधिक से अधिक, और outputting nपहले मूल्यों जब वे बदल रहा बंद करो। हमें बहुत लंबा इंतजार करने की जरूरत नहीं है, या तो: हम आंतरिक क्रिया के चार अनुप्रयोगों में से 46336 शब्द प्राप्त कर सकते हैं।

कश्मीर में एक ही कार्य:

• k2, 37 वर्ण: {{x#y@&~_lin[y:1+!1+/y;1+\y]}[x]/2 4}
• k4, 36 वर्ण: {{x#y@&~(y:2+!1+/y)in\:1+\y}[x]/2 4}

Answer 6

जावा - 183 158

यह सबसे ज्यादा मैंने कभी कुछ भी हासिल किया है, और मुझे इस पर गर्व है! (हालांकि यह चार्ट के शीर्ष के पास कहीं नहीं है (क्योंकि यह जावा है))

सुझावों के लिए पीटर टेलर का धन्यवाद

class f{public static void main(String[]a){int q=1,m=Byte.valueOf(a[0]),w=2,n[]=new int[m*m*2];for(n[q+=w]=1;m-->0;){System.out.println(w);for(;n[++w]>0;);}}}

बड़ा -

public class f {
    public static void main(String[] a) {
        int q = 1, m = Byte.valueOf(a[0]), w = 2, n[] = new int[m * m * 2];
        for (n[q += w] = 1; m-- > 0;) {
            System.out.println(w);
            for (; n[++w] > 0;)
                ;
        }
    }
}

Comments

लूप के लिए यह आंतरिक काफी प्रभावशाली रूप से बाधित है, लेकिन मुझे लगता है कि आप कुछ बाइट्स बचा सकते हैं। Byte.valueOfतीन बचाता है, और चूंकि प्रश्न इनपुट की सीमा को निर्दिष्ट नहीं करता है, मुझे लगता है कि यह स्वीकार्य होना चाहिए। छोरों के बाहर, mकेवल इनिशियलाइज़ करने के लिए उपयोग किया जाता है n, इसलिए पूरी तरह से समाप्त k++<mहो सकता है । के रूप में आरंभिक किया जा सकता है और पिछले आरंक्षक में विलय किया जा सकता है। इसके अलावा कभी भी मान नहीं रखता है , इसलिए हो सकता है । आरम्भिक तब पहले लूप का प्रारंभिक भाग बन सकता है । m-->0kint[] nint n[]n1n[...]!=0n[...]>0for

— पीटर टेलर

और अगर आप छुटकारा पा लेते हैं uऔर बस उपयोग करते हैं ++w, तो सेट करने की आवश्यकता नहीं है n[q]या n[w]। इसमें एक बग है, इसमें आप nकब के अंत से भागते हैं m==2, जो कि इनिशियलाइज़िंग द्वारा सबसे अच्छा तय किया गया n=new int[2*m*m]लगता है, लेकिन मुझे लगता है कि यह 157 बाइट्स के नीचे है।

— पीटर टेलर

लूप के लिए शुरुआती के शुरुआती भाग बनने के बारे में मेरा क्या मतलब था, for(int q=1,w=2,m=...,n[]=...;m-->0;){...एक अर्धविराम को बचा रहा था ।

— पीटर टेलर

Answer 7

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

---

कोड:

n=input();x=1;b=range(2,n*n)
while n:v=b.pop(0);x+=v;print v;b.remove(x);n-=1

@ हिस्टोक्रैट के समाधान के समान काम करता है, सिवाय इनपुट स्टड से आता है।

Answer 8

अजगर 2 - 68

R=[1]
s=0
n=input()
while n:s+=1+(s+1in R);R+=[R[-1]+s];print s;n-=1

Answer 9

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

SƤŻ‘µṀ‘Rḟ
2dz¡ḣ

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

6 के इनपुट पर मेमोरी त्रुटि।

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

SƤŻ‘µṀ‘Rḟ  Aux. link (monad). Input: part of the desired sequence
SƤŻ‘       Sum of prefixes, then prepend a zero and increment
           This is a list of numbers to exclude from the next iteration
    µ      Re-focus on the above
     Ṁ‘Rḟ  Create range 1..Max + 1, then remove all elements of the above
           +1 is needed to progress from [2] to [2,4]

2dz¡ḣ  Main link (monad). Input: n, number of terms
2dz¡   Starting from 2, apply aux. link n times
    ḣ  Take n elements from the beginning

अधिक कुशल संस्करण, 16 बाइट्स

SƤŻ‘µṀ‘Rḟḣ³
2ÇÐL

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

इस J उत्तर से एक विचार का उपयोग करता है । वांछित लंबाई प्रत्येक पुनरावृत्ति को काटें, और फ़िक्सपॉइंट लें। मैंने (अधिकतम + 1 S) के बजाय (राशि) का उपयोग करने का सोचा Ṁ‘, लेकिन मैं इसकी शुद्धता की गारंटी नहीं दे सकता।

Comments

12 बाइट्स ।

— निकोलफर