क्या मैं एक विशेष N-bonacci नंबर हूँ?

Question

मूल रूप से इस प्रश्न में @DJMcMayhem द्वारा आविष्कार किया गया N-bonacci अनुक्रम, पूर्णांक 0 और 1 के साथ शुरू करके और फिर अगले संख्या को उत्पन्न करने के लिए पिछले N संख्याओं को जोड़कर उत्पन्न एक अनुक्रम है। N-bonacci अनुक्रम विशेष N-bonacci अनुक्रम है जो 0 और 1 के अलावा अन्य संख्याओं की एक जोड़ी के साथ शुरू होता है, जिसका नाम X और Y होगा। यदि N अनुक्रम में पहले से मौजूद शब्दों की संख्या से अधिक है, तो बस सभी उपलब्ध जोड़ें शर्तों।

उदाहरण के लिए, सामान्य फ़्रीक्वेंसी अनुक्रम में 2 का एक N होता है (पिछले दो आइटम लेता है), और एक एक्स और वाई 0 और 1, या 1 और 1, जो आप पूछते हैं पर निर्भर करता है।

आपका कार्य:

आपको एक प्रोग्राम या फ़ंक्शन लिखना है जो यह जांचता है कि एक इनपुट पूर्णांक (A) अगले तीन पूर्णांकों द्वारा उत्पन्न विशेष N-bonacci अनुक्रम का हिस्सा है (दूसरे इनपुट को N के रूप में उपयोग करके, और X और Y के रूप में तीसरा और चौथा) । सुनिश्चित करें कि आप N = 1 के विशेष मामले को संभालते हैं।

इनपुट:

चार गैर-नकारात्मक पूर्णांक, ए, एन, एक्स और वाई।

आउटपुट:

एक सत्य / मिथ्या मूल्य जो इंगित करता है कि क्या N, N, X और Y इनपुट द्वारा उत्पन्न N-bonacci अनुक्रम का हिस्सा है।

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

Input:    Output:
13,2,0,1->truthy
12,3,1,4->falsy
4,5,0,1-->truthy
8,1,8,9-->truthy
9,1,8,9-->truthy

12,5,0,1->falsy  [0,1]>[0,1,1]>[0,1,1,2]>[0,1,1,2,4]>[0,1,1,2,4,8]>[0,1,1,2,4,8,16]>etc.  

स्कोरिंग:

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

Comments

N==1ऐसा ही एक अजीब मामला है।

— मैजिक ऑक्टोपस Urn

हां, लेकिन अजीब मामले हैं जो यह मजेदार बनाते हैं :)

— ग्राईफॉन

यदि आप वास्तव में मामले को संभालने के लिए उत्तर चाहते हैं N=1, तो आप प्रश्न में इसे बाहर करना चाह सकते हैं, क्योंकि कई उत्तर (सभी वर्तमान उत्तर सहित, मुझे लगता है) की विफलता की स्थिति होगी जो एक सख्ती से बढ़ती श्रृंखला मानती है। इसके अलावा, कर सकते हैं Xऔर Yनकारात्मक हो सकता है? वह भी संभवतः सभी मौजूदा उत्तरों को अमान्य कर देगा।

— अप्सिलर्स

मुझे लगता है कि सभी मौजूदा उत्तर गैर-बढ़ते मामले को संभालने में विफल होते हैं जहां एक्स और वाई दोनों शून्य हैं। क्या उस केस को भी संभालना जरूरी है?

— अप्सिलर्स

मुझे लगता है कि आपको सत्य मामलों को जोड़ना चाहिए 8,1,8,9और 9,1,8,9यह सुनिश्चित करना चाहिए कि N=1मामले को संभालने के साथ-साथ गैर-दोहराया Xमूल्य का भी पता लगाया जाए Y। (यदि आप 0,0उन मामलों को संभालना चाहते हैं जो आपको भी जोड़ना चाहिए।)

— अप्सिलर्स

Answer 1

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

ḣ⁴S;µṀ<⁵µ¿⁵e

एक पूर्ण कार्यक्रम लेने [X,Y], N, A।

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

कैसे?

ḣ⁴S;µṀ<⁵µ¿⁵e - Main link (monadic): [X,Y]
    µ   µ¿   - while:
     Ṁ       -   maximum value of the list
       ⁵     -   5th command line argument (3rd input) = A
      <      -   less than?
             - ...do:
 ⁴           -   4th command line argument (2nd input) = N
ḣ            -   head (get the first N (or less) items from the list)
  S          -   sum
   ;         -   concatenate (add the result to the front of the list)
          ⁵  - 5th command line argument (3rd input) = A
           e - exists in the resulting list?

Comments

अति उत्कृष्ट। वैसे भी मेरे लिए काम करने लगता है। +1

— ग्रिफन

इसके बजाय उल्टे N-bonacci अनुक्रम ⁵eको अंत से हटाने के लिए A से अधिक या उसके बराबर मान तक देखें; यह बताने में बहुत आसान है कि यह काम करेगा (यह देखते हुए कि पहले दो शब्दों का क्रम परिणाम नहीं है)।

— जोनाथन एलन

परीक्षण मामलों का एक समूह बनाया, इसलिए जब तक कोई इसे विफल नहीं पाता, यह मेरे साथ अच्छा है।

— ग्राईफॉन

Answer 2

05AB1E , 18 बाइट्स

[DR²£O©‚˜³®>‹#]³QZ

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

---

उपयोग: [X,Y], N, A

---

मुझे ऐसा लगता है कि कुछ अनपेक्षित कार्यशीलता ने इसे कठिन बना दिया है।

इससे बड़ा या नहीं-के-बराबर, इससे पहले कभी ध्यान नहीं दिया गया है।

और +1 बाइट्स के लिए #³काम नहीं किया, और ए की आवश्यकता थी ।]#]³

Answer 3

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

a,n,l=input()
while l[0]<a:l=[sum(l[:n])]+l
print a in l

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

के रूप में इनपुट लेता है A,N,[X,Y]

Comments

यहाँ सभी प्रकार के परीक्षण करता है, तो आप इसे पसंद के लिए एक आवरण है।

— लीक नून

यहाँ 2 बाइट्स गॉकेटेड हैं।

— लीक नून

Answer 4

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

->\A,\N,\X,\Y{A∈(X,Y,{[+] @_.tail(N)}...*>A)}

झसे आज़माओ

विस्तारित:

->
  \A,
  \N,
  \X, \Y
{
    A          # is ｢A｣

  ∈            # an element of

    (          # this Sequence

      X, Y,        # seed values of sequence

      {            # generate the rest of the Seq using this code block

        [+]        # reduce by addition

          @_       # of all previously generated values
          .tail(N) # only use the last ｢N｣ of them
      }

      ...          # keep generating values until

      * > A        # it is greater than ｢A｣

    )
}

Answer 5

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

a,n,l=input()
while[a]>l:l=[sum(l[:n])]+l
a in l>x

के रूप में इनपुट लेता है A,N,[Y,X]। निर्गम कोड के माध्यम से आउटपुट।

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

Answer 6

आर , 69 60 बाइट्स

function(a,n,l){while(l<a)l=c(sum(l[1:n],na.rm=T),l)
a%in%l}

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

एक अनाम फ़ंक्शन, रिटर्न a,nऔर एक वेक्टर देता है l=c(y,x)। N-bonacci अनुक्रम को पीछे की ओर बनाता है (यानी, अनुक्रम में छोटा सूचकांक आगे है), क्योंकि while(l<a)केवल पहले तत्व की जांच करता है l।

Answer 7

आम लिस्प, 164 बाइट्स

(defun f(a n x y &aux(l(list y x)))(if(= n 1)(or(= a x)(= a y))(loop(if(<= a(car l))(return(member a l))(setf l(cons(reduce'+ l)(if(<(length l)n)l(butlast l))))))))

यह फ़ंक्शन NILसही ( सामान्य लिस्प के सामान्यीकृत बूलियन की परिभाषा के अनुसार) झूठे, गैर-एनआईएल के लिए लौटता है ।

(defun f(a n x y &aux (l (list y x)))    ; initialize a list l for the N values
  (if (= n 1)                            ; special case for N = 1
      (or (= a x) (= a y))               ;    true only if A = X or A = Y
      (loop
        (if (<= a (car l))               ; when the last number generated is greater than A
            (return (member a l))        ; return true if A is in the list
            (setf l (cons (reduce '+ l)  ; otherwise compute the sum of l
                          (if (< (length l) n)   ; and push it to l (truncating the list at 
                              l                  ; end if it has already size = N)
                              (butlast l))))))))

Comments

क्या आप किसी विशेष , जैसे, दोनों और / या कब , का N=1पता लगाने के लिए विशेष केस हैंडल करते हैं ? मेरे लिस्प-पढ़ने के कौशल महान नहीं हैं, लेकिन ऐसा लगता है कि आप केवल दो प्रारंभिक मूल्यों में से एक से तुलना कर सकते हैं। A12X=1 Y=2A

— अप्सिलर्स

@ अंतराल, जब N = 1 मैं केवल X के साथ A की तुलना करता हूं और Y के साथ नहीं। तो क्या मुझे इसकी तुलना दोनों के साथ सच होने पर करनी चाहिए अगर यह उनमें से एक के बराबर है? शायद इस मामले के लिए अनुक्रम अच्छी तरह से परिभाषित नहीं है?

— रेनजो

ठीक है, अब मैं देखता हूं कि प्रश्न को बदल दिया गया है, मैंने अपना उत्तर अपडेट कर दिया है।

— रेनजो

Answer 8

k, 29 बाइट्स

{x=*(*x>){(x=#y)_y,+/y}[y]/z}

इसे ऑनलाइन आज़माएं! सत्य है 1, 0मिथ्या है। इनपुट है [A;N;X,Y]।

Comments

मैंने इसे उन सभी उदाहरणों पर चलाया, जिन्हें मैंने देखा था। १ सत्य है, ० मिथ्या है।

— zgrep

@Gryphon मैंने शरीर के बजाय पाद लेख पर इनपुट स्थानांतरित कर दिया, लेकिन मैं निश्चित नहीं हूं कि आप मुझे क्या बदलना चाहते हैं। यह दोनों एक ही कार्य है।

— zgrep

ओह, मैं अब देखता हूं। मुझे लगा कि आप कोई इनपुट नहीं ले रहे हैं, लेकिन आप इसे कोड में ले रहे हैं। अब बहुत अधिक समझ में आता है। मुझे k पता नहीं है, इसलिए मैंने मान लिया कि आपने प्रश्न को गलत समझा होगा, क्योंकि यह सब आउटपुट 1 0 1 1

— Gryphon

Answer 9

PHP> = 7.1, 103 बाइट्स

for([,$n,$d,$s,$e]=$argv,$f=[$s,$e];$x<$n;)$x=$f[]=array_sum(array_slice($f,-$d));echo+in_array($n,$f);

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

Answer 10

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

(s={#3,#4};t=1;While[t<#2-1,s~AppendTo~Tr@s;t++];!LinearRecurrence[1~Table~#2,s,#^2]~FreeQ~#)&

इनपुट प्रारूप

[ए, एन X, Y]