पॉइंटर सीक्वेंस बनाएं

12

चलो एक सूचक अनुक्रम निर्धारित किसी भी क्रम में इस तरह है कि एक (एन) = एक ((n-1) - (क (n-1))) forall n कुछ निश्चित संख्या से अधिक। उदाहरण के लिए यदि हमारे अनुक्रम के साथ शुरू हुआ

3 2 1

हमारा अगला कार्यकाल होगा 2, क्योंकि a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (यह उदाहरण शून्य इंडेक्स है, हालांकि इससे कोई फर्क नहीं पड़ता कि आप किस इंडेक्स का उपयोग गणना में करते हैं। हमेशा समान रहें।) यदि हम इस प्रक्रिया को दोहराते हैं तो हमें अनंत अनुक्रम मिलते हैं

3 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2

कार्य

सकारात्मक पूर्णांक के कुछ प्रारंभिक सरणी को देखते हुए सूचक क्रम उस सरणी से शुरू होता है।

आउटपुट प्रकार

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

आप दो इनपुट, शुरुआती सरणी और एक इंडेक्स भी चुन सकते हैं। यदि आप ऐसा करने के लिए चुनते हैं, तो आपको केवल उस सूचकांक में अनुक्रम की अवधि का आउटपुट चाहिए।

आपको कभी भी एक अनुक्रम नहीं दिया जाएगा जिसे अनुक्रम की शुरुआत से पहले अनुक्रमण की आवश्यकता होती है। उदाहरण के लिए 3एक वैध इनपुट नहीं है क्योंकि 3अगले कार्यकाल को हल करने से पहले आपको शर्तों की आवश्यकता होगी ।

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

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

परीक्षण के मामलों को सरलता के लिए काट दिया जाता है

2 1   -> 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 ...
2 3 1 -> 2 3 1 3 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 ...
3 3 1 -> 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 ...
4 3 1 -> 4 3 1 3 4 4 3 3 4 4 4 3 4 4 4 4 3 4 4 4 4 3 4 4 4 4 3 4 ...
code-golf  sequence 
— एड हॉक गार्फ हंटर
स्रोत
क्या इनपुट सरणी के अतिरिक्त n अतिरिक्त शब्दों को आउटपुट करने की अनुमति है ? या एन- वें शब्द इनपुट के रूप में प्रदान किए जाने के बाद शुरू होता है?
— लुइस मेन्डो
@LuisMendo किसी भी अनुक्रमण ठीक है।
— तदर्थ गार्फ हंटर

जवाबों:

8

जावास्क्रिप्ट (ईएस 6), 25 बाइट्स

a=>f=n=>a[n]||f(--n-f(n))

एक अनाम फ़ंक्शन जिसे कहा जाता है, एक फ़ंक्शन बनाता है fजो किसी दिए गए इंडेक्स में अनुक्रम में आइटम देता है।

कृपया मुझे बताएं कि क्या मैंने कुछ गलत समझा है ...

— ETHproductions
स्रोत
आप फोन f(n)में से f(n)। मुझे नहीं लगता कि यह कभी समाप्त होगा, लेकिन मैं जेएस को नहीं जानता।
— तदर्थ गार्फ हंटर
@FunkyComputerMan जब nपर्याप्त रूप से कम हो जाता है a[n], तो एक सत्य मूल्य वापस आ जाएगा, इसलिए ||शॉर्ट-सर्किट और इसे असीम रूप से पीछे हटने से रोक देगा।
— ETHproductions
हाँ, मुझे वह मिल गया है लेकिन nप्रत्येक कॉल के साथ कोई भी कम नहीं मिलता है। मुझे पूरा यकीन है कि अगर आप nकी लंबाई से अधिक है तो aआप कभी रुकेंगे नहीं।
— तदर्थ गार्फ हंटर
2
@FunkyComputerMan यह प्रत्येक कॉल, साथ कम मिल जाता --nअसाइन nकरने के लिए n-1तो यह करने के लिए अगले संदर्भ कम कर के पास भेजेगा n।
— आउटगोल्फ़र
2
@FunkyComputerMan --ndecrements n, जिसका अर्थ है कि f(--n-f(n))समान हैf((n-1)-f(n-1))
— ETHproductions
5

भूसी , 7 6 बाइट्स

¡S!o_L

एक अनंत सूची देता है। इसे ऑनलाइन आज़माएं! ध्यान दें कि TIO को परिणाम को छोटा करने और प्रिंट करने में कुछ समय लगता है।

व्याख्या

ऑपरेटर ¡के कई अर्थ हैं। यहां मैं "फ़ंक्शन का निर्माण करके अनंत सूची का उपयोग कर रहा हूं जो मौजूदा तत्वों की सूची से एक नए तत्व की गणना करता है"। लंबाई N की सूची को देखते हुए , नए तत्व में 1-आधारित इंडेक्स N + 1 होगा । हम सभी को सूची के अंतिम तत्व (जो पिछले मूल्य है) और परिणाम का उपयोग करके सूची में सूचकांक को नकारने की आवश्यकता है।

¡S!o_L  Implicit input.
¡       Construct infinite list by iterating this function on input:
 S!      Element at index
    →    last element
  o_     negated.
— Zgarb
स्रोत
4

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

एक सूची लेता है और अनुक्रम को अनुक्रमित करने वाला एक फ़ंक्शन देता है

l!n|n<length l=l!!n|e<-n-1=l!(e-l!e)

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

व्याख्या

यहां हम एक फ़ंक्शन को परिभाषित कर रहे हैं !जो एक सूची lऔर एक सूचकांक लेता है n। यदि हम द्वारा अनुक्रमणिका nकी लंबाई से कम है , अन्यथा हम वापस लौटते हैं । यह प्रश्न में दिए गए फ़ंक्शन की पुनरावर्ती परिभाषा का अनुसरण करता है।llnl!((n-1)-l!(n-1))

यहाँ एक ही कार्यक्रम अनगढ़ है।

a l n
 |n<length l = l!!n
 |otherwise = (a l) ((n-1) - (a l) (n-1))

मैं का उपयोग करें e<-n-1अन्यथा के बजाय जबकि बताए बाइट्स को बचाने के लिए n-1करने के लिए eतो यह बाद में इस्तेमाल किया जा सकता।

— एड हॉक गार्फ हंटर
स्रोत
4

MATL , 13 9 बाइट्स

:"tt0)_)h

N के बाद एक अतिरिक्त पॉजिटिव (पूर्णांक ) चुनौती के रूप में लिया गया एक प्रारंभिक पूर्णांक है जहां n अतिरिक्त शर्तों (चुनौती द्वारा अनुमत), के बाद प्रारंभिक शब्द आउटपुट ।

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

व्याख्या

:"      % Implicitly input n. Do the following n times
  tt    %    Duplicate the sequence so far, twice. In the first iteration this
        %    implicitly inputs the array of initial terms
  0)    %    Get value of the last entry, say m
  _)    %    Get value of the entry which is m positions back from the last
  h     %    Append. This extends the array with the new entry
        % Implicit end. Implicitly display
— लुइस मेंडो
स्रोत
2

मानक एमएल (एमएलटन) , 58 बाइट्स

fun a$n=if n<length$then List.nth($,n)else a$(n-1-a$(n-1))

इसे ऑनलाइन आज़माएं! फ़ंक्शन aप्रारंभिक सूची और एक इंडेक्स लेता है और उस इंडेक्स पर अनुक्रम तत्व देता है। उदाहरण उपयोग: a [4,3,1] 5पैदावार 4।

— Laikoni
स्रोत
2

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

NṪịṭµ¡

एक अनुक्रम S और एक पूर्णांक k लेता है , और S के लिए k शब्द जोड़ता है ।

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

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

NṪịṭµ¡  Main link. Left argument: S (sequence). Right argument: k (integer)

    µ¡  Combine the links to the left into a (variadic) chain and call it k times.
        The new chain started by µ is monadic, so the chain to the left will be
        called monadically.
N           Negate; multiply all elements in S by -1.
 Ṫ          Tail; retrieve the last element, i.e., -a(n-1).
  ị         At-index; retrieve the element of S at index -a(n-1).
            Since indexing is modular and the last element has indices n-1 and 0,
            this computes a( (n-1) - a(n-1) ).
   ṭ        Tack; append the result to S.
— डेनिस
स्रोत
1

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

{{(_j-j}j}

CJam के लिए, यह बहुत अच्छा करता है (यह भी 05ab1e धड़कता है!)।

यह एक गुमनाम ब्लॉक है जो i nस्टैक पर फॉर्म में इनपुट की अपेक्षा करता है , जहां iअनुक्रम में सूचकांक है और nसंख्याओं की एक सरणी है।

यह इतनी अच्छी तरह से काम करता है इसका कारण jऑपरेटर है, जो शुरुआती मूल्यों के एक सेट से यादगार पुनरावृत्ति प्रदान करता है।

स्पष्टीकरण:

{    Function j(n) with [j(0), j(1), j(2)] = [4, 3, 1], return j(6):
 (    Decrement:    5
 _    Duplicate:    5 5
 j    j(5):
  (    Decrement:   5 4
  _    Duplicate:   5 4 4
  j    j(4):
   (    Decrement:  5 4 3
   _    Duplicate:  5 4 3 3
   j    j(3):
    (    Decrement: 5 4 3 2
    _    Duplicate: 5 4 3 2 2
    j    j(2) = 1:  5 4 3 2 1
    -    Subtract:  5 4 3 1
    j    j(1) = 3:  5 4 3 3
   -    Subtract:   5 4 0
   j    j(0) = 4:   5 4 4
  -    Subtract:    5 0
  j    j(0) = 4:    5 4
 -    Subtract:     1
 j    j(1) = 3:     3
}j   End:           3
— फल तोड़ना
स्रोत
1

जावा (8), 60 बाइट्स

int a(int[]a,int n){return n<a.length?a[n]:a(a,--n-a(a,n));}

दो इनपुट (पूर्णांक-सरणी aऔर पूर्णांक n) लेता है , और nअनुक्रम के 'वें मान' को आउटपुट करता है ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (कुछ सेकंड लग सकते हैं।)

int a(int[]a,int n){        // Method with int[] and int parameters and int return-type
  return n<a.length?        //  If input `n` is smaller than the length of the array:
          a[n]              //   Output the `n`'th item of the array
         :                  //  Else:
          a(a,--n-a(a,n));  //   Recursive call with `n-1-a(n-1)`
}                           // End of method
— केविन क्रूज़सेन
स्रोत
0

पर्ल, 38 +3 (-नल) बाइट्स

{print;push@F,$_=$F[$#F-$F[$#F]];redo}

यह ऑनलाइन की कोशिश करो

— नहुएल फौलीउल
स्रोत
आपका TIO लिंक एक अलग कार्यक्रम में जाता है।
— Xcali
@Xcali मैंने लिंक को ठीक कर दिया, लेकिन निष्पादित नहीं कर सका क्योंकि सर्वर के साथ कनेक्शन स्थापित नहीं किया जा सका।
— नहुएल फौलीउल
0

05AB1E , 20 बाइट्स

#`r[=ˆŽ¼}[¯¾¯¾è-è=ˆ¼

इनपुट को अंतरिक्ष-पृथक स्ट्रिंग के रूप में अपेक्षा करता है, अनिश्चित काल तक आउटपुट देता रहता है; बहुत सीधा कार्यान्वयन

उदाहरण रन:

$ 05ab1e -e '#`r[=ˆŽ¼}[¯¾¯¾è-è=ˆ¼' <<< '3 2 1'
3
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
— user4867444
स्रोत
0

जावा (ओपनजेडके 8) , 95 93 91 90 बाइट्स

a->i->{int j=0,b[]=new int[++i];for(;j<i;j++)b[j]=j<a.length?a[j]:b[~-j-b[j-1]];return b;}

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

— रॉबर्टो ग्राहम
स्रोत
के b[(j-1)-...]बराबर नहीं है b[~-j-...]?
— जोनाथन फ्रीच
आप बाइट को बचाने के j>=a.lengthलिए टर्नरी को उल्टा कर सकते हैं :। इसके अलावा मैं उत्सुक हूं: आप लूप एप्रोच के साथ क्यों गए, जब रिकर्सिव एप्रोच जो कि चैलेंज डिस्क्रिप्शन में भी बताया गया है वह सिर्फ 60 बाइट्स है? j<a.lengthj<a.length?a[j]:b[~-j-b[j-1]]
— केविन क्रूज़सेन
मैं तरीकों और AFAIK के साथ जवाब देना पसंद नहीं करता हूं एक आत्म-संदर्भित फ़ंक्शन को एक पूर्ण कार्यक्रम उत्तर की आवश्यकता है
— रॉबर्टो ग्राहम
@RobertoGraham नहीं, एक पुनरावर्ती विधि एक लंबोदर नहीं हो सकती है, इसलिए एक जावा 7 शैली विधि होनी चाहिए। लेकिन यह अभी भी पूर्ण कार्यक्रम के बजाय एक (जावा 7 शैली) विधि पोस्ट करने की अनुमति है।
— केविन क्रूज़सेन
@ केविनक्रूजसेन मैंने आपके उत्तर को एक द्विअर्थी बना दिया है, इसे ऑनलाइन आज़माएं! । यह संभव है, लेकिन आपको पूरे कार्यक्रम को पोस्ट करने की आवश्यकता है क्योंकि यह मुख्य संदर्भ देता है
— रॉबर्टो ग्राहम
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.