सिल्वेस्टर का क्रम

Question

सिल्वेस्टर के अनुक्रम, OEIS A000058 , एक पूर्णांक अनुक्रम निम्नानुसार परिभाषित किया गया है:

प्रत्येक सदस्य पिछले सभी सदस्यों के उत्पाद है। अनुक्रम का पहला सदस्य 2 है।

कार्य

संभव सबसे छोटा प्रोग्राम बनाएं जो n लेता है और सिल्वेस्टर के अनुक्रम के nth शब्द की गणना करता है। मानक इनपुट, आउटपुट और लूपहोल्स लागू होते हैं। चूंकि परिणाम बहुत तेज़ी से बढ़ता है इसलिए आपको किसी भी शब्द को लेने की उम्मीद नहीं है, जिसके परिणामस्वरूप आपकी चुनी हुई भाषा में अतिप्रवाह होगा।

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

आप या तो शून्य या एक अनुक्रमण का उपयोग कर सकते हैं। (यहाँ मैं शून्य अनुक्रमण का उपयोग करता हूँ)

>>0
2
>>1
3
>>2
7
>>3
43
>>4
1807

Comments

क्या इनपुट संभाले जाने की उम्मीद है? आउटपुट काफी तेजी से बढ़ता है।

— Geobits

@ जीबिट्स से अपेक्षा की जाती है कि आप अपनी भाषा को जितना संभाल सकते हैं

— व्हीट विजार्ड

एक सरणी है जिसे अनुक्रमित किए गए अनुक्रम के nरिटर्न के साथ अनुक्रमित nthकिया जाता है?

— user6245072

@ user6245072 नहीं, आपको अपने स्वयं के सरणियों को अनुक्रमित करना होगा

— गेहूं जादूगर

Answer 1

ब्रेन-फ्लैक , 76 68 58 52 46 बाइट्स

<>(()())<>{({}[()])<>({({}[()])({})}{}())<>}<>

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

इसके बजाय इस रिश्ते का उपयोग करता है:

जो इस संबंध से प्राप्त होता है जिसे उस क्रम से संशोधित किया गया है:

a(n+1) = a(n) * (a(n) - 1) + 1।

व्याख्या

प्रत्येक कमांड क्या करता है, इसके दस्तावेज के लिए, कृपया GitHub पेज पर जाएँ ।

ब्रेन-फ्लैक में दो स्टैक होते हैं, जिन्हें मैं क्रमशः स्टैक 1 और स्टैक 2 के रूप में नाम दूंगा।

इनपुट स्टैक 1 में संग्रहीत है।

<>(()())<>             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 <- Stack_1 - 1;
  <>                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  <>                       Switch back to Stack 1.
}

<>                     Switch to Stack 2, implicitly print.

पीढ़ी एल्गोरिथ्म के लिए:

({({}[()])({})}{}())      Top <- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).

वैकल्पिक 46-बाइट संस्करण

यह केवल एक स्टैक का उपयोग करता है।

({}<(()())>){({}<({({}[()])({})}{}())>[()])}{}

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

Comments

केवल 10 और बाइट्स यह दिखाने के लिए कि जावा डेवेलपर्स को ब्रेन फ्लैक जाना चाहिए

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला मुझे डर है कि यह असंभव है ...

— लीक नून

@ LeakyNun अभी भी यह सोचना दिलचस्प है। ब्रेन फ्लैक में कुछ शक्ति होती है, और यह आश्चर्यजनक रूप से विपरीत है

— रोहन झुनझुनवाला

एक स्टैक संस्करण भी स्टैक साफ है। जो ब्रेन-फ्लैक में कोड मॉड्युलैरिटी के लिए एक महत्वपूर्ण बिंदु है।

— गेहूं जादूगर

वाह। यह एक अत्यंत प्रभावशाली उत्तर है।

— DJMcMayhem

Answer 2

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

Ḷ߀P‘

यह 0-आधारित अनुक्रमण और चुनौती युक्ति से परिभाषा का उपयोग करता है।

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

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

Ḷ߀P‘  Main link. Argument: n

Ḷ      Unlength; yield [0, ..., n - 1].
 ߀    Recursively apply the main link to each integer in that range.
   P   Take the product. This yields 1 for an empty range.
    ‘  Increment.

Comments

आह, मैं भूल गया कि खाली उत्पाद 1. है

— लीक नून

Answer 3

हेक्सागोनी , 27 बाइट्स

1{?)=}&~".>")!@(</=+={"/>}*

सामने आया:

    1 { ? )
   = } & ~ "
  . > " ) ! @
 ( < / = + = {
  " / > } * .
   . . . . .
    . . . .

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

व्याख्या

चलो अनुक्रम पर विचार करें b(a) = a(n) - 1और थोड़ा पीछे हटें:

b(a) = a(n) - 1
     = a(n-1)*(a(n-1)-1) + 1 - 1
     = (b(n-1) + 1)*(b(n-1) + 1 - 1)
     = (b(n-1) + 1)*b(n-1)
     = b(n-1)^2 + b(n-1)

यह क्रम बहुत समान है लेकिन हम वेतन वृद्धि को समाप्त कर सकते हैं, जो इस कार्यक्रम में एक बाइट को बचाने के लिए होता है।

तो यहाँ एनोटेट स्रोत कोड है:

^{टिमवी के हेक्सागोनीकॉलर के साथ बनाया गया ।}

और यहाँ एक स्मृति आरेख है (लाल त्रिकोण स्मृति सूचक की प्रारंभिक स्थिति और अभिविन्यास दिखाता है):

^{टिमवी के एसोटेरिकाइड के साथ बनाया गया ।}

कोड ग्रे पथ पर शुरू होता है जो बाएं कोने को लपेटता है, इसलिए प्रारंभिक रैखिक बिट निम्न है:

1{?)(
1      Set edge b(1) to 1.
 {     Move MP to edge N.
  ?    Read input into edge N.
   )(  Increment, decrement (no-op).

फिर कोड हिट होता है <जो एक शाखा है और मुख्य लूप की शुरुआत (और अंत) को इंगित करता है। जब तक एन एज का एक सकारात्मक मूल्य है, तब तक हरे रंग का पथ निष्पादित किया जाएगा। वह रास्ता ग्रिड के चारों ओर कुछ बार घूमता है, लेकिन यह वास्तव में पूरी तरह से रैखिक है:

""~&}=.*}=+={....(

.इसलिए वास्तविक कोड है, कोई-ऑप्स हैं:

""~&}=*}=+={(
""             Move the MP to edge "copy".
  ~            Negate. This is to ensure that the value is negative so that &...
   &           ...copies the left-hand neighbour, i.e. b(i).
    }=         Move the MP to edge b(i)^2 and turn it around.
      *        Multiply the two copies of b(i) to compute b(i)^2.
       }=      Move the MP back to edge b(i) and turn it around.
         +     Add the values in edges "copy" and b(i)^2 to compute
               b(i) + b(i)^2 = b(i+1).
          ={   Turn the memory pointer around and move to edge N.
            (  Decrement.

एक बार जब यह decrementing कम कर देता है Nके लिए 0, लाल पथ निष्पादित किया जाता है:

")!@
"     Move MP back to edge b(i) (which now holds b(N)).
 )    Increment to get a(N).
  !   Print as integer.
   @  Terminate the program.

Comments

क्या आप इस पर अपना ब्रूटफॉरसर चला सकते हैं?

— कैलक्यूलेटरफ्लीन

@CalculatorFeline ब्रूट फ़ॉरेस्ट उचित समय में अधिकांश 7-बाइट प्रोग्राम (और यहां तक ​​कि केवल मान्यताओं का एक गुच्छा के साथ) कर सकता है। मैं इसे 7 बाइट्स में दूरस्थ रूप से संभव नहीं देखता।

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

इसलिए? कोशिश करने में क्या हर्ज है?

— कैलक्यूलेटरफ्लीन

@ कैलाकेटरफैलिन आलस्य। ब्रूट फॉरेसर को हमेशा मैनुअल ट्विकिंग की थोड़ी सी आवश्यकता होती है जिसे मैं व्यावहारिक रूप से 0 मौके के लिए करने के लिए परेशान नहीं हो सकता कि यह कुछ मिल जाएगा। स्क्रिप्ट का कुछ संस्करण GitHub पर है, हालांकि कोई और इसे जाने के लिए स्वतंत्र है।

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

और मैं ऐसा कैसे करूं?

— कैलक्यूलेटरफैनलाइन

Answer 4

जे, 18 14 12 बाइट्स

यह संस्करण यादृच्छिक के लिए धन्यवाद। मैं बाद में एक विस्तृत विवरण लिखने की कोशिश करूँगा।

0&(]*:-<:)2:

जे, 14 बाइट्स

यह संस्करण मीलों के लिए धन्यवाद है। ^:नीचे दिए गए एजेंडे के बजाय पावर एडवर्ब का इस्तेमाल किया । अधिक स्पष्टीकरण आने के लिए।

2(]*:-<:)^:[~]

जे, 18 बाइट्स

2:`(1+*/@$:@i.)@.*

0 अनुक्रमित।

उदाहरण

   e =: 2:`(1+*/@$:@i.)@.*
   e 1
3
   e 2
7
   e 3
43
   e 4
1807
   x: e i. 10
2 3 7 43 1807 3263443 10650056950807 113423713055421862298779648 12864938683278674737956996400574416174101565840293888 1655066473245199944217466828172807675196959605278049661438916426914992848    91480678309535880456026315554816
   |: ,: x: e i. 10
                                                                                                        2
                                                                                                        3
                                                                                                        7
                                                                                                       43
                                                                                                     1807
                                                                                                  3263443
                                                                                           10650056950807
                                                                              113423713055421862298779648
                                                    12864938683278674737956996400574416174101565840293888
165506647324519994421746682817280767519695960527804966143891642691499284891480678309535880456026315554816

व्याख्या

यह एक एजेंडा है जो इस तरह दिखता है:

           ┌─ 2:
           │    ┌─ 1
       ┌───┤    ├─ +
       │   └────┤           ┌─ / ─── *
── @. ─┤        │     ┌─ @ ─┴─ $:
       │        └─ @ ─┴─ i.
       └─ *

( (9!:7)'┌┬┐├┼┤└┴┘│─'तब का उपयोग कर उत्पन्न 5!:4<'e')

सड़ते हुए:

       ┌─ ...
       │
── @. ─┤
       │
       └─ *

शीर्ष शाखा का उपयोग एक gerund के रूप में G, और नीचे चयनकर्ता के रूप में F, यह है:

e n     <=>     ((F n) { G) n

यह लगातार फ़ंक्शन का उपयोग करता 2:है जब 0 = * n, यह है कि, जब संकेत शून्य है (इस प्रकार nशून्य है)। अन्यथा, हम इस कांटे का उपयोग करते हैं:

  ┌─ 1
  ├─ +
──┤           ┌─ / ─── *
  │     ┌─ @ ─┴─ $:
  └─ @ ─┴─ i.

निम्नलिखित में से कौन सी एक से अधिक श्रृंखला है:

            ┌─ / ─── *
      ┌─ @ ─┴─ $:
── @ ─┴─ i.

आगे घटते हुए, यह उत्पाद ( */) सेल्फ-रेफरेंस ( $:) ओवर रेंज ( i.) है।

Comments

आप 2(]*:-<:)^:[~]सूत्र a(0) = 2और का उपयोग करके 14 बाइट्स के लिए प्राप्त करने के लिए शक्ति क्रिया का उपयोग भी कर सकते हैं a(n+1) = a(n)^2 - (a(n) - 1)। बड़े मूल्यों की गणना करने के लिए, 2शुरुआत में एक विस्तारित पूर्णांक के रूप में चिह्नित करना होगा।

— मील

दोनों ही समाधान बहुत अच्छे हैं। मुझे लगता है कि मैं v`$:@.uपुनरावर्ती प्रारूप से अनजान था । मैंने हमेशा एक ^:vप्रारूप का उपयोग किया है जो अक्सर अधिक जटिल होता है। @ मीलों मैंने भी कभी (]v)तरकीब का इस्तेमाल नहीं किया । इसे समझने में मुझे 5 मिनट का समय लगा।

— रैंडमरा

पूर्णता के लिए एक 3 तरह के लूपिंग (मील की विधि का उपयोग करके 14 बाइट्स): 2(]*:-<:)~&0~](या 2:0&(]*:-<:)~])। और उन्हें 13 बाइट्स का संयोजन ]0&(]*:-<:)2:।

— बेतरतीब

12 बाइट्स: 0&(]*:-<:)2:। (क्षमा करें, मुझे टिप्पणियों में गोल्फ नहीं करना चाहिए ।)

— randomra

@randomra बॉन्ड का वास्तव में साफ-सुथरा उपयोग है। मुझे यह जानने के लिए पेज को पढ़ना था कि आम तौर पर क्या होता है क्योंकि किसी को लगता है कि मध्य क्रिया को तीन तर्क मिल रहे थे।

— मील

Answer 5

पर्ल 6 , 24 बाइट्स

{(2,{1+[*] @_}...*)[$_]}

{(2,{1+.²-$_}...*)[$_]}

व्याख्या

# bare block with implicit parameter ｢$_｣
{
  (
    # You can replace 2 with 1 here
    # so that it uses 1 based indexing
    # rather than 0 based
    2,

    # bare block with implicit parameter ｢@_｣
    {
      1 +

      # reduce the input of this inner block with ｢&infix:<*>｣
      # ( the input is all of them generated when using a slurpy @ var )
      [*] @_

      # that is the same as:
      # ｢@_.reduce: &infix:<*>｣
    }

    # keep calling that to generate more values until:
    ...

    # forever
    *

  # get the value as indexed by the input
  )[ $_ ]
}

उपयोग:

my &code = {(2,{1+[*] @_}...*)[$_]}

say code 0; # 2
say code 1; # 3
say code 2; # 7
say code 3; # 43
say code 4; # 1807

# you can even give it a range
say code 4..7;
# (1807 3263443 10650056950807 113423713055421844361000443)

say code 8;
# 12864938683278671740537145998360961546653259485195807
say code 9;
# 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
say code 10;
# 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

my $start = now;
# how many digits are there in the 20th value
say chars code 20;
# 213441

my $finish = now;
# how long did it take to generate the values up to 20
say $finish - $start, ' seconds';
# 49.7069076 seconds

Comments

एक सरणी के साथ टुकड़ा $_? यह कौन सा जादू टोना है?

— ज़ेड

Answer 6

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

f n|n<1=2|m<-f$n-1=1+m*m-m

प्रयोग उदाहरण: f 4-> 1807।

Answer 7

जावा 7, 46 42 बाइट्स

int f(int n){return--n<0?2:f(n)*~-f(n)+1;}

सामान्य सूत्र के साथ 0-अनुक्रमण का उपयोग करता है। हालाँकि, जावा के पास एक आसान पावर ऑपरेटर नहीं है, और कॉल लंबे समय से हो रही थीं , मैंने इसके लिए स्वैप n*n-nकिया ।n*(n-1)f()

Comments

f(n)*~-f(n)कार्य करना चाहिए।

— डेनिस

मैं हर बार उस ट्रिक को कैसे भूल सकता हूँ ? यदि वह सुझाव पृष्ठ पर नहीं है, तो यह निश्चित रूप से होने के बारे में है।

— Geobits

return--n<0एक और बाइट बचाता है।

— डेनिस

लेकिन जावा डेवलपर्स को वैसे भी ब्रेन-फ्लैक जाना चाहिए ।

— लीक नन

@ लीक नून अगर मैं अपने PRNG को रोल किए बिना एक साधारण डाई रोल का अनुकरण नहीं कर सकता, तो मैं इसका प्रशंसक नहीं हूं : पी

— जियोबिट्स

Answer 8

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

(iterate(\m->m*m-m+1)2!!)

Answer 9

एसआईओएस , 60 बाइट्स

readIO 
p = 2
lblL
r = p
r + 1
p * r
i - 1
if i L
printInt r

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

सी में मेरे जवाब का पोर्ट ।

Comments

Yay: D आखिरकार एक SILOS गोल्फर है, दिलचस्प बात यह है कि यह स्काला को हरा देता है :)

— रोहन झुनझुनवाला

Answer 10

ब्रेन-फ्लैक , 158 154 बाइट्स

लीक नून ने मुझे यहां हराया है

({}<(()())>){({}[()]<<>(())<>([]){{}<>({}<<>(({}<>))><>)<>({<({}[()])><>({})<>}{})<>{}([])}{}<>({}())([]){{}({}<>)<>([])}{}<>>)}{}([][()]){{}{}([][()])}{} 

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

व्याख्या

इनपुट के तहत एक दो रखो (0)

({}<(()())>) 

जबकि इनपुट शून्य से अधिक है इनपुट से एक घटाना और ...

{
({}[()]

चुप चाप...

<

गुणन <> (()) <> के लिए उत्प्रेरक के रूप में कार्य करने के लिए दूसरे स्टैक पर एक रखें

जबकि स्टैक गैर-रिक्त है

 ([])
 {
  {}

सूची के शीर्ष पर ले जाएँ और प्रतिलिपि बनाएँ

  <>({}<<>(({}<>))><>)

प्रतिलिपि द्वारा उत्प्रेरक को गुणा करें

  <>({<({}[()])><>({})<>}{})<>{}
  ([])
 }
 {}

एक जोड़ें

 <>({}())

अनुक्रम को उचित स्टैक पर वापस ले जाएं

 ([])
 {
 {}
 ({}<>)<>
 ([])
 }
 {}
 <>
>)
}{}

सभी आइटम निकालें, लेकिन नीचे की वस्तु (यानी बनाई गई अंतिम संख्या)

([][()])
{
{}
{}
([][()])
}
{}

Answer 11

सी, 32 बाइट्स

f(n){return--n?f(n)*~-f(n)+1:2;}

1-आधारित अनुक्रमण का उपयोग करता है। Ideone पर इसका परीक्षण करें ।

Answer 12

दरअसल , 9 बाइट्स

2@`rΣτu`n

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

इसके बजाय इस रिश्ते का उपयोग करता है:

जो इस संबंध से प्राप्त होता है जिसे उस क्रम से संशोधित किया गया है:

a(n+1) = a(n) * (a(n) - 1) + 1।

Answer 13

आर, 44 42 41 बाइट्स

2 बाइट्स जेडीएल के लिए धन्यवाद बचाते हैं

1 बाइट उपयोगकर्ता 5957401 के लिए धन्यवाद सहेजें

f=function(n)ifelse(n,(a=f(n-1))^2-a+1,2)

Comments

यह समस्या बयान से स्पष्ट नहीं है, लेकिन जब तक nकरने के लिए गारंटी है नकारात्मक तो हालत से कम किया जा सकता नहीं हो n>0सिर्फ करने के लिए n।

— JDL

@JDL अच्छा लगा! धन्यवाद !

— मैमी

f(n-1)6 बाइट्स है। मुझे लगता है कि आप किसी चीज को असाइन करके एक बाइट को बचाते हैं। यानीifelse(n,(a=f(n-1))^2-a+1,2)

— user5957401

Answer 14

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

संभवतः गोल्फ परिवार से मेरी आखिरी भाषा! गैर-प्रतिस्पर्धात्मक, चूंकि भाषा चुनौती का सामना करती है।

कोड:

²->2

वैकल्पिक समाधान Zwei के लिए धन्यवाद :

<*>2

विस्तारित संस्करण:

a(n) = ²->
a(0) = 2

स्पष्टीकरण:

²    # Stack is empty, so calculate a(n - 1) ** 2.
 -   # Subtract, arity 2, so use a(n - 1).
  >  # Increment by 1.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

अंतिम गोल्फ भाषा? आप कोई और बनाने नहीं जा रहे हैं? डी:

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

@ ConorO'Brien शायद, मैं अब विचारों से बाहर हूँ :(

— अदनान

इस चुनौती को देखने से पहले, मैंने b<*>2प्रयोग कियाa(n-1)*(a(n-1)+1)-1

— ज़ीवेई

@Zwei बहुत साफ! आप वास्तव में बाहर छोड़ सकते हैं bक्योंकि स्वचालित रूप से (इनपुट के बजाय) :) में भर जाएगा।

— अदनान

हाँ, मैंने देखा कि पोस्ट करने के बाद। मुझे आश्चर्य है कि यह भाषा इसके लिए कितनी अच्छी तरह काम करती है, भले ही इसे दृश्यों के लिए डिज़ाइन किया गया हो।

— ज़ेविए

Answer 15

पायथन, 38 36 बाइट्स

डेनिस के लिए 2 बाइट्स धन्यवाद।

f=lambda n:0**n*2or~-f(n-1)*f(n-1)+1

Ideone यह!

इसके बजाय इस अनुक्रम में प्रदान किए गए इस संबंध का उपयोग करता है:

a(n+1) = a(n) * (a(n) - 1) + 1

व्याख्या

0**n*22जब n=0और 0अन्यथा, क्योंकि रिटर्न को पायथन में 0**0होना परिभाषित किया 1गया है।

Answer 16

चेडर , 26 बाइट्स

n g->n?g(n-=1)**2-g(n)+1:2

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

बहुत मुहावरेदार।

व्याख्या

n g ->    // Input n, g is this function
  n ?     // if n is > 1
    g(n-=1)**2-g(n)+1   // Do equation specified in OEIS
  : 2     // if n == 0 return 2

Comments

अब 4 बार (लगभग)

— लीक नून

आपने TIO लिंक को क्यों हटाया?

— लीक नून

@ LeakyNun ओह, जब मैं था तब आप संपादन कर रहे होंगे

— डाउगोएट

Answer 17

सीजेएम, 10 बाइट्स

2{_(*)}ri*

0-आधारित अनुक्रमण का उपयोग करता है। इसे ऑनलाइन आज़माएं!

Answer 18

05AB1E , 7 बाइट्स

2sFD<*>

व्याख्या की

शून्य-आधारित अनुक्रमण का उपयोग करता है।

2         # push 2 (initialization for n=0)
 sF       # input nr of times do
   D<*    # x(x-1)
      >   # add 1

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

Answer 19

प्रोलॉग, 49 बाइट्स

a(0,2).
a(N,R):-N>0,M is N-1,a(M,T),R is T*T-T+1.

Answer 20

SILOS 201 बाइट्स

readIO 
def : lbl
set 128 2
set 129 3
j = i
if j z
print 2
GOTO e
:z
j - 1
if j Z
print 3
GOTO e
:Z
i - 1
:a
a = 127
b = 1
c = 1
:b
b * c
a + 1
c = get a
if c b
b + 1
set a b
i - 1
if i a
printInt b
:e

इसे ऑनलाइन आज़माने के लिए स्वतंत्र महसूस करें !

Comments

क्या चल रहा है

— TuxCrafting

@ T @xCräftîñg जादू टोना

— रोहन झुनझुनवाला

Answer 21

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

²_’
2Ç¡

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

इसके बजाय अनुक्रम में दिए गए इस संबंध का उपयोग करता है: a(n+1) = a(n)^2 - a(n) + 1

व्याख्या

2Ç¡   Main chain, argument in input

2     Start with 2
  ¡   Repeat as many times as the input:
 Ç        the helper link.


²_’   Helper link, argument: z
²     z²
  ’   z - 1
 _    subtraction, yielding z² - (z-1) = z² - z + 1

Answer 22

सी, 46 बाइट्स

s(n,p,r){for(p=r=2;n-->0;p*=r)r=p+1;return r;}

Ideone यह!

pउत्पाद के अस्थायी भंडारण के रूप में उपयोग करता है ।

मूल रूप से, मैंने दो अनुक्रमों को परिभाषित किया है p(n)और r(n), कहां r(n)=p(n-1)+1और p(n)=p(n-1)*r(n)।

r(n) आवश्यक अनुक्रम है।

Comments

किसी भी कारण से आप अपने पायथन उत्तर से समान संबंध का उपयोग नहीं कर रहे हैं? यह बहुत छोटा होना चाहिए ...

— डेनिस

@ डेनिस यह अधिक दिलचस्प है।

— लीक नन

@ डेनिस और इस उत्तर को पोर्ट

— लीक नून

Answer 23

आर, 50 46 44 बाइट्स

    n=scan();v=2;if(n)for(i in 1:n){v=v^2-v+1};v

पूरे अनुक्रम को ट्रैक करने के बजाय, हम केवल उत्पाद का ट्रैक रखते हैं, जो दिए गए द्विघात अद्यतन नियम का पालन करते हैं जब तक n> 1 n> 0। (यह क्रम " एक शून्य पर प्रारंभ " सम्मेलन का उपयोग करता है )

शून्य कन्वेंशन में शुरुआत का उपयोग बाइट्स के एक जोड़े को बचाता है क्योंकि हम उपयोग कर सकते हैं अगर (n) इसके बजाय अगर (n> 1)

Answer 24

जेलिफ़िश , 13 बाइट्स

p
\Ai
&(*
><2

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

व्याख्या

चलो नीचे से शुरू करते हैं:

(*
<

यह एक हुक है, जो एक फ़ंक्शन को परिभाषित करता है f(x) = (x-1)*x।

&(*
><

यह इंक्रीमेंट फ़ंक्शन के साथ पिछले हुक की रचना करता है इसलिए यह हमें एक फ़ंक्शन देता है g(x) = (x-1)*x+1।

\Ai
&(*
><

अंत में, यह एक फ़ंक्शन उत्पन्न करता है hजो पिछले फ़ंक्शन का पुनरावृत्ति है g, जैसा कि कई बार पूर्णांक इनपुट द्वारा दिया गया है।

\Ai
&(*
><2

और अंत में, हम इस चलना को प्रारंभिक मूल्य पर लागू करते हैं 2। pशीर्ष पर बस परिणाम प्रिंट करता है।

वैकल्पिक (13 बाइट्स भी)

p
>
\Ai
(*
>1

यह बहुत अंत तक वेतन वृद्धि को रोकता है।

Answer 25

सी, 43 , 34 , 33 बाइट्स

1 अनुक्रमित:

F(n){return--n?n=F(n),n*n-n+1:2;}

टेस्ट मुख्य:

int main() {
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(4));
  printf("%d\n", F(5));
}

Answer 26

ब्रेकीलॉग , 13 बाइट्स

0,2|-:0&-y+*+

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

इसके बजाय इस रिश्ते का उपयोग करता है:

जो इस संबंध से प्राप्त होता है जिसे उस क्रम से संशोधित किया गया है:

a(n+1) = a(n) * (a(n) - 1) + 1।

Answer 27

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

Nest[#^2-#+1&,2,#]&

---

या 21 बाइट्स:

Array[#0,#,0,1+1##&]&

Comments

Arrayसमाधान जादुई है। बहुत बुरा है, ##0कोई बात नहीं है। ;)

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

Answer 28

भूलभुलैया , 18 बाइट्स

Sp3000 को क्रेडिट जो स्वतंत्र रूप से एक ही समाधान मिला।

?
#
)}"{!@
* (
(:{

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

Answer 29

दरअसल , 14 12 बाइट्स

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

2#,`;πu@o`nF

Ungolfing:

2#              Start with [2]
  ,`     `n     Take 0-indexed input and run function (input) times
    ;           Duplicate list
     πu         Take product of list and increment
       @o       Swap and append result to the beginning of the list
           F    Return the first item of the resulting list

Answer 30

GolfScript , 12 10 बाइट्स

डेनिस के लिए 2 बाइट्स धन्यवाद।

~2\{.(*)}*

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

उपयोग करता है a(n) = a(n-1) * (a(n-1)-1) + 1।

Comments

(के लिए कम है 1-; )के लिए छोटा है 1+।

— डेनिस

@ डेनिस धन्यवाद, मुझे एक विशेष प्रकार का बेवकूफ होना चाहिए।

— लीक