समैक अनुक्रम की लंबाई [बंद]

Question

Sumac अनुक्रम दो पूर्णांकों के साथ शुरू होता है: t ₁ और t ₂ ।

अगला शब्द, टी ₃ , = टी ₁ - टी ₂

अधिक सामान्यतः, t _n = t _n-2 - t _n-1

अनुक्रम समाप्त होता है जब t _n <0।

आपकी चुनौती: एक प्रोग्राम या फ़ंक्शन लिखें जो एक समास अनुक्रम की लंबाई को प्रिंट करता है, टी ₁ और टी _{2 से} शुरू होता है ।

• t ₁ और t ₂ आपकी भाषा की सीमा के भीतर पूर्णांक हैं।
• मानक खामियां लागू होती हैं।

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

t1  t2       sumac_len(t1,t2)

120  71      5
101  42      3
500  499     4
387  1       3

बोनस सड़क क्रेडिट:

3    -128    1
-314 73      2

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

Comments

निकटता से संबंधित , यदि कोई डुप्लिकेट नहीं है

— श्री एक्सकोडर

यह एक अच्छी चुनौती है, लेकिन थोड़ा अस्पष्ट है। हम लेने के लिए अपेक्षा की जाती है t1और t2इनपुट के रूप में? और iपरीक्षण के मामलों में क्या है ?

— 15:32 बजे caird coinheringaahing

क्या यह गारंटी है कि t1 और t2 हैं> = 0?

— user202729

@ बेल्सिवर हुह? वह बोनस वास्तव में क्या है? बोनस आम तौर पर वैसे भी हतोत्साहित किया जाता है

— लुइस मेंडो

क्या हमें संभालना है t_1 = t_2 = 0? क्या "बोनस स्ट्रीट क्रेडिट" का मतलब है कि हमें संभालना नहीं है t_1 < 0या t_2 < 0?

— xnor

Answer 1

भूसी , 8 बाइट्स

→V<¡oG-↔

2-तत्व सूची के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

→V<¡oG-↔  Implicit input, say p=[101,42]
   ¡      Iterate on p:
       ↔    Reverse: [42,101]
    oG-     Cumulative reduce by subtraction: [42,59]
          Result is infinite list [[101,42],[42,59],[59,-17],[-17,76],[76,-93]...
 V<       Find the first index where adjacent pairs are lexicographically increasing.
          In our example [42,59] < [59,-17], so this gives 2.
→         Increment: 3

Answer 2

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

a#b|b<0=1|c<-a-b=1+b#c

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

मैं वास्तव में एक नकारात्मक संख्या के लिए मैच पैटर्न के लिए एक रास्ता था इच्छा ...

व्याख्या

a#b|b<0=1|c<-a-b=1+b#c

a#b                     -- define a function (#) that takes two arguments a and b
   |b<0                 -- if b is negative...
       =1               -- return 1
         |              -- otherwise...
          c<-a-b        -- assign a-b to c...
                =  b#c  -- and return the result of (#) applied to b and c...
                 1+     -- incremented by 1

Comments

मुझे लगता है कि स्पष्टीकरण एक बार के लिए कोड से कम स्पष्ट है। : P

— तदर्थ गार्फ हंटर

@WheatWizard यह सबसे शायद इसलिए है क्योंकि मैं स्पष्टीकरण पर चूसता हूं। : पी

— बिलकुल अमानवीय

Answer 3

भूसी , 12 11 बाइट्स

V<0t¡ȯF-↑2↔

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

जो कुछ भी लायक है, उसके लिए बोनस स्ट्रीट क्रेडिट लेता है।

व्याख्या

    ¡ȯ       Repeatedly apply the function to the right to the list of all
             previous values and collect the results in an infinite list.
          ↔  Reverse the list of previous results.
        ↑2   Take the first two values (last two results).
      F-     Compute their difference (using a fold).
   t         Discard the first element.
V<0          Find the first index of a negative value.

Answer 4

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

->a,b{(1..a).find{a<b=a-a=b}}

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

Comments

a<b=a-a=b... रूबी कैसे पार्स करती है ..?

— पूरी तरह से

Answer 5

MATL , 13 बाइट्स

`yy-y0<~]N2-&

यह नकारात्मक इनपुट (पिछले दो परीक्षण मामलों) को संभालता है।

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

व्याख्या

`        % Do...while
  yy     %   Duplicate top two elements. Implicit inputs first time
  -      %   Subtract
  y      %   Duplicate from below: push previous term
  0<~    %   Is it 0 or greater? This is the loop condition
]        % End. Proceed with next iteration if top of the stack is true
N        % Push number of elements in stack
2-       % Subtract 2
&        % Specify that the next function, namely implicit display, should
         % only display the top of the stack

Answer 6

ब्रेन-फ्लैक , 142 90 बाइट्स

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

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

बहुत कम नहीं है। इनपुट को पीछे की ओर ले जाता है।

व्याख्या

(
 (())   #Push 1
 {      #Until 0
  {}    #Pop (+1 to counter)
  <(({}({}))[({}[{}])({})])  #tn = tn-1 - tn-2
  ([(({})<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}>  #Greater than 0?
 }      #End loop
 <>     #Get rid of everything
)       #Push result

Answer 7

05AB1E , 11 बाइट्स

[DŠ-D0‹#]NÌ

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

व्याख्या

के रूप में इनपुट लेता है t2, t1

[             # start a loop
 DŠ           # duplicate top of stack and move it down 2 positions
   -          # subtract the top 2 values
    D0‹#      # if a copy of the top value is negative, break loop
        ]     # end loop
         NÌ   # push iteration index+2

Answer 8

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

(t=1;While[Last@LinearRecurrence[{-1,1},#,t++]>0];t-2)&

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

और अब @totallyhuman द्वारा नियमित रूप से उबाऊ दृष्टिकोण

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

If[#2<0,1,1+#0[#2,#-#2]]&

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

Comments

FYI करें, नियमित रूप से उबाऊ दृष्टिकोण लंबे समय तक आधे से भी कम है ।

— 18

@totallyhuman वास्तव में बोरिंग ... आप एक बाइट बचा सकते हैं #1करने के लिए#

— J42161217

Answer 9

जे , 22 बाइट्स

[:#({:,-/)^:(0<{:)^:a:

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

                  ^:a: - Repeat until the result stops changing, store the results in a list
          ^:(0<{:)     - repeat if the second term is positive
   ({:,-/)             - makes a tuple (second, first minus second)
[:#                    - number of elements in the list ([: caps the fork)

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

Answer 10

सी (जीसीसी) , 32 27 26 बाइट्स

-5 बाइट्स जीसीसी के अमानवीय दुरुपयोग के लिए धन्यवाद (टीसीसी पर भी काम करना लगता है)
-1 बाइट प्रिंसिपोलका के लिए धन्यवाद

f(a,b){a=b<0?:1+f(b,a-b);}

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

Comments

26 बाइट्स के बाद से, बी <0 1 का मूल्यांकन करता है, परिवर्तन? 1: 1 से ?: 1

— प्रिंसपॉलका

Answer 11

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

f=lambda a,b:b<0 or-~f(b,a-b)

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

रिटर्न 1 के बजाय यह सच है ।

Answer 12

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

1 के बजाय सही रिटर्न देता है ।

f=(a,b)=>b<0||1+f(b,a-b)

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

f=(a,b)=>b<0||1+f(b,a-b)

console.log(f(120,  71  )) //    5
console.log(f(101,  42  )) //    3
console.log(f(500,  499 )) //    4
console.log(f(387,  1   )) //    3

console.log('Bonus street cred:')
console.log(f(3,    -128)) //    1
console.log(f(-314, 73 ))  //    2

Comments

@totallyhuman तो आपको f(b)(a-b)कोई बचत की आवश्यकता होगी ।

— श्री एक्सकोडर

क्या होगा अगर a<0? (1 और जाने के लिए)

— user202729

अद्यतन: आपको नकारात्मक इनपुट का समर्थन करने की आवश्यकता नहीं है, लेकिन यदि आप ऐसा करते हैं तो यह अच्छा है।

— SIGSTACKFAULT

Answer 13

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

यह एक पुनरावर्ती फ़ंक्शन है जो दो तर्क लेता है, Gऔर H। वास्तव में दिए गए इनपुट पर फ़ंक्शन को कॉल करने के लिए लिंक को थोड़ा संशोधित किया गया है।

M|<H0hgH-GH

परीक्षण सूट।

Answer 14

APL (Dyalog) , 23 बाइट्स

2∘{0>-/⍵:⍺⋄(⍺+1)∇-⍨\⌽⍵}

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

कैसे?

2∘ - 2 के प्रारंभिक संचायक के साथ,

-/⍵ - अगर अगला कार्यकाल

0> - 0 से नीचे है,

⍺- संचायक वापस करें। अन्यथा,

(⍺+1) - संचायक बढ़ाएँ

∇ - और के साथ पुनरावृत्ति

-⍨\⌽⍵ - अंतिम दो आइटम उलट और अलग हो गए।

      {⍵} 8 2
8 2
      {⌽⍵} 8 2
2 8
      {-⍨\⌽⍵} 8 2
2 6

Answer 15

जावा (ओपनजेडके 8) , 44 बाइट्स

int f(int a,int b){return b<0?1:1+f(b,a-b);}

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

सबसे छोटा पुनरावृत्ति मुझे मिला (50 बाइट्स)

(a,b)->{int c=1;for(;b>=0;c++)b=a-(a=b);return c;}

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

Answer 16

डीसी , 24 बाइट्स

?[dsb-1rlbrd0<a]dsaxz1-p

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

व्याख्या

?                         # read input                | 71 120
 [dsb-1rlbrd0<a]          # push string               | [string] 71 120
                dsa       # copy top to register a    | [string] 71 120
                   x      # execute the string        | -5 27 1 1 1 1
                    z     # push length of stack      | 6 -5 27 1 1 1 1
                     1-   # decrement top by 1        | 5 -5 27 1 1 1 1
                       p  # print top

 # string in register a:

  dsb                     # copy top to register b    | 71 120
     -                    # subtract                  | 49
      1                   # push 1                    | 1 49
       r                  # swap top two elements     | 49 1
        lb                # load register b           | 71 49 1
          r               # swap top two elements     | 49 71 1
           d0<a           # if top < 0 execute register a

Answer 17

Z80 विधानसभा, 10 बाइट्स

यह संस्करण कार्य का "स्ट्रीट क्रेड" संस्करण करने का प्रयास करता है। हालांकि, सुझाए गए परीक्षण मामले के लिए जहां t1 = -314, t2 = 73 यह कार्यक्रम उत्तर "0" का उत्पादन करता है, जो स्पष्ट रूप से "2" की तुलना में थोड़ा अधिक समझ में आता है।

SumacLen:
        xor a           ; HL = t[1], DE = t[2], A is the counter
Loop:   bit 7,h
        ret nz          ; stop if HL is negative
        inc a
        sbc hl,de       ; HL = t[3], DE = t[2]
        ex de,hl        ; HL = t[2], DE = t[3]
        jr Loop

जेडएक्स स्पेक्ट्रम 48K के लिए Sjasmplus कोडांतरक का उपयोग कर लिखित परीक्षा का परीक्षण कार्यक्रम यहां डाउनलोड किया जा सकता है । एक संकलित स्नैपशॉट भी उपलब्ध है ।

Comments

संभवतः Loop: ret cइसके बजाय गैर-बोनस संस्करण का उपयोग करता है ?

— नील

हां, H के साइन बिट की जांच करने की अब जरूरत नहीं होगी। "बिट 7, एच" को हटाया जा सकता है और "रिट सी" द्वारा प्रतिस्थापित "एनजी" के साथ "इंक" बस इसके सामने चल रहा है। 8 बाइट्स पूरी तरह से।

— इंट्रोस्पेक

हाँ; 2परिणाम वास्तव में सिर्फ मेरा कार्यक्रम के साथ एक बात है।

— SIGSTACKFAULT

क्या आपका मतलब है कि 0उस परीक्षण मामले के लिए एक स्वीकार्य जवाब है? या क्या आपका मतलब है कि मेरे कार्यक्रम को आउटपुट में संशोधित करना बेहतर होगा 2?

— introspec

Answer 18

जावा (ओपनजेडके 8) , 85 75 बाइट्स

(b,c)->{int d,k=1;for(;;){if(c<0)break;else{d=c;c=b-c;b=d;k++;}}return k;};

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

ungolfed:

(b,c)->{
    int d,k=1;
    for(;;){
        if(c<0)
            break;
        else{
            d=c;
            c=b-c;
            b=d;
            k++;
        }
    }
    return k;
};

Comments

मेरा मानना ​​है कि यह लंबोदर के रूप में छोटा होगा।

— आलू ४४

@ आलू44 वास्तव में, लेकिन मेरे पास इसे करने के लिए कल नहीं था, लेकिन मैंने इसे अभी किया और 10 बाइट्स बचाए।

— लुका एच

59 बाइट्स

— सीलिंगकैट

Answer 19

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

(defun f(a b)(if(< b 0)1(1+(f b(- a b)))))

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

Answer 20

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

ब्रैड गिल्बर्ट b2gills के लिए -5 बाइट्स धन्यवाद।

{+(|@_,*-*...^0>*)}

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

स्पष्टीकरण : कोष्ठक में पूरी बात वास्तव में अनुक्रम में है ( |@_पहले 2 शब्द (= दो पैरामीटर) हैं, *-*एक ऐसा फ़ंक्शन है जो दो तर्क लेता है और उनके अंतर को लौटाता है, और * <0रोक की स्थिति है (शब्द 0 से कम है) । हम अंतिम शब्द ^को ...) के बाद छोड़ देते हैं । फिर हम +ऑपरेटर द्वारा संख्यात्मक संदर्भ को बाध्य करते हैं , जो अनुक्रम की लंबाई को पैदावार देता है।

Comments

{+(|@_,*-*...^0>*)}

— ब्रैड गिल्बर्ट

@ ब्रैडगिल्बर्ब २गिल्स: धन्यवाद। मैंने गोल्फ के साथ एक बड़ा ब्रेक लिया था, इसलिए मैं थोड़ा कठोर हूं। हालांकि मुझे जो नहीं मिलता है, वह यह है कि आपको * <0*, but why you don't need it in 0> * `... में जगह क्यों रखनी चाहिए

— Ramillies

अंतरिक्ष की जरूरत है ताकि यह भ्रमित न हो%h<a>

— ब्रैड गिल्बर्ट b2gills