फाइबोनैचि कक्षाओं की गणना

13

यदि हम एक पूर्णांक-जैसे अनुक्रम को f k (n) = (f k (n-1) + f k (n-2))% k के रूप में परिभाषित करते हैं , तो कुछ पूर्णांक k के लिए (जहाँ % modulo ऑपरेटर है) अनुक्रम जरूरी, चक्रीय होगा वहाँ केवल हैं, क्योंकि k 2 अलग-अलग मान (च कश्मीर (n-1), च कश्मीर (n-2)) । हालांकि, इस चक्र आम तौर पर शामिल नहीं है सब , मूल्यों के संभावित जोड़े तो दो शुरू करने मूल्यों के आधार पर च कश्मीर (0) और च कश्मीर (1) , हम विभिन्न चक्रों मिल सकता है। उदाहरण के लिए, k = 2 के लिए, हम पहले दो मूल्यों के आधार पर निम्नलिखित चार संभावनाएं हैं:

0, 0, 0, 0, 0, 0, 0, 0, 0, ...
0, 1, 1, 0, 1, 1, 0, 1, 1, ...
1, 0, 1, 1, 0, 1, 1, 0, 1, ...
1, 1, 0, 1, 1, 0, 1, 1, 0, ...

अनुक्रमों की चक्रीय प्रकृति के कारण, यहां वास्तव में केवल दो मौलिक अलग-अलग क्रम हैं, कक्षाओं के साथ (0) और (0, 1, 1) । आइए देखें k = 3 :

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...
0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, ...
0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, ...
1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, ...
1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, ...
1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, ...
2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, ...
2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, 2, ...
2, 2, 1, 0, 1, 1, 2, 0, 2, 2, 1, 0, 1, 1, 2, 0, ...

फिर, केवल दो अलग-अलग कक्षाएँ हैं: (0) और (0, 1, 1, 2, 0, 2, 2, 1) ।

उच्च k के लिए हम अधिक कक्षाएँ प्राप्त कर सकते हैं, लेकिन वे अभी भी तुलनात्मक रूप से छोटी कक्षाओं में आते हैं। उदाहरण के लिए k = 4 चार कक्षाओं (0) , (0,1,1,2,3,1) , (0, 2, 2) , (0, 3, 3, 2, 1, 3) और k की पैदावार करता है। = 5 तीन कक्षाएँ (0) , (0, 1, 1, 2, 3, 0, 3, 3, 1, 4, 4, 4, 4, 3, 2, 2, 2, 4, 1) और (1, 3, 4, 2) ।

इस चुनौती में आपका काम यह गणना करना है कि दिए गए k के लिए अनुक्रम कितने परिक्रमा करता है । यह OEIS A015134 है । यहाँ पहले 100 मान हैं ( k = 1 से शुरू ):

1, 2, 2, 4, 3, 4, 4, 8, 5, 6, 14, 10, 7, 8, 12, 16, 9, 16, 22, 16,
29, 28, 12, 30, 13, 14, 14, 22, 63, 24, 34, 32, 39, 34, 30, 58, 19,
86, 32, 52, 43, 58, 22, 78, 39, 46, 70, 102, 25, 26, 42, 40, 27, 52,
160, 74, 63, 126, 62, 70, 63, 134, 104, 64, 57, 78, 34, 132, 101, 60,
74, 222, 37, 38, 62, 328, 89, 64, 82, 124, 41, 86, 42, 172, 75, 44,
184, 178, 181, 132, 82, 180, 99, 140, 104, 246, 49, 50, 114, 76

K = 11 की जांच करना सुनिश्चित करें , जो पहला इनपुट है जो k orbits से अधिक पैदावार देता है ।

नियम

आपको एक सकारात्मक पूर्णांक k दिया गया है और A015134 (k) का उत्पादन करना चाहिए ।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

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

code-golf  sequence  number-theory  combinatorics  fibonacci 
— मार्टिन एंडर
स्रोत
3
यह codegolf.stackexchange.com/q/26578/194 के करीब है कि मैं इसे एकतरफा बंद नहीं करूंगा, लेकिन मैं 5 वें वोट को डुपी के रूप में बंद करूंगा।
— पीटर टेलर

जवाबों:

3

हस्क , 17 16 बाइट्स

Lüȯ€U¡ȯ↔m%⁰∫π2ŀ⁰

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

व्याख्या

Lüȯ€U¡ȯ↔m%⁰∫π2ŀ⁰  Implicit input, say n=4.
              ŀ⁰  Lowered range: [0,1,2,3]
            π2    Cartesian second power: [[0,0],[0,1],[1,0],[0,2]..
 üȯ                Deduplicate with respect to this function:
   €U¡ȯ↔m%⁰∫       Arguments are two pairs, say a=[0,2], b=[1,1]
     ¡ȯ            Iterate on a:
           ∫       Cumulative sum,
        m%⁰        take modulo n of each,
       ↔           then reverse: [[0,2],[2,0],[2,2],[0,2],[2,0]..
    U              Cut at first repeated element: [[0,2],[2,0],[2,2]]
   €               Is b in this list? No, so they are distinct in ü.
L                 Number of remaining pairs.
— Zgarb
स्रोत
1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 76 70 बाइट्स

Tr[EdgeCycleMatrix[#->{#[[2]],Tr@#~Mod~n}&/@Tuples[Range[n=#]-1,2]]!]&

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

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

हम नियमों द्वारा दिए गए ग्राफ का निर्माण करते हैं {{0,0}->{0,0}, {1,0}->{1,1}, ...}, जो एक सामान्यीकृत फाइबोनैचि अनुक्रम के दो तत्वों को देखते हुए, अगले एक मॉड्यूल को खोजते हैं n। EdgeCycleMatrixइस ग्राफ में किनारों के चक्र से घटना मैट्रिक्स देता है; हम इसकी पंक्तियों को गिनना चाहते हैं।

(कई बिल्ट-इन हैं जो एक समान कार्य करते हैं, लेकिन ConnectedComponentsलंबा है, और FindCycleइसे काम करने के लिए बहुत सारे अतिरिक्त इनपुट की आवश्यकता है। इसके अलावा, EdgeCycleMatrixएक आयताकार सरणी है, अन्य दो की तरह मजाकिया आकार का नहीं है, जो बाद में मदद करता है। )

मैट्रिक्स की पंक्तियों को गिनने के लिए, हम प्रविष्टियों को सभी लोगों के मैट्रिक्स में बदलने के लिए, फिर ट्रेस लेते हैं। (प्रत्येक चक्र में कम से कम एक किनारा होता है और इसलिए पंक्तियों के रूप में कम से कम कई स्तंभ होते हैं - इसलिए यह पंक्तियों को गिनता है और स्तंभों को नहीं।)

— मिशा लावरोव
स्रोत
1

MATL , 38 36 बाइट्स

:qt!J*+le"@GU:"t&Zjwy+G\J*+hu]S]Xhun

इसे ऑनलाइन आज़माएं! यह अधिक से अधिक इनपुट के लिए ऑनलाइन संकलक में बार7।

व्याख्या

कोड जटिल संख्या के संदर्भ में कक्षाओं को परिभाषित करता है, जहां काल्पनिक हिस्सा नया शब्द है और वास्तविक हिस्सा फिबोनाची अनुक्रम में पूर्ववर्ती शब्द है। प्रत्येक जटिल मान अनुक्रम की स्थिति को एन्कोड करता है । अर्थात्, a+jbअगले मूल्य के रूप में गणना की जाती है b+j(a+b)।

संभव शुरुआती मूल्य के a+jbसाथ a, bमें हैं [0, 1, ..., k-1]। प्रत्येक शुरुआती मूल्य के लिए, कोड k^2बार पुनरावृत्त करता है। दरअसल, कोड को छोटा बनाने के लिए, प्रत्येक पुनरावृत्ति को अब तक संचित सभी मूल्यों पर लागू किया जाता है , और परिणाम काटे जाते हैं (जो कि वैसे भी अंत में आवश्यक होगा)। अंतिम पुनरावृत्ति के बाद, जटिल जटिल मानों के वेक्टर को सॉर्ट किया जाता है (निरपेक्ष मान से, फिर कोण से)। यह प्रत्येक कक्षा के लिए एक "हस्ताक्षर" देता है।

कार्यक्रम के अंत में, हस्ताक्षर एक सेल ऐरे में एकत्र किए जाते हैं। अद्वितीय हस्ताक्षर की संख्या वांछित आउटपुट है।

:q          % Implicit input: k. Push row vector [0, 1, ..., k-1]
t!          % Duplicate, transpose: gives column vector [0; 1; ...; k-1]
J*+         % Multiply by 1j, add with broadcast. Gives a k × k matrix of
            % values a+jb with a, b in [0, 1, ..., k-1]
le          % Linearize into a row vector
"           % For each c in that vector
  @         %   Push c
  GU:"      %   Do the following k^2 times
    t&Zj    %     Duplicate and split into real and imaginary parts: a, b
    wy+     %     Swap, duplicate, from below, add: transforms a, b into
            %     b, a+b. This is the basic step in the Fibonacci sequence
            %     In subsequent iterations a and b may be vectors instead
            %     of numbers, as they include all values obtained so far
    G\      %     Modulo k, element-wise
    J*+     %     Times 1j, add. Gives the next complex number for each of
            %     the complex numbers so far
    hu      %     Append to values so far and deduplicate. This may extend
            %     the vector of complex numbers
  ]         %   End
  S         %   Sort
]           % End
Xh          % Collect entire stack into a cell array
u           % Deduplicate
n           % Number of entries. Implicit display
— लुइस मेंडो
स्रोत
1

हास्केल , 196 191 बाइट्स

import Data.List
o(a:b)=1+o[x|x<-b,not$(0<$a)==(0<$x)&&isInfixOf a(x++x)]
o _=0
k#(a,b)=(b,mod(a+b)k)
p!(a:b)|elem a p=fst<$>p|r<-p++[a]=r!b
f k=o[[]!iterate(k#)(a,b)|a<-[0..k-1],b<-[0..k-1]]

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

इसमें शायद सुधार किया जा सके। विशेष रूप से अगर कोई isInfixOfआयात से बचने और निकालने का तरीका खोज सकता है ।

मूल विचार "राज्यों" (दो पिछले मूल्यों वाले टुपल्स) की एक सूची उत्पन्न करना है, यह देखने के लिए कि यह कब शुरू होता है। फिर हम जांचते हैं कि क्या प्रत्येक कक्षा अपने पूर्ववर्तियों के लिए अलग है (वास्तव में दूसरे तरीके से काम करती है लेकिन शब्दों में डालना मुश्किल है)। यह जाँचने के लिए कि क्या कक्षाएँ समान हैं, हम जाँचते हैं कि क्या लंबाई समान है और क्या कोई दूसरे के साथ फिट बैठता है या नहीं। उदाहरण के लिए [0,2,2], [2,2,0]: दोनों की लंबाई 3 है और [0,2,2,0,2,2]शामिल है [2,2,0]एक सतत परिणाम को के रूप में। मुझे यकीन नहीं है कि यह मूर्ख है, लेकिन यह काम करने लगता है।

संपादित करें: 5 बाइट्स उतारने के लिए लकोनी का धन्यवाद! मुझे उन युक्तियों को अधिक पढ़ना चाहिए।

— user1472751
स्रोत
1
ऐसा लगता है कि आप बचने के लिए इस टिप का उपयोग कर सकते हैं length। एक और बाइट के !साथ में बचाया जा सकता है |r<-p++[a]=r!b।
— लैकोनी
0

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

Force (k ^ 3) जानवर बल एल्गोरिथ्म के लिए क्षमा करें।

(k,x=o=0,u=[],s=(q,w,v,j=d=0)=>{while(j++<v)d|=q.reduce((a,b,i)=>a&=b==w[(i+j)%v],1);return d})=>{for(;x<k;x++)for(y=0;y<k;y++){l=2;r=[x,y];do{r.push((c=(d=r[(l+=2)-3])+r[l-4])%k,(c+d)%k)}while(!(t=r.slice(0,h=l/2)).reduce((a,b,i)=>a&=b==r[i+h],1));if(!u.reduce((q,z)=>q|=(t.length-(a=z.length)?0:s(t,z,a)),0)){o++;u.push(t)}}return o}

प्रदर्शन ... जब मैं A015134 (k = 50 से परे कुछ) की गणना कर रहा था, यह TIO पर 60 के दशक की सीमा को पार कर गया।

var g=(k,x=o=0,u=[],s=(q,w,v,j=d=0)=>{while(j++<v)d|=q.reduce((a,b,i)=>a&=b==w[(i+j)%v],1);return d})=>{for(;x<k;x++)for(y=0;y<k;y++){l=2;r=[x,y];do{r.push((c=(d=r[(l+=2)-3])+r[l-4])%k,(c+d)%k)}while(!(t=r.slice(0,h=l/2)).reduce((a,b,i)=>a&=b==r[i+h],1));if(!u.reduce((q,z)=>q|=(t.length-(a=z.length)?0:s(t,z,a)),0)){o++;u.push(t)}}return o}

for (var ix = 1; ix <= 15; ix++)
 console.log(`A015134(${ix}) = ${g(ix)}`);
स्निपेट का विस्तार करें

स्पष्टीकरण (Ungolfed)

function CheckIfSameOrbit(Array_1, Array_2, Length) { // Checks if the orbits are equal
  var d = false, j = 0;                               // Assume both have same length
  while (j < v) {                                     // Checks for different startings
    j++;                                                
    d |= Array_1.reduce(function(Acc, Item, Index) {  // Element-by-element comparison
      Acc &= Item == w[(Index + j) % v], 1);                     
    });                                               // Return true if any starting
  }                                                   // point makes two orbits identical
}

function A015134(k) {                                 // Main Program
  var o = 0, u = [];                                    
  for (var x = 0; x < k; x++) {                       // Checks different pairs of (x, y)
    for (var y = 0; y < k; y++) {
      var l = 2, r = [x, y], h = 1, t;
      do {                                            // Find until a complete orbit is
        l += 2;                                       // found (except for (0, 0) case)
        h = l / 2;
        var d = r[l - 3], c = r[l - 3] + r[l - 4];
        r.push(c % k, (c + d) % k);
        t = r.slice(0, h);
      }                                                 
      while (!t.reduce(function(Acc, Item, Index) {   // Which is, if 2 identical copies
        Acc &= Item == r[Index + h];                  // of the orbit are calculated
      }, 1));

      if (!u.reduce(function(Acc, Item) {             // If the orbit is a new one
        var a = Item.length;
        Acc |= (t.length - a ? 0 : s(t, Item, a));
      }, 0)) {
        o++;                                          // Increment the counter, and
        u.push(t);                                    // record it to the list
      }
    }
  }
  return o;                                           // Ultimately return the counter;
}
— शायरु असकोतो
स्रोत
0

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

k=>F=(a=0,b=0,C=0,q)=>q?F[q=[a,b%=k]]?0:1|F(b,a+b,C,F[q]=1):b<k?F(a,b+1,C+F(a,b,C,1)):++a<k?F(a,0,C):C

एक फ़ंक्शन देता है जो परिणाम देता है। 3 और बाइट्स के लिए हमारे पास इसका परिणाम सीधे लौट सकता है:

k=>(F=(a,b,C,q)=>q?F[q=[a,b%=k]]?0:1|F(b,a+b,C,F[q]=1):b<k?F(a,b+1,C+F(a,b,C,1)):++a<k?F(a,0,C):C)(0,0,0)

दोनों में समय जटिलता O (n 2 ) है।

— ETHproductions
स्रोत
0

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

def h(k):
 R=[]
 for p in[[i/k,i%k,(i/k+i%k)%k]for i in range(k*k)]:
	while p[:2]!=p[-2:]:
		p.append(sum(p[-2:])%k)
	p=p[:-2]
	if not any([p==x[i:]+x[:i]for i in range(len(p))for x in R]):R.append(p)
 print len(R)

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

यह बहुत कुशल नहीं है, लेकिन यह गोल्फ मैं कर सकता है।

— dylnan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.