गोलॉम्ब के आत्म-वर्णन अनुक्रम के नौवें शब्द की गणना करें

Question

पिछले प्रश्न से प्रेरित ।

गोलम का आत्म-वर्णन अनुक्रम जी (एन) एक ऐसा अनुक्रम है जहां nअनुक्रम जी (एन) समय के भीतर किसी भी प्राकृतिक संख्या को दोहराया जाता है।

अनुक्रम में पहले कुछ संख्याएँ हैं:

n    1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20
g(n) 1  2  2  3  3  4  4  4  5  5  5  6  6  6  6  7  7  7  7  8

आप उस जी (4) = 3 को देख सकते हैं, और अनुक्रम में "4" को 3 बार दोहराया जाता है।

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

सीमाएँ: n <100000।

सबसे छोटा कोड जीतता है।

Comments

भोली दृष्टिकोण के लिए यह पिछले प्रश्न के समान है सिवाय इसके कि यह इसके nबजाय उपयोग करता है 2 - n % 1। क्या आपके पास उत्तर अलग-अलग होने की अपेक्षा करने का कोई कारण है?

— पीटर टेलर

हास्केल में, आप इसका उपयोग कर सकते हैं:golomb=1:2:2:concat(zipWith replicate(drop 2 golomb)[3..])

— FUZxxl

@PeterTaylor: मुझे नहीं पता था कि।

— बेय्यबाक़

Answer 1

GolfScript (31 वर्ण)

~([1 2.]2{.2$=[1$)]*@\+\)}3$*;=

डेमो

Comments

अच्छा है, लेकिन क्या आपने वास्तव में n = 99999 के साथ ऐसा करने की कोशिश की है, और यदि ऐसा है, तो कितना समय लगा? (जब मैंने इसे आज़माया, तो यह 100 घंटे तक चला था इससे पहले कि मैं इसके लिए 100 MiB मेमोरी की सीमा तय करूं और दुर्घटनाग्रस्त हो

— जाऊं

@ इलमारीकरोन, नहीं। सवाल स्मृति या समय दक्षता पर कोई सीमा निर्धारित नहीं करता है, इसलिए मैं मानता हूं कि इनपुट आकार पर बाध्य उन भाषाओं के लिए है, जिनमें निश्चित-चौड़ाई की स्याही होती है।

— पीटर टेलर

Answer 2

जेली , गैर-प्रतिस्पर्धात्मक

10 बाइट्स यह जवाब गैर-प्रतिस्पर्धात्मक है, क्योंकि चुनौती जेली के निर्माण से पहले की है।

’ßßạ¹ß‘µṖ¡

यह OEIS पृष्ठ से पुनरावर्ती सूत्र (1) = 1, (n + 1) = 1 + a (n + 1 - a (a (n))) का उपयोग करता है।

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

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

’ßßạ¹ß‘µṖ¡ Main link. Input: n

’          Decrement; yield n - 1.
 ßß        Recursively call the main link twice, with argument n - 1.
   ạ¹      Take the absolute difference of a(a(n - 1)) and n.
     ß     Recursively call the main link, with argument n - a(a(n - 1)).
      ‘    Increment the result, yielding 1 + a(n - a(a(n - 1))).
       µ   Combine the chain to the left into a single link.
        Ṗ  Pop [1, ..., n]. This yields [] iff n == 1.
         ¡ Execute the chain iff Ṗ returned a non-empty array.

Answer 3

PHP - 63 शुल्क

function g($n){for(;++$i<=$n;){for(;++$j<=$i;){echo $i;}$j=0;}}

तेज और छोटा।

मुझे लगता है कि मन में गलत क्रम था। Derp।

यह सही, तेज और छोटा है।

function g($n){for(;++$i<$n;){echo round(1.201*pow($i,.618));}}

सटीकता आवश्यक 100,000 अंक से अधिक हो सकती है, लेकिन मैंने वास्तव में निशान को पूरा किया।

Answer 4

पीएचपी

यह पुनरावर्ती संस्करण छोटा है (60) लेकिन कम्प्यूटेशनल रूप से अक्षम है:

function g($n){return$n==1?1:1+g($n-g(g($n-1)));}echo g($n);

यह बहुत तेज़ है लेकिन अब (78):

$a=[1,2,2];for($i=3;$i<$n;$i++)for($j=0;$j<$a[$i-1];$j++)$a[]=$i;echo$a[$n-1];

बहुत तेजी से, लेकिन 89 अक्षरों में होगा:

$a=[1,2,2];for($i=3;!isset($a[$n-1]);$i++)for($j=0;$j<$a[$i-1];$j++)$a[]=$i;echo$a[$n-1];

जो O (n) है

Answer 5

हास्केल, 30 27 चार्ट

g 1=1
g n=1+(g$n-g(g$n-1))

Comments

साइट पर आपका स्वागत है!

— जोनाथन वान मैटर

Answer 6

ओएसिस , 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

कोड:

n<aae>T

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

ओएसिस अदनान द्वारा डिज़ाइन की गई भाषा है जो दृश्यों में विशेष है।

वर्तमान में, यह भाषा पुनरावृत्ति और बंद रूप में कर सकती है।

Tअंत में के लिए आशुलिपि है 10, जो कि इंगित करता है a(0) = 0और a(1) = 1। अधिक टेस्टेसिस जोड़ने के लिए, बस अंत में सूची में जोड़ें।

n<aae>T
n<aae>10  expanded

       0  a(0) = 0
      1   a(1) = 1

n         push n (input)
 <        -1
  a       a(above)  [a is the sequence]
   a      a(above)
    e     a(n-above)
     >    +1

अब हमने अनिवार्य रूप से गणना की a(n-a(a(n-1))+1।

Answer 7

पर्ल, 48 वर्ण

(@a=(@a,($,)x($a[$,++]||$,)))<$_?redo:say$,for<>

स्टड पर इनपुट, स्टडआउट के लिए आउटपुट। सुविधा -M5.010को सक्षम करने के लिए पर्ल 5.10+ और की जरूरत है say। अक्षम सरणी हेरफेर के कारण ओ ( एन ² ) समय के बारे में लेता है , लेकिन अभी भी इतनी तेजी से 100,000 वें कार्यकाल तक आसानी से गणना करता है।

Answer 8

जूलिया - २ -

एक पुनरावर्ती तरीके से:

a(n)=n==1?1:1+a(n-a(a(n-1)))

आउटपुट:

[a(i) for i=1:20]'
1x20 Array{Int64,2}:
 1  2  2  3  3  4  4  4  5  5  5  6  6  6  6  7  7  7  7  8

Answer 9

पायथन - 64 वर्ण

n=input()
g=[1,2,2]
for i in range(3,n):g+=[i]*g[i-1]
print g[n]

Comments

यह अच्छा है। मुझे नहीं लगता था [i]*g[i-1]कि ऐसा करने से मैं ऐसा करने के लिए पीछे की तरफ झुकता हूँ; मैंने सोचा कि यह किसी कारण से एक मैट्रिक्स को एक स्केलर से गुणा करने की तरह अधिक व्यवहार करेगा ...

— chucksmash

Answer 10

जावास्क्रिप्ट, 93 वर्ण

c=[,1],i=c.length;function g(n){for(i;i<n;i++) c[i]=g(i);return c[n]||(c[n]=1+g(n-g(g(n-1))))}

Answer 11

जे, ४३ अक्षर

f=:3 :'<.@:+&0.5(p^2-p)*y^p-1[p=:(+%)/20$1'

विकिपीडिया पृष्ठ पर दिए गए स्पर्शोन्मुख अभिव्यक्ति का उपयोग करके एक फ़ंक्शन को परिभाषित करता है।

   f 5
3
   f 20
8
   f 100000
1479

वार्षिक रूप से 9 वर्णों का उपयोग केवल निकटतम पूर्णांक तक गोलाई में किया जाता है।

Answer 12

प्रस्तावना , 69 55 54 बाइट्स

?1-(v  #1)-
1   0v ^(#    0 (1+0)#)!
    (#)  ^#1-(0)#

यदि एक मानक अनुरूप दुभाषिया का उपयोग किया जाता है, तो यह इनपुट और आउटपुट को बाइट मान के रूप में लेता है । वास्तव में STDIN / STDOUT पर दशमलव संख्या का उपयोग करने के लिए, आपको एक अतिरिक्त विकल्प के साथ अजगर दुभाषिया की आवश्यकता होगी ।NUMERIC_OUTPUT = TrueNUMERIC_INPUT = True

व्याख्या

कार्यक्रम का कंकाल है

?1-(    1 -
1                     )!

हमने Nपहली आवाज़ पर इनपुट पढ़ा और इसे प्राप्त करने के लिए इसे घटाया N-1। हम दूसरी आवाज़ को भी इनिशियलाइज़ करते हैं 1। फिर हम N-1एक बार लूप करते हैं, जिसमें से प्रत्येक पुनरावृत्ति को दूसरे स्टैक पर अनुक्रम का अगला मूल्य मिलता है। अंत में हम Nवें नंबर को प्रिंट करते हैं ।

कार्यक्रम का विचार अनुक्रम के प्रत्येक तत्व को तीसरी आवाज़ पर एक कतार में रखना है, और प्रत्येक पुनरावृत्ति में उस कतार के प्रमुख को निकालना है। जब सिर पहुंचता है 0, तो हम अनुक्रम के मूल्य में वृद्धि करते हैं और इसे हटा देते हैं 0।

अब मुद्दा यह है कि प्रेड्यू स्टैक का उपयोग करता है न कि कतारों का। इसलिए हमें कतार की तरह उपयोग करने के लिए उस ढेर के चारों ओर शिफ्ट करने की आवश्यकता है।

v  #
0v ^
(#)

यह अनुक्रम के वर्तमान मूल्य को पहली आवाज़ (एक अस्थायी प्रतिलिपि के रूप में) की प्रतिलिपि बनाता है, 0दूसरी आवाज़ पर (कतार के अंत को चिह्नित करने के लिए ) धक्का देता है । और फिर दूसरे पर तीसरे स्टैक को शिफ्ट (और इस तरह रिवर्स) करने के लिए एक लूप करता है। लूप के बाद, हम वर्तमान अनुक्रम मान की प्रतिलिपि दूसरे स्टैक के ऊपर रखते हैं (जो हमारी कतार की पूंछ है)।

 )
(#
 ^#1-

यह थोड़ा बदसूरत दिखता है, लेकिन अनिवार्य रूप से यह एक लूप है जो स्टैक को तीसरी आवाज़ पर वापस शिफ्ट करता है। चूंकि )स्थानांतरण निर्देश के समान कॉलम में है, 0हम पहले दूसरी आवाज पर रखते हैं, तीसरी आवाज पर भी समाप्त हो जाएगा, इसलिए हमें इसे दूसरे के साथ निकालने की आवश्यकता है #। फिर तीसरी आवाज के शीर्ष पर, यानी कतार के शीर्ष को घटाएं।

अब यह थोड़ा कष्टप्रद हो जाता है - हम कुछ कोड चलाना चाहते हैं जब वह मान होता है 0, लेकिन प्रिल्यूड की एकमात्र नियंत्रण संरचना (लूप) केवल गैर-शून्य मानों पर प्रतिक्रिया करती है।

 0 (1+0)#
(0)#

ध्यान दें कि दूसरी आवाज़ का शीर्ष सत्य है (चूँकि गोलम अनुक्रम में कोई 0s नहीं है )। तो काम का बोझ उस आवाज़ (कोष्ठक की बाद वाली जोड़ी) में चला जाता है। अगर कतार का सिर अभी तक नहीं है, तो हमें इसे रोकने की आवश्यकता है 0। तो पहले हमारे पास तीसरी आवाज पर एक "लूप" है जो 0दूसरी आवाज पर धक्का देता है अगर कतार का सिर अभी भी गैर-शून्य है। हमने 0लूप से बाहर निकलने के लिए तीसरी आवाज भी लगाई । #तीसरे आवाज पर तो या तो उस को हटा 0, या कतार के सिर को हटा अगर है कि पहले से ही शून्य था। अब वह दूसरा लूप केवल तभी दर्ज किया जाता है जब कतार का सिर शून्य था (और0दूसरी आवाज पर कभी धक्का नहीं दिया गया)। उस स्थिति में हम अनुक्रम के वर्तमान मूल्य को बढ़ाते हैं और 0लूप से बाहर निकलने के लिए धक्का देते हैं । अंत में, 0स्टैक के शीर्ष पर हमेशा रहेगा , जिसे हमें त्यागने की आवश्यकता है।

मैंने आपको बताया था कि प्रेग्‍नेंसी में तार्किक नकारात्‍मक गुस्सा है ...

Answer 13

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

f@1=1;f@n_:=1+f[n-f@f[n-1]]

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

Answer 14

CJam, 14 बाइट्स

CJam इस चुनौती से बहुत छोटा है, इसलिए यह उत्तर ग्रीन चेकमार्क के लिए योग्य नहीं है। हालाँकि, यह काफी दुर्लभ है कि आपको jइसे अच्छी तरह से उपयोग करना है, इसलिए मैं इसे वैसे भी पोस्ट करना चाहता था।

l~2,{_(jj-j)}j

इसका परीक्षण यहां करें।

व्याख्या

jमूल रूप से "ज्ञापन पुनरावृत्ति ऑपरेटर" है। यह एक पूर्णांक N, एक सरणी और एक ब्लॉक लेता है F। एरे को मेमरी को इनिशियलाइज़ करने के लिए उपयोग किया जाता है: इंडेक्स में मौजूद तत्व के iलिए लौटाया जाएगा F(i)। यदि मान अभी तक याद नहीं किया गया है jतो गणना करता है F(N), या तो इसे देख कर या ब्लॉक ( nस्टैक पर) चलाकर। वास्तव में निफ्टी की विशेषता यह है कि ब्लॉक के भीतर , jकेवल एक पूर्णांक लेता है i, और F(i)पुनरावर्ती कॉल करता है। तो यहाँ कोड है:

l~             "Read and eval input.";
  2,           "Push a 2-range onto the stack, i.e. [0 1]. The first value is irrelevant
                but the second value is the base case of the recursion.";
    {       }j "Compute F(N).";
     _(        "Duplicate i and decrement to i-1.";
       jj      "Compute F(F(i-1)).";
         -     "Subtract from i.";
          j    "Compute F(n-F(F(i-1))).";
           )   "Increment the result.";

Answer 15

जे, 16 बाइट्स

    <:{1($1+I.)^:[~]

    (<:{1($1+I.)^:[~]) every 1+i.20  NB. results for inputs 1..20
1 2 2 3 3 4 4 4 5 5 5 6 6 6 6 7 7 7 7 8

यह समाधान है भारी के आधार पर algorithmshark के समाधान के लिए एक समान समस्या के लिए। आप इस विधि के बारे में कुछ स्पष्टीकरण पा सकते हैं।

जे, 33 बाइट्स

इस दृष्टिकोण में मैं h(k)पहले अनुक्रमित के मूल्यों के साथ एक अनुक्रम बनाता हूं iजहां g(i)=kऐसा है h = 1 2 4 6 9 12 16...। हम अभिव्यक्ति के साथ h(k)काफी सरलता से प्राप्त कर सकते हैं जहां इनपुट है ।h(1..k-1)({:+1+[:+/#<:])h(1..k-1)

से आउटपुट hको सीधा करना सरल है।h ([:+/]>:[) input

[:+/]>:1 2(,{:+1+[:+/#<:])@]^:[~]

Answer 16

ब्रेकीलॉग , 13 बाइट्स (गैर-प्रतिस्पर्धात्मक)

1|-₁↰↰:?-ṅ↰+₁

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

व्याख्या

1                Input = 1 = Output
 |               Or
  -₁↰            a(Input - 1)
     ↰           a(a(Input - 1))
      :?-ṅ       Input - a(a(Input - 1))
          ↰      a(Input - a(a(Input - 1))
           +₁    1 + a(Input - a(a(Input -1))

Answer 17

पायथन - 76 वर्ण

n=20;g=[1,2,2];[[g.append(i)for j in range(g[i-1])]for i in range(3,n)];g[n]

Comments

यह वास्तव में Nones के एक समूह के साथ सूची भरता है । लगता है "सही" राशि का Nonetho :)

— daniero

@Daniero हाँ यह अजीब तरह का कोड है। मुझे इसे चलाने के लिए खुद को समझाने के लिए कई बार भागना पड़ा। यह list.append () रिटर्न Noneप्रकार के बाद से Nones के समूह के साथ सूची की समझ को भर देता है । मैंने सिर्फ नेस्टेड लूप हासिल करने के लिए नेस्टेड लिस्ट कॉम्प्रिहेंशन का इस्तेमाल किया। यहाँ सूची समझ का एकमात्र उद्देश्य कोड को सही संख्या में लूप करने का कारण है - वे मानों को दूर फेंक रहे हैं

— chucksmash

यह दो पात्रों को बचाता है अगर मैंने पारंपरिक नेस्टेड लूप किया है :)

— chucksmash

दुर्भाग्य से ऐसा लगता है कि आप इनपुट को हार्ड-कोडिंग कर रहे हैं, जिसे हम अनुमति नहीं देते हैं, और आरईपीएल वातावरण को ग्रहण करते हैं, जिससे यह एक स्निपेट बन जाएगा। डिफ़ॉल्ट रूप से , सभी प्रस्तुतियाँ पूर्ण कार्यक्रम या फ़ंक्शंस होनी चाहिए जो स्निपेट के बजाय हमारे डिफ़ॉल्ट I / O तरीकों में से एक का उपयोग करती हैं । अगर आपका कोई प्रश्न हैं, तो मुझे से पूछें।

— एलेक्स ए।

@AlexA। थोड़ा सा पुरातत्व कर रहे हो?

— 16

Answer 18

जावास्क्रिप्ट - 48 वर्ण

for(g=[,i=j=k=1,2];i<1e5;k=--k?k:g[++j])g[i++]=j

gअनुक्रम मान वाले 1-अनुक्रमित सरणी बनाता है ।

संपादित करें - जावास्क्रिप्ट - 46 वर्ण

v=[,1];for(x=2;x<1e5;)v[x]=1+v[x-v[v[x++-1]]]

vअनुक्रम मान वाले 1-अनुक्रमित सरणी बनाता है ।

2 संपादित करें - ECMAScript 6 - 27 वर्ण

g=x=>x-1?1+g(x-g(g(x-1))):1

पहले दो यथोचित तेज हैं - तीसरा बहुत धीमा है

Answer 19

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

f n|n<3=n|n<4=2|1>0=foldr1(++)[replicate(f m)m|m<-[1..]]!!(n-1)

यह अनुभवहीन दृष्टिकोण है, जब मैंने यह लिखा था तो मुझे बहुत कम पुनरुत्थान के बारे में पता नहीं था, लेकिन मुझे लगा कि मैं इसे वैसे भी पोस्ट करूंगा, यहां तक ​​कि सभी अन्य हास्केल कार्यान्वयनों की तुलना में यह कठिन है, जैसे कि

गोलॉम्ब के आत्म-वर्णन अनुक्रम के नौवें शब्द की गणना करें

तथा

https://codegolf.stackexchange.com/a/23979/24877