परिभाषा

दो पूर्णांकों की नकल होती है, अगर वे इसके अलावा कोई सकारात्मक सामान्य भाजक साझा नहीं करते हैं 1।
a(1) = 1
a(2) = 2
a(n)सबसे छोटा धनात्मक पूर्णांक है जो पूर्णांक है a(n-1)और a(n-2)अभी तक प्रकट नहीं हुआ है, पूर्णांक के लिए n >= 3।

कार्य

सकारात्मक पूर्णांक n, आउटपुट / प्रिंट को देखते हुए a(n)।

उदाहरण

a(11) = 6क्योंकि 6पिछले दो पूर्ववर्तियों (अर्थात्, 11और 13) के साथ मैथुन किया गया है और 6पहले सामने नहीं आया है।

चश्मा

आपको 1-अनुक्रमित का उपयोग करना चाहिए ।

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

n      a(n)
1      1
2      2
3      3
4      5
5      4
6      7
7      9
8      8
9      11
10     13
11     6
12     17
13     19
14     10
15     21
16     23
17     16
18     15
19     29
20     14
100    139
1000   1355
10000  13387
100000 133361

स्कोरिंग

चूंकि कोप्राइम का अर्थ है कि दो नंबर केवल एक भाजक ( 1) साझा करते हैं , और 1एक छोटी संख्या है, बाइट-काउंट के संदर्भ में आपका कोड यथासंभव छोटा होना चाहिए।

संदर्भ

OEIS A084937

code-golf sequence number-theory

— लीक नन
स्रोत

4

शॉर्ट कोड के लिए वे "कारण" ...

— लुइस मेंडो

1

मुझे आश्चर्य है कि यह क्यों ठुकरा दिया गया था। निश्चित रूप से भयानक औचित्य के कारण नहीं?

— कॉनर ओ'ब्रायन

@ मुझे नहीं। असल में मैं उखड़ गया। मुझे उम्मीद है कि लोग परिहास और मेरी टिप्पणी दोनों को चुटकुले के रूप में देखेंगे

— लुइस मेंडू

3

कोड गोल्फ के लिए इन "अजीब" औचित्य के साथ समस्या यह है कि मुझे चार लाइनों में फैले एक खराब मजाक को पढ़ने की जरूरत है ताकि यह पता लगाया जा सके कि यह मानक कोड गोल्फ है। यह केवल बिना किसी अच्छे कारण के चुनौती के नियमों का पालन कर रहा है।

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

1

@ ConorO'Brien सभी ब्राउज़र हमेशा शीर्षक नहीं दिखाते (और फिर मोबाइल ऐप है), और हम आम तौर पर टैग का उपयोग करने के अलावा पोस्ट में स्कोरिंग का वर्णन करते हैं, क्योंकि अकेले टैग का मतलब उन लोगों से कोई मतलब नहीं है जो नए हैं साइट के लिए। भले ही मैं कर रहा हूँ हमारी चुनौती प्रकार टैग से परिचित है, मैं उन्हें पढ़ा कैसे एक चुनौती रन बनाता है यह पता लगाने की लेकिन लगता है कि चुनौती शरीर में प्रयास करने के लिए कभी नहीं। टैग टैग विकी में श्रेणीबद्धता, खोजशीलता और चुनौती-प्रकार की विशिष्ट जानकारी के लिए है।

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

5

पायथन 3.5, 160 141 126 124 121 109 बाइट्स

यह अनुक्रम की परिभाषा का एक सरल कार्यान्वयन है। गोल्फ सुझाव का स्वागत करते हैं।

संपादित करें: -17 बाइट लीक नन के लिए धन्यवाद। -9 बाइट्स पीटर टेलर का धन्यवाद। -6 बाइट्स Sp3000 के लिए धन्यवाद और पायथन 3.5 पर स्विच करना।

import math;f=lambda n,r=[2,1],c=3:n<2and r[1]or(c in r)+math.gcd(c,r[0]*r[1])<2and f(n-1,[c]+r)or f(n,r,c+1)

Ungolfing:

import math
def f(n, r=[2,1], c=3):
    if n<2:
        return r[1]
    elif (c in r) + math.gcd(c,r[0]*r[1]) < 2:
        return f(n-1, [c]+r)
    else:
        return f(n, r, c+1)

— Sherlock9
स्रोत

पायथन 3.5+ के लिए, import mathफिर g=math.gcdअपना खुद को परिभाषित करने से छोटा होना चाहिए g। 3.5 से पहले के लिए, आप कर सकते हैं from fractions import*के लिए gcd।

— Sp3000

यदि आप c=3लूप के अंदर इनिशियलाइज़ करते हैं तो आपको केवल एक बार करने की आवश्यकता है। मेरी गिनती से आप 3 वर्ण बचाते हैं।

— पीटर टेलर

सरणी को दूसरे तरीके से बनाने से 2-चार की बचत भी होती है: आपको इसके r=[c]+rबजाय उपयोग करना होगा +=, लेकिन तीन नकारात्मक सूचकांक सकारात्मक हो जाते हैं। और फिर लैम्बडा के रूप में पुनर्लेखन से एक और 2-चार की बचत होती है, हालांकि यह एक बहुत बड़ा बदलाव है: from fractions import*;F=lambda n,r=[2,1],c=3:n<2and r[1]or(c in r)+gcd(r[0]*r[1],c)<2and F(n-1,[c]+r)or F(n,r,c+1)और इसकी कोई आवश्यकता नहीं है printक्योंकि यह अब एक पूर्ण कार्यक्रम नहीं है।

— पीटर टेलर

2

MATL , 28 27 बाइट्स

2:i:"`@ym1MTF_)Zdqa+}@h]]G)

कोड धीमा है, लेकिन सही परिणाम देता है।

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

कोड का एक छोटा संशोधन अनुक्रम के एक भूखंड का उत्पादन करता है:

2:i:"`@ym1MTF_)Zdqa+}@h]]G:)XG

इसे ASCII कला के रूप में देखें , या ऑफ़लाइन संकलक में ग्राफिकल आउटपुट के साथ:

व्याख्या

2:         % Push [1 2] to initiallize the sequence
i:         % Input n. Push [1 2 ... n]
"          % For loop: repeat n times
  `        %   Do while loop
    @      %     Push iteration index, starting at 1. This is the candidate number
           %     to extend the sequence
    y      %     Duplicate vector containing the sequence so far
    m      %     Is member? Gives true if the candidate is in the sequence
    1M     %     Push candidate and vector again
    TF_)   %     Get last two elements of the vector
    Zd     %     GCD between the candidate and those two elements. Produces a
           %     two-element vector
    qa     %     True if any of the two results exceeds 1, meaning
           %     the candidate is not coprime with the latest two sequence values
    +      %     Add. This corresponds to logical "or" of the two conditions, namely
           %     whether the candidate is member of the sequence so far, and
           %     whether it is not coprime with the latest two. In either case
           %     the do...while must continue with a next iteration, to try a new
           %     candidate. Else the loop is exited, and the current candidate
           %     is the new value of the sequence
  }        %   Finally (execute when the loop is exited)
    @h     %     Push current candidate and concatenate to the sequence vector
  ]        %   End do...while
]          % End for
G)         % Get n-th value of the sequence. Implicitly display

— लुइस मेंडो
स्रोत

1

सी, 185 बाइट्स

G(a,b){return a%b?G(b,a%b):b;}
i,j,k;f(n){int a[n+2];for(i=0;i++<n;){a[i]=i<3?i:0;for(j=2;!a[i];++j){for(k=i;--k;){if(a[k]==j)++j,k=i;}a[G(a[i-1],j)*G(a[i-2],j)<2?i:0]=j;}}return a[n];}

— orlp
स्रोत

1

दरअसल , 38 37 35 33 31 30 बाइट्स

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

संपादित करें: -3 बाइट्स लीक नन के लिए धन्यवाद।

2R#╗,;`1";2±╜tπg@╜í+Y"£╓╖`nD╜E

Ungolfing:

2R#╗    Push [1,2] and store it in register 0
,;      Take input and duplicate
`1      Start function, push 1
  "       Start string
  ;       Duplicate i
  2±╜t    Push (list in register 0)[-2:]
  πg      gcd(i, product of list[-2:])
  @╜í     Rotate the gcd and bring up i, check for i in list (0-based, -1 if not found)
  +Y      Add the gcd and the index, negate (1 if coprime and not found in list, else 0)
  "£      End string, turn into a function
╓       Push first (1) values where f(x) is truthy, starting with f(0)
╖`      Append result to the list in register 0, end function
n       Run function (input) times
D╜E     Return (final list)[n-1]

— Sherlock9
स्रोत

1

ढेर हेरफेर

— लीक नून

0

हास्केल, 81 73 बाइट्स

c l@(m:n:_)=m:c([x|x<-[1..],gcd(m*n)x<2,all(/=x)l]!!0:l)
((0:1:c[2,1])!!)

प्रयोग उदाहरण: ((0:1:c[2,1])!!) 12-> 17।

1-आधारित इंडेक्स को ठीक करने और उसके बाद a(n)शुरू करने के 0लिए सभी की सूची बनाएं । इसके बाद तर्क सूची के प्रमुख को ले जाता है, उसके बाद एक पुनरावर्ती कॉल के साथ अगले नंबर जो फिट बैठता है (सह-प्राइम, पहले नहीं देखा गया) के सामने जोड़ा गया । इस सूची के वें तत्व को चुनें ।1c[2,1]clln

— nimi
स्रोत

0

आर, 141 बाइट्स

 f=Vectorize(function(n)ifelse(n>3,{c=3;a=f(n-1);b=f(n-2);d=f(4:n-3);while(!c%%which(!a%%1:a)[-1]||!c%%which(!b%%1:b)[-1]||c%in%d)c=c+1;c},n))

ungolfed

f=Vectorize( function(n)     #build a recursive function. Vectorize allows
    if(n>3) {                #the function to be called on vectors.
        c=3                  #Tests size. Builds some frequent variables.
        a=f(n-1)
        b=f(n-2)
        d=f(4:n-3)           #Should really golf this out, but its horribly slow.
        while(!c%%which(!a%%1:a)[-1]||!c%%which(!b%%1:b)[-1]||c%in%d)
              c=c+1          #If we are coprime and not already seen. add.
        c
     } else n)               #First three are 1,2,3.

— user5957401
स्रोत

0

मैथेमेटिका, 97 90 बाइट्स

a@1=1;a@2=2;a@n_:=SelectFirst[Range[2n],GCD[a[n-1]a[n-2],#]<2&&!MemberQ[a/@Range[n-1],#]&]

~~मेरे अनुमान के~~ आधार पर किa(n) < 2n सभी के लिए n।

तेज़ रन प्राप्त करने के लिए, a@n=मूल के बाद जोड़ें :=ताकि फ़ंक्शन को पिछले मानों को पुनर्गणना करने की आवश्यकता न हो ।

Sherlock9 (यदि gcd(a,b)=1तब gcd(ab,m) = gcd(a,m)*gcd(b,m)) के लिए धन्यवाद 7 बाइट्स सहेजे गए

यह एक अनुमान नहीं है, क्योंकि यह OEIS पृष्ठ में लिखा गया है कि " ABS(a(n)-n) < n"