पिग्गीबैक अनुक्रम

Question

मैंने हाल ही में अपना खुद का अनुक्रम बनाया (जिसे पिगीबैक अनुक्रम कहा जाता है), और यह इस तरह काम करता है:

P(1), P(2)और P(3)= 1।

सभी के लिए , P(n)जहां n>3अनुक्रम इस तरह काम करता है:

P(n) = P(n-3) + P(n-2)/P(n-1)

तो, क्रम जारी है:

P(4)= 1 + 1/1=2

P(5)= 1 + 1/2= 3/2 =1.5

P(6)= 1 + 2/(3/2)= 7/3 =2.33333...

P(7)= 2 + (3/2)/(7/3)= 37/14=2.6428571428...

P(8)= 3/2 + (7/3)/(37/14)= 529/222 =2.3828828828...

आपका कार्य, जब दिया जाता है n, P(n)तो एक अस्थायी बिंदु संख्या या (im) उचित अंश के रूप में गणना करें ।

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

अगर किसी को अनुक्रम का नाम मिल सकता है, तो कृपया तदनुसार पोस्ट को संपादित करें।

वर्तमान नेताओं: MATL और जेली (दोनों 15 बाइट्स में)।

Comments

क्या हम सूचकांक 0 पर शुरू कर सकते हैं? P(0)=1...

— nimi

क्या मैं इस क्रम को दिए गए नाम के पीछे तर्क पूछ सकता हूं?

— जॉन ड्वोरक

@JDDvorak ऐसा लगता है जैसे संख्याएं एक दूसरे को "गुल्लक" कर रही हैं।

— clismique

@ निम्मी हां, आपको अनुमति है।

— clismique

Answer 1

पायथन 2, 40 39 बाइट्स।

f=lambda x:x<4or.0+f(x-3)+f(x-2)/f(x-1)

True1 के बजाय देता है , अगर यह अनुमति नहीं है तो हम 42 बाइट्स के लिए यह कर सकते हैं:

f=lambda x:.0+(x<4or f(x-3)+f(x-2)/f(x-1))

जिस तरह से यह काम करता है वह बहुत सीधा है, .0+परिणाम को फ्लोट करने के लिए केवल चाल का उपयोग किया जाता है।

Comments

आप बीच x<4- बीच में स्पेस हटाकर एक बाइट बचा सकते हैंor

— Acrolith

पायथन 2 में, आप f(x-1.)तैरने के लिए कलाकारों का उपयोग कर सकते हैं । पायथन 3 में, आपको बिल्कुल भी कास्ट करने की आवश्यकता नहीं है।

— डेनिस

Answer 2

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

(a#b)c=a:(b#c)(a+b/c)
((0#1)1!!)

प्रयोग उदाहरण: ((0#1)1!!) 7-> 2.642857142857143। मैं अनुक्रम 0-आधारित अनुक्रमण 0, 1, 1को ठीक करने के लिए प्रारंभ करता हूं !!।

संपादित करें: @xnor ने बाइट काउंट को बदले बिना 0-आधारित से 1-आधारित इंडेक्स पर स्विच करने का एक तरीका पाया।

Comments

प्रत्यक्ष पुनरावर्ती परिभाषा की पिटाई के लिए अच्छी विधि। मुझे लगता है कि आप इनिशियल करके 1-इंडेक्स में शिफ्ट हो सकते हैं (0,1,1)।

— xnor

Answer 3

रूबी, 34 बाइट्स

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

f=->n{n<4?1r:f[n-3]+f[n-2]/f[n-1]}

Answer 4

पर्ल 6 ,  25  23 बाइट्स

{(0,1,1,1,*+*/*...*)[$_]}

{(0,1,1,*+*/*...*)[$_]}

स्पष्टीकरण:

# bare block lambda with implicit parameter ｢$_｣
{
  (
    # initial set-up
    # the ｢0｣ is for P(0) which isn't defined
    0, 1, 1, 1,

    # Whatever lambda implementing the algorithm
    * + * / *
    # { $^a + $^b / $^c }

    # keep using the lambda to generate new values until
    ...

    # Whatever (Forever)
    *

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

यह 3 के साथ शुरू होने वाले आदानों के लिए एक चूहा ( तर्कसंगत ) देता है जब तक कि परिणाम एक भाजक से बड़ा नहीं होना शुरू हो जाता है जब तक कि 64 बिट पूर्णांक में फिट हो सकता है, जिस बिंदु पर यह अंक वापस करना शुरू कर देता है ।
आखिरी रैट यह वापस आ जाएगीP(11) == 8832072277617 / 2586200337022

यदि आप चाहते हैं कि यह तैरने के बजाय परिमेय संख्याओं को वापस लौटाए तो आप इसे निम्नलिखित के लिए स्वैप कर सकते हैं जो बदले में एक फ़ाट्रैट लौटाएगा ।

{(0.FatRat,1,1,*+*/*...*)[$_]}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &piggyback = {(0,1,1,*+*/*...*)[$_]}
# */ # stupid highlighter no Perl will ever have C/C++ comments

my @test = (
  1, 1, 1, 2,
  3/2, 7/3, 37/14,
  529 / 222,
  38242 / 11109,
  66065507 / 19809356,
  8832072277617 / 2586200337022,
);

plan +@test;

for 1..* Z @test -> ($input,$expected) {
  cmp-ok piggyback($input), &[==], $expected, $expected.perl;
}

Answer 5

सी, 46 बाइट्स

float P(n){return n<4?1:P(n-3)+P(n-2)/P(n-1);}

Ideone

Answer 6

MATL , 15 बाइट्स

llli3-:"3$t/+]&

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

व्याख्या

lll       % Push 1, 1, 1
i         % Take input n
3-:       % Pop n and push range [1 2 ... n-3] (empty if n<4)
"         % For each
  3$t     %    Duplicate the top three numbers in the stack
  /       %    Pop the top two numbers and push their division
  +       %    Pop the top two numbers and push their addition
]         % End
&         % Specify that the next function, which is implicit display, will take
          % only one input. So the top of the stack is displayed

Answer 7

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

n P->n<4?1:P(n-3)+P(n-2)/P(n-1)

Ungolfed संस्करण इतना स्पष्ट है कि आपको स्पष्टीकरण की आवश्यकता नहीं है:

n P->
  n < 4 ? 1 : P(n-3) + P(n-2) / P(n-1)

मूल रूप से फ़ंक्शन तर्कों के बाद आप चर का उपयोग करने के लिए निर्दिष्ट कर सकते हैं जो फ़ंक्शन पर ही सेट किया जाएगा। क्यों? क्योंकि यह फ़ंक्शन टेल-कॉल-अनुकूलित होगा, या कम से कम होना चाहिए।

Answer 8

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

P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)

एक साधारण कार्य।

P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)

var out = '';

for (var i=1;i <= 20;i++) {
out +='<strong>'+i+':</strong> '+P(i)+'<br/>';
}

document.getElementById('text').innerHTML = out;

div {
font-family: Arial
}

<div id="text"></div>

Comments

ES6 क्यों नहीं? यह एक मीट्रिक टन बाइट्स बचाता है।

— इस्माइल मिगुएल

इस तरह:P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)

— इस्माइल मिगुएल

@IsmaelMiguel धन्यवाद सच कहूँ तो, मैं अलग Javascripts के बीच अंतर के बारे में पता नहीं है: D

— बीटा Decay

आपके लाभ के लिए, अधिकांश चुनौतियों पर, आपको केवल "बिग एरो नोटेशन" जानना होगा, जो आपको कीवर्ड का उपयोग किए बिना फ़ंक्शन बनाने की अनुमति देता है function। बिट P=n=>[...]एक अनाम फ़ंक्शन बना रहा है जो 1 पैरामीटर (एन) लेता है। इसके अलावा, ES6 पर, रिटर्न निहित हैं। तो, P=n=>5एक ऐसा फंक्शन है जो हमेशा लौटता है 5। {}यदि आपको एक से अधिक कथन (जैसे:) हों तो आपको केवल शरीर को घेरना होगा P=n=>{alert(1);console.log(1)}। चूंकि आपके पास केवल 1 (बड़ा) स्टेटमेंट (टर्नरी ऑपरेटर) है, आप भूल सकते हैं {}।

— इस्माइल मिगुएल

@IsmaelMiguel धन्यवाद, जो उपयोगी आएगा: डी

— बीटा

Answer 9

05AB1E , 18 17 बाइट्स

3Ld                # push list [1,1,1]
   ¹ÍG         }   # input-3 times do
      D3£          # duplicate list and take first 3 elements of the copy
         R`        # reverse and flatten
           /+      # divide then add
             ¸ì    # wrap in list and prepend to full list
                ¬  # get first element and implicitly print

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

लुइस मेंडो के लिए 1 बाइट धन्यवाद

Answer 10

अजगर, 20 बाइट्स

L?<b4h0+y-b3cy-b2ytb

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

Answer 11

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

ạ2,1,3߀÷2/SµḊ¡

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

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

ạ2,1,3߀÷2/SµḊ¡  Main link. Argument: n (integer)

             Ḋ   Dequeue; yield [2, ..., n].
            µ ¡  If the range is non-empty (i.e., if n > 1), execute the chain to
                 the left. If n is 0 or 1, return n.
                 Note that P(3) = P(0) + P(2)/P(1) if we define P(0) := 0.
ạ2,1,3           Take the absolute difference of n and 2, 1, and 3.
                 This gives [0, 1, 1] if n = 2, and P(0) + P(1)/P(1) = 0 + 1/1 = 1.
      ߀         Recursively apply the main each to each difference.
        ÷2/      Perform pairwise division.
                 This maps [P(n-2), P(n-1), P(n-3)] to [P(n-2)/P(n-1), P(n-3)].
           S     Sum, yielding P(n-2)/P(n-1) + P(n-3).

Answer 12

आर, 53 47 बाइट्स

f=function(N)ifelse(N>3,f(N-3)+f(N-2)/f(N-1),1)

यह जवाब बहुत साफ समारोह का उपयोग किया ifelse:ifelse(Condition, WhatToDoIfTrue, WhatToDoIfNot)

Comments

आपको return()अपने कोड से छुटकारा पाने में सक्षम होना चाहिए । लेकिन आपको अपने कार्य को पुनरावृत्ति के लिए फ़ंक्शन का नाम देना होगा

— user5957401

Answer 13

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

P@n_:=If[n<4,1,P[n-3]+P[n-2]/P[n-1]]

यहां पहले कुछ शब्द दिए गए हैं:

P /@ Range[10]
{1, 1, 1, 2, 3/2, 7/3, 37/14, 529/222, 38242/11109, 66065507/19809356}

Answer 14

दिल्लोग एपीएल, 25 बाइट्स

⊃{1↓⍵,⍎⍕' +÷',¨⍵}⍣⎕⊢0 1 1