23

आज अपने लक्ष्य पूर्णांकों को मिल रहा है एक और ख दिया गैर नकारात्मक पूर्णांक n ऐसा है कि:

(3 + sqrt (5)) ^ n = a + b * sqrt (5)

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

मानक खामियां लागू होती हैं। इसके अतिरिक्त, यह इरादा है कि आप मूल अंकगणित का उपयोग करके उपरोक्त समस्या को स्वयं कार्यान्वित करें। इसलिए आप बिल्ट-इन सटीक बीजगणित की कार्यक्षमता, तर्कसंगत, या गैर-तुच्छ गणितीय निर्माणों को लागू करने वाले कार्यों का उपयोग नहीं कर सकते हैं (उदाहरण के लिए लुकास अनुक्रम )।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण इनपुट / आउटपुट:

0 → 1, 0
1 → 3, 1
2 → 14, 6
3 → 72, 32
4 → 376, 168
5 → 1968, 880
6 → 10304, 4608
7 → 53952, 24128
8 → 282496, 126339
6 → 1479168, 661504

code-golf arithmetic

— orlp
स्रोत

3

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

((3∘×+5 1×⌽)⍣⎕)1 0

यह एक प्रोग्राम है जो इनपुट के माध्यम से लेता है ⎕।

 (         )         Monadic train:
  3∘×                3 times argument
     +               Plus
      5 1×⌽          (5 1) times the reverse
(           ⍣⎕)      Apply that function (input) times
               1 0   starting with (1 0)

अप्रैल 2015 से पहले यहां इस्तेमाल की जाने वाली सुविधाओं को अच्छी तरह से लागू किया गया था, जिससे यह उत्तर मान्य हो गया।

इसे यहाँ आज़माएँ । ध्यान दें कि tryapl.org Dyalog का एक सीमित उपसमूह है और समर्थन नहीं करता है ⎕।

— lirtosiast
स्रोत

16

ऑक्टेव, 26 बाइट्स

[3 5;1 3]**input('')*[1;0]

क्योंकि ( a + b * sqrt (5)) * (3 + sqrt (5)) = ( 3a + 5b ) + ( a + 3b) ) * sqrt (5),

इनपुट वेक्टर को गुणा करना

| 1 |    /* a = 1 */
| 0 |    /* b = 0 */

जो मैट्रिक्स द्वारा 1 = (3 + sqrt (5)) ^ 0 के लिए खड़ा है

| 3 5 |
| 1 3 |

स्वाभाविक लगता है। लूपिंग nसमय के बजाय, हम मैट्रिक्स को शक्ति तक बढ़ाते हैं nऔर फिर इसे इनपुट वेक्टर द्वारा गुणा करते हैं।

— pawel.boczarski
स्रोत

आप अपने आप को छोटा बेच रहे हैं, [3 5;1 3]**input('')*[1;0]26 बाइट्स है, 41 नहीं।

— orlp

3

@(n)[3 5;1 3]^n*[1;0](समारोह संभाल) आप पांच पात्रों को बचाने के लिए होगा, अच्छा विचार!

— दोष

14

अजगर 2, 50

a=1;b=0
exec"a,b=3*a+5*b,3*b+a;"*input()
print a,b

प्रतिनिधित्व 3+sqrt(5)करने वाली जोड़ी पर अपनी कार्रवाई द्वारा बार-बार गुणा । मैट्रिक्स द्वारा कॉलम वेक्टर और बाएं-गुणा गुणा के साथ शुरू करने के लिए बराबर ।(a,b)a+b*sqrt(5)[1,0]n[[3,5],[1,3]]

— XNOR
स्रोत

12

जूलिया, 22 20 बाइट्स

n->[3 5;1 3]^n*[1;0]

यह एक लैम्ब्डा फ़ंक्शन बनाता है जो इनपुट के रूप में एकल पूर्णांक लेता है और समाधान [ए, बी] के अनुरूप पूर्णांक के 2-तत्व वेक्टर लौटाता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसेf=n->... ।

गुणा करके शुरू करें

प्रारंभिक विस्तार

हम फिर इस समीकरण के दाहिने हाथ को 2-कॉलम मैट्रिक्स में अनुवाद कर सकते हैं, जहां पहला ए के गुणांक से मेल खाता है और दूसरा बी के गुणांक से :

मैट्रिक्स

इस मैट्रिक्स को स्वयं n बार गुणा करें , फिर कॉलम वेक्टर (1, 0) और POOF द्वारा सही गुणा करें! आउट सॉल्यूशन वेक्टर।

उदाहरण:

julia> println(f(0))
[1,0]

julia> println(f(5))
[1968,880]

— एलेक्स ए।
स्रोत

8

जे, 20 बाइट्स

+/@:*(3 5,.1 3&)&1 0

[1 0]मैट्रिक्स के साथ वेक्टर को गुणा करें[[3 5] [1 3]] n समय के ।

2 बाइट्स @algorithmshark के लिए धन्यवाद सहेजे गए।

उपयोग और परीक्षण:

   (+/@:*(3 5,.1 3&)&1 0) 5
1968 880

   (+/@:*(3 5,.1 3&)&1 0) every i.6
   1   0
   3   1
  14   6
  72  32
 376 168
1968 880

— randomra
स्रोत

Tacit adverb पार्सिंग का फायदा उठाकर आप 20 से नीचे जा सकते हैं +/ .*(3 5,:1 3&)&1 0:।

— एलगोरिदमशर्क

@ अल्गोरिद्मशर्क थैंक्स, हालांकि क्यों (+/@:*&(3 5,.1 3)&1 0)काम करता है और (+/@:*&1 0&(3 5,.1 3))नहीं? दूसरे एक बंधन को सही ढंग से नहीं करना चाहिए और पहले एक को अदला-बदली करनी चाहिए?

— रैंडम

मिल गया, जैसा कि मैंने उम्मीद की थी, वे बंधते हैं लेकिन बाहरी &पावरिंग / लूपिंग बनाता है ताकि आप पावरिंग के दौरान लेफ्ट साइड इनपुट को संशोधित कर सकें (सामान्य राइट-साइड मॉडिफिकेशन के विपरीत)।

— रैंडम

7

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

u,+*3sGyeG+sGyeGQ,1Z

uजो सामान्य रूप से कम हो जाता है, यहाँ एक बार-बार लूप के रूप में उपयोग किया जाता है। अद्यतन करने का कार्य है G-> ,+*3sGyeG+sGyeG, जहां G2 टपल है। यह कार्य अनुवाद करता है 3*sum(G) + 2*G[1], sum(G) + 2*G[1]। sहै sum, yहै *2।

— isaacg
स्रोत

मैंने आप पर रैंडम का जवाब चुना क्योंकि उसका / उसकी 16 मिनट पहले पोस्ट किया गया था, क्षमा करें।

— orlp

5

एपीएल (22)

{⍵+.×⍨2 2⍴3 5 1}⍣⎕⍨2↑1

स्पष्टीकरण:

{... }⍣⎕⍨2↑1: एक नंबर पढ़ें, और निम्न फ़ंक्शन को चलाएं जो कई बार, [1,0]प्रारंभिक इनपुट के रूप में उपयोग करते हैं ।
- 2 2⍴3 5 1: साँचा [[3,5],[1,3]]
- ⍵+.×⍨: multip में पहले नंबर को 3 से गुणा करें, दूसरे को 5 से और उन्हें योग करें, यह नया पहला नंबर है; फिर पहले नंबर को, 1 से गुणा करें, दूसरे को 3 से, और उन्हें योग करें, यही नया दूसरा नंबर है।

— मारीनस
स्रोत

1

Awww yiss, APL।

— नाइट

5

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

5W×U++Ḥ
2BÇ³¡

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

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

5W×U++Ḥ    Helper link. Argument: [a, b]

5W         Yield [5].
  ×U       Multiply it by the reverse of [a, b]. This yields [5b, a].
    +      Hook; add the argument to the result. This yields [a + 5b, a + b].
     +Ḥ    Fork; add the doubled argument ([2a, 2b]) to the result.
           This yields [3a + 5b, a + 3b].

2BÇ³¡      Main link. Argument: n

2B         Convert 2 to binary, yielding [1, 0].
    ¡      Repeat:
  Ç            Apply the helper link...
   ³           n times.

— डेनिस
स्रोत

नहीं, मुझे पूरा यकीन है कि जेली इंटरनेट के निर्माण से पहले एक लंबे समय के आसपास थी: पी

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

1

@ Do @ गैर-प्रतिस्पर्धात्मक उत्तर के लिए, मैं बाइट की गिनती को दूसरी पंक्ति में रखना पसंद करता हूं। यह लीडरबोर्ड और उपयोगकर्ताओं में शीर्ष पर उठने से उत्तर रखता है, जो अनुचित लगता है।

— डेनिस

3

गणितज्ञ, ३१

Nest[{{3,5},{1,3}}.#&,{1,0},#]&

— alephalpha
स्रोत

3

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

0X{_2$3*+@5*@3*+}li*p

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

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

0X       " Stack: [ 0 1 ]                                ";
li{      " Do int(input()) times:                        ";
  _2$    " Stack: [ a b ] -> [ a b b a ]                 ";
  3*+    " Stack: [ a b b a ] -> [ a b (b+3a) ]          ";
  @5*@3* " Stack: [ a b (b+3a) ] -> [ (b+3a) 5a 3b ]     ";
  +      " Stack: [ (b+3a) 5a 3b ] -> [ (b+3a) (5a+3b) ] ";
}*       "                                               ";
p        " Print topmost stack item plus linefeed.       ";
         " Print remaining stack item (implicit).        ";

— डेनिस
स्रोत

3

जावास्क्रिप्ट, 63 61 बाइट्स

मैं द्विपद के पुनरावर्ती मूल्यांकन का उपयोग कर रहा हूं: (x + y) ^ n = (x + y) (x + y) ^ {n-1}

नया (@ edc65 के लिए धन्यवाद)

F=n=>{for(i=y=0,x=1;i++<n;)[x,y]=[3*x+5*y,x+3*y];return[x,y]}

पुराना

F=n=>{for(i=y=0,x=1;i<n;i++)[x,y]=[3*x+5*y,x+3*y];return [x,y]}

— flawr
स्रोत

1

अपने सूत्र के संपादन पर विचार करना चाह सकते हैं। हमारे पास अब MathJax नहीं है।

— एलेक्स ए।

मुझे लगा कि कुछ दिन पहले ही इसे शुरू किया गया था?

— मृग

हां, लेकिन इसने स्टैक स्निपेट्स को गड़बड़ कर दिया, इसलिए इसे निष्क्रिय करना पड़ा।

— एलेक्स ए।

मैं 63 के रूप में गिनता हूं, और F=n=>{for(i=y=0,x=1;i++<n;)[x,y]=[3*x+5*y,x+3*y];return[x,y]}

— edc65

n=>[...Array(n)].map(_=>[x,y]=[3*x+5*y,x+3*y],y=0,x=1)[n-1]वही लंबाई

— l4m2

2

सी, 114 बाइट्स

g(n){int i,a[2]={1,0},b[2];for(i=0;i<n;i++)*b=*a*3+5*a[1],b[1]=*a+3*b[1],*a=*b,a[1]=b[1];printf("%d,%d",*a,a[1]);}

यह मैट्रिक्स मैट्रिक्स को उबाऊ तरीके से गुणा करता है। अधिक मज़ेदार के लिए (उद्धरण: "भयानक भयानक") 238 बाइट समाधान, आगे नहीं देखो!

f(n){int p[2][n+3],i,j,k=0,a[2]={0};for(j=0;j<n+3;j++)p[0][j]=0;*p[1]=0;(*p)[1]=1;for(j=0;j<n;j++,k=!k)for(i=1;i<n+3;i++)p[!k][i]=p[k][i-1]+p[k][i];for(i=1;i<n+2;i++)a[!(i%2)]+=p[k][i]*pow(3,n+1-i)*pow(5,(i-1)/2);printf("%d,%d",*a,a[1]);}

सुलझाया:

g(n){
    int i,a[2]={1,0},b[2];
    for(i=0;i<n;i++)
        *b=3**a+5*a[1],b[1]=*a+3*b[1],*a=*b,a[1]=b[1];
    printf("%d,%d",*a,a[1]);
}

यह शायद थोड़ा छोटा किया जा सकता है। ऑनलाइन एक परीक्षण कार्यक्रम की कोशिश करो !

— BrainSteel
स्रोत

1

यह एक नहीं बल्कि

— अतिव्यापी

@orlp मैं इस भाषा के लिए एक छोटे एल्गोरिथ्म के बारे में नहीं सोच सकता। मैंने सोचा था कि यह काम करेगा, लेकिन यह हाथ से निकल गया, हाहा। मैट्रिक्स गुणा को हाथ से लागू करना बहुत कम हो सकता है।

— BrainSteel

1

अपवोट क्योंकि यह बहुत भयावह है।

— kirbyfan64sos

2

k2 - 22 चार

एक तर्क लेने का कार्य।

_mul[(3 5;1 3)]/[;1 0]

_mulआव्यूह गुणन तो हम मैट्रिक्स के साथ यह करी है (3 5;1 3): और फिर कार्यात्मक बिजली क्रिया विशेषण के साथ मारा f/[n;x]लागू होता है fकरने के लिए x, nकई बार। फिर से हम इसे करी, इस बार शुरुआती वेक्टर के साथ 1 0।

  _mul[2 2#3 5 1]/[;1 0] 5
1968 880
  f:_mul[2 2#3 5 1]/[;1 0]
  f'!8  /each result from 0 to 7 inclusive
(1 0
 3 1
 14 6
 72 32
 376 168
 1968 880
 10304 4608
 53952 24128)

यह काम नहीं करेगा Kona, क्योंकि किसी कारण के लिए f/[n;x]सही ढंग से लागू नहीं किया गया है। केवल n f/xसिंटैक्स काम करता है, इसलिए सबसे छोटा फिक्स {x _mul[(3 5;1 3)]/1 0}23 चार्ट पर है।

— algorithmshark
स्रोत

वाह। करीने का यह प्रयोग इतना स्मार्ट है कि मुझे ऐसा लग रहा है कि मेरा K उत्तर बेवकूफ है। फिर भी, मैंने आपके द्वारा उठाए गए मुद्दे को उठाया Kona उनके बग ट्रैकर पर ।

— kirbyfan64sos

FYI करें, यह हाल ही में Kona में तय किया गया था ।

— kirbyfan64sos

2

आइड, 25 बाइट्स (20 अक्षर)

({:{2,4}·x±Σx:}$1)∘1

मुझे बेहतर होने की उम्मीद थी, लेकिन इसे सक्षम बनाने के लिए ईश में बस बहुत सारे ब्रेस की आवश्यकता होती है, ऑपरेटर की वरीयता गोल्फिंग के लिए इष्टतम नहीं है।

यह इनपुट $ 1 मेमोरी स्लॉट में होने की उम्मीद करता है, इसलिए यह काम करता है:

ised '@1{9};' '({:{2,4}·x±Σx:}$1)∘1'

N = 0 के लिए, शून्य को छोड़ दिया गया है (आउटपुट 1 के बजाय 1)। यदि यह समस्या है, तो अंतिम 1को प्रतिस्थापित करें ~[2]।

— ओरियन
स्रोत

2

गंभीरता से, 32 बाइट्स, गैर-प्रतिस्पर्धात्मक

,╗43/12`╜";)@4*≈(6*-"£n.X4ì±0`n

हेक्स डंप:

2cbb34332f313260bd223b2940342af728362a2d229c6e2e58348df130606e7f

यह प्रयास करें

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

a_n = 6 * a_ {n-1} - 4 * a_ {n-2}।)

— quintopia
स्रोत

1

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

(iterate(\(a,b)->(3*a+5*b,a+3*b))(1,0)!!)

प्रयोग उदाहरण: (iterate(\(a,b)->(3*a+5*b,a+3*b))(1,0)!!) 8-> (282496,126336)।

— nimi
स्रोत

1

सी / सी ++ 89 बाइट्स

void g(int n,long&a,long&b){if(n){long j,k;g(n-1,j,k);a=3*j+5*k;b=j+3*k;}else{a=1;b=0;}}

प्रारूपित:

    void g(int n, long&a, long&b) {
if (n) {
    long j, k;
    g(n - 1, j, k);
    a = 3 * j + 5 * k;
    b = j + 3 * k;
} else {
    a = 1;
    b = 0;
}}

एक ही अवधारणा:

void get(int n, long &a, long& b) {
    if (n == 0) {
        a = 1;
        b = 0;
        return;
    }
    long j, k;
    get(n - 1, j, k);
    a = 3 * j + 5 * k;
    b = j + 3 * k;
}

परीक्षण बेंच:

#include <iostream>
using namespace std;    
int main() {
    long a, b;
    for (int i = 0; i < 55; i++) {
        g(i, a, b);
        cout << i << "-> " << a << ' ' << b << endl;
    }
    return 0;
}

उत्पादन:

0-> 1 0
1-> 3 1
2-> 14 6
3-> 72 32
4-> 376 168
5-> 1968 880
6-> 10304 4608
7-> 53952 24128
8-> 282496 126336
9-> 1479168 661504
10-> 7745024 3463680
11-> 40553472 18136064
12-> 212340736 94961664
13-> 1111830528 497225728
14-> 5821620224 2603507712
15-> 30482399232 13632143360
16-> 159607914496 71378829312
17-> 835717890048 373744402432
18-> 4375875682304 1956951097344
19-> 22912382533632 10246728974336
20-> 119970792472576 53652569456640
21-> 628175224700928 280928500842496
22-> 3289168178315264 1470960727228416
23-> 17222308171087872 7702050360000512
24-> 90177176313266176 40328459251089408
25-> 472173825195245568 211162554066534400
26-> 2472334245918408704 1105661487394848768

— philn
स्रोत

साइट पर आपका स्वागत है, और अच्छा पहला जवाब!

— DJMcMayhem

0

के, 37 बाइट्स

f:{:[x;*(1;0)*_mul/x#,2 2#3 1 5;1 0]}

या

f:{:[x;*(1;0)*_mul/x#,(3 1;5 3);1 0]}

वे दोनों एक ही चीज हैं।

— kirbyfan64sos
स्रोत

0

पायथन 3, 49 बाइट्स

w=5**0.5;a=(3+w)**int(input())//2+1;print(a,a//w)

हालांकि मेरी मशीन पर, यह केवल सीमा में इनपुट के लिए सही उत्तर देता है 0 <= n <= 18।

यह बंद फॉर्मूला लागू करता है

w = 5 ** 0.5
u = 3 + w
v = 3 - w
a = (u ** n + v ** n) / 2
b = (u ** n - v ** n) / (2 * w)

और इस तथ्य का लाभ उठाता है कि v ** nहिस्सा छोटा है, और प्रत्यक्ष गणना के बजाय गोल करके गणना की जा सकती है।

1

यह एक वैध समाधान नहीं है (आपको किसी भी n का समर्थन करना चाहिए ), लेकिन चूंकि आप कहीं नहीं हैं सबसे छोटा होने के कारण मुझे नीचा दिखाने का कोई कारण नहीं दिखता है। यह एक अच्छा समाधान है।

— orlp

0

स्कीम, 97 बाइट्स

(define(r n)(let s([n n][a 1][b 0])(if(= 0 n)(cons a b)(s(- n 1)(+(* a 3)(* b 5))(+ a(* b 3))))))

— Penguino
स्रोत

0

सी 71 बाइट्स (60 प्रारंभिक-प्रारंभिक चर के साथ)

गोल्फ के लिए स्कोप अभी तक लेकिन यह साबित करने के लिए कि सी को "भयानक रूप से भयानक" नहीं होना है।

f(int n,int*a){for(*a=1,a[1]=0;n--;a[1]=*a+3*a[1],*a=(5*a[1]+4**a)/3);}

यदि मानों को {1,0} से आरंभ किया जाता है, तो हम बेहतर करते हैं।

f(int n,int*a){for(;n--;a[1]=*a+3*a[1],*a=(5*a[1]+4**a)/3);}

यह मैपिंग a-> 3a + 5b, b-> a + 3b का उपयोग करके पुनरावृत्ति करता है, लेकिन इसके बजाय b के नए मान से गणना करके एक अस्थायी चर से बचा जाता है।

— Alchymist
स्रोत

आपका समाधान बड़े इनपुट के लिए पूर्णांक

— बनाता है

@orlp - वह आपके लिए C है। दी गई इस समाधान कोष्ठक में अंतरिम गणना के कारण दूसरों की तुलना में पहले विफल हो जाता है, लेकिन यह केवल कुछ अतिरिक्त चरणों का प्रबंधन करेगा जब तक कि मैं डेटाटाइप को नहीं बदल दूंगा। क्या यह स्पष्ट रूप से उस मूल्य को बदलने के लायक है जो आप समर्थन की उम्मीद करते हैं? शायद अब बहुत देर हो चुकी है।

— अल्छमिस्ट

समर्थन करने के लिए कोई सीमा नहीं है, किसी भी इनपुट के लिए एक उचित समाधान काम करना चाहिए। सी में इसका मतलब है कि आपको मनमाने ढंग से चौड़ाई पूर्णांक लागू करना होगा, माफ करना = /

— orlp

के a[*a=1]=0बजाय सुझाव*a=1,a[1]=0

— छत

0

(गैर-प्रतिस्पर्धी) जेली, 10 बाइट्स

31,53Dæ*³Ḣ

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

मैट्रिक्स का उपयोग करता है। गणना ([[३,१], [५,३]] ** इनपुट ()) [०]।

— लीक नन
स्रोत

गणना (3 + sqrt (5)) ^ n बिल्कुल

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

ऑक्टेव, 26 बाइट्स

अजगर 2, 50

जूलिया, 22 20 बाइट्स

जे, 20 बाइट्स

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

एपीएल (22)

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

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

गणितज्ञ, ३१

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

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

जावास्क्रिप्ट, 63 61 बाइट्स

सी, 114 बाइट्स

k2 - 22 चार

आइड, 25 बाइट्स (20 अक्षर)

गंभीरता से, 32 बाइट्स, गैर-प्रतिस्पर्धात्मक

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

के, 37 बाइट्स

पायथन 3, 49 बाइट्स

स्कीम, 97 बाइट्स

(गैर-प्रतिस्पर्धी) जेली, 10 बाइट्स