फाइबोनैचि अनुक्रम मॉड K में गुम संख्याएँ खोजें

Question

इस गणित से प्रेरित होकर । प्रश्न ।

पृष्ठभूमि

फाइबोनैचि अनुक्रम (बुलाया F) अनुक्रम, प्रारंभ हो रहा है 0, 1ऐसा है कि प्रत्येक संख्या ( F(n)) (बाद के पहले दो) यह पहले दो का योग (है F(n) = F(n-1) + F(n-2))।

एक फाइबोनैचि अनुक्रम मॉड K (कहा जाता है M) फाइबोनैचि संख्या मॉड K ( M(n) = F(n) % K) का अनुक्रम है ।

यह दिखाया जा सकता है कि फाइबोनैचि अनुक्रम मोड K सभी K के लिए चक्रीय है, जैसा कि प्रत्येक मान पिछली जोड़ी द्वारा निर्धारित किया जाता है, और केवल K के मुकाबले गैर-नकारात्मक पूर्णांकों के केवल ² संभावित जोड़े हैं, क्योंकि फाइबोनैचि मोड K इसकी पहली बार दोहराई गई जोड़ी के बाद चक्रीय है, एक संख्या जो शब्दों के पहले दोहराया जोड़ी से पहले फाइबोनैचि अनुक्रम mod K में प्रकट नहीं होती है।

K = 4 के लिए

0 1 1 2 3 1 0 1 ...

K = 8 के लिए

0 1 1 2 3 5 0 5 5 2 7 1 0 1 ...

ध्यान दें कि K = 8, 4 और 6 बार-बार सामने नहीं आते हैं 0 1, इसलिए 4 और 6 फाइबोनैचि अनुक्रम मोड 8 में कभी नहीं दिखाई देंगे।

चुनौती

पूर्णांक K को कड़ाई से 0 से अधिक होने पर, सभी गैर-ऋणात्मक पूर्णांकों का उत्पादन K से कम होता है जो कि फाइबोनैचि अनुक्रम मोड K में दिखाई नहीं देते हैं।

नियम

• डिफ़ॉल्ट कमियां निषिद्ध हैं ।

• Default मैं / हे ।

• कार्यक्रम या कार्य स्वीकार्य हैं ।

• आप मान सकते हैं कि K आपके मूल पूर्णांक प्रकार ( कारण के भीतर ) में फिट होगा ।

• यदि गैर-ऋणात्मक संख्याएँ K से कम हैं जो फाइबोनैचि अनुक्रम मॉड K में नहीं दिखाई देती हैं, तो आपके प्रोग्राम / फ़ंक्शन को ऐसे सभी नंबरों को किसी भी उचित तरीके से आउटपुट करना चाहिए।

• यदि कोई गैर-नकारात्मक पूर्णांक नहीं हैं जो K से कम हैं जो फाइबोनैचि अनुक्रम मॉड K में प्रकट नहीं होते हैं, तो आपका प्रोग्राम / फ़ंक्शन खाली सूची वापस करके, कुछ भी नहीं छापना, त्रुटि उत्पन्न करना, आदि का संकेत दे सकता है।

• आदेश मायने नहीं रखता।

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

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

ऑनलाइन परीक्षण मामलों उत्पन्न!

गैर-खाली टेस्ट केस

  8 [4, 6]
 11 [4, 6, 7, 9]
 12 [6]
 13 [4, 6, 7, 9]
 16 [4, 6, 10, 12, 14]
 17 [6, 7, 10, 11]
 18 [4, 6, 7, 9, 11, 12, 14]
 19 [4, 6, 7, 9, 10, 12, 14]
 21 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 19]
 22 [4, 6, 7, 9, 15, 17, 18, 20]
 23 [4, 7, 16, 19]
 24 [4, 6, 9, 11, 12, 14, 15, 18, 19, 20, 22]
 26 [4, 6, 7, 9, 17, 19, 20, 22]
 28 [10, 12, 14, 16, 18, 19, 23]
 29 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27]
 31 [4, 6, 9, 12, 14, 15, 17, 18, 19, 22, 25, 29]
 32 [4, 6, 10, 12, 14, 18, 20, 22, 26, 28, 30]
 33 [4, 6, 7, 9, 15, 17, 18, 20, 24, 26, 27, 28, 29, 31]
 34 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27, 28, 30]
 36 [4, 6, 7, 9, 10, 11, 12, 14, 16, 18, 20, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32]
 37 [9, 10, 14, 17, 20, 23, 27, 28]
 38 [4, 6, 7, 9, 10, 11, 12, 14, 15, 16, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 36]
 39 [4, 6, 7, 9, 15, 17, 19, 20, 22, 24, 30, 32, 33, 35]
...
200 [4, 6, 12, 14, 20, 22, 28, 30, 36, 38, 44, 46, 52, 54, 60, 62, 68, 70, 76, 78, 84, 86, 92, 94, 100, 102, 108, 110, 116, 118, 124, 126, 132, 134, 140, 142, 148, 150, 156, 158, 164, 166, 172, 174, 180, 182, 188, 190, 196, 198]
...
300 [6, 18, 30, 42, 54, 66, 78, 90, 102, 114, 126, 138, 150, 162, 174, 186, 198, 210, 222, 234, 246, 258, 270, 282, 294]
...
400 [4, 6, 10, 12, 14, 20, 22, 26, 28, 30, 36, 38, 42, 44, 46, 52, 54, 58, 60, 62, 68, 70, 74, 76, 78, 84, 86, 90, 92, 94, 100, 102, 106, 108, 110, 116, 118, 122, 124, 126, 132, 134, 138, 140, 142, 148, 150, 154, 156, 158, 164, 166, 170, 172, 174, 180, 182, 186, 188, 190, 196, 198, 202, 204, 206, 212, 214, 218, 220, 222, 228, 230, 234, 236, 238, 244, 246, 250, 252, 254, 260, 262, 266, 268, 270, 276, 278, 282, 284, 286, 292, 294, 298, 300, 302, 308, 310, 314, 316, 318, 324, 326, 330, 332, 334, 340, 342, 346, 348, 350, 356, 358, 362, 364, 366, 372, 374, 378, 380, 382, 388, 390, 394, 396, 398]
...

खाली परीक्षण मामले (कोई आउटपुट, त्रुटि, खाली सूची, आदि स्वीकार्य आउटपुट नहीं है)

1, 2, 3, 4, 5, 6, 7, 9, 10, 14, 15, 20, 25, 27, 30, 35 ... 100 ...

सम्बंधित:

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

पिसानो अवधि ज्ञात कीजिए

Comments

सैंडबॉक्स (हटाए गए)।

— pizzapants184

Answer 1

जेली , ९ by बाइट्स

²RÆḞ%ḟ@Ḷ

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

A001175p(n) <= 6n से पिजन अवधि के आधार पर । इसके अलावा, p(n) <= 6n <= n^2के लिए n >= 6और p(n) <= n^2के लिए n < 6। डेनिस की बदौलत इस बाइट को बचाया।

Comments

²के बजाय काम करना चाहिए ×6।

— डेनिस

Answer 2

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

कुछ मात्रा में बाइट्स ने Esolanging Fruit को धन्यवाद दिया

8 बाइट्स ने लिकोनी को धन्यवाद दिया

a=1:scanl(+)1a
f x=[u|u<-[2..x-1],and[mod b x/=u|(_,b)<-zip[1..x^2]a]]

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

Comments

@EsolangingFruit आह धन्यवाद! मैं अभी खुद ऐसे ही निष्कर्ष पर आ रहा था।

— गेहूं जादूगर

read$showfromIntegerइस मामले में इसके बजाय काम करता है और दो बाइट्स बचाता है।

— लैकोनी

zip[1..x^2]ट्रंकटिंग के लिए उपयोग करना कुछ और बाइट्स बचाता है: इसे ऑनलाइन आज़माएं!

— लैकोनी

@ लायकोनी को थोड़ी देर लगी लेकिन मैंने बदलाव किया। धन्यवाद, यह एक अच्छा विचार है।

— गेहूं जादूगर

Answer 3

पर्ल 6 ,  43 42 39  32 बाइट्स

{^$_ (-)(1,1,(*+*)%$_...->\a,\b{!a&&b==1})}

झसे आज़माओ

{^$_∖(1,1,(*+*)%$_...->\a,\b{!a&&b==1})}

झसे आज़माओ

{^$_∖(1,1,(*+*)%$_...{!$^a&&$^b==1})}

झसे आज़माओ

{^$_∖(1,1,(*+*)%$_...!*&*==1)}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  ^$_               # Range upto and excluding the input

  ∖                 # set minus (U+2216)

  (                 # generate the Fibonacci sequence mod k

    1, 1,           # seed the sequece (can't be 0,1)

    ( * + * ) % $_  # add two values and modulus the input (lambda)

    ...             # keep doing that until

                    # it matches 0,1
    !*              #   negate the first param (1 when 0)
    &               #   and Junction
    *               #   second param
    == 1            #   both match 1

  )
}

Answer 4

> <> , 48 बाइट्स

01\
?!\:&+{:}%:1$0p&$:
v0\~:1=?
>?!;1-::0g?!nao:

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

-V ध्वज के माध्यम से इनपुट लेता है।

बहुत सारी नई कहानियों को छापता है, लेकिन काम पूरा कर लेता है। यह मूल रूप से संख्याओं के सेट को संग्रहीत करने के लिए पहली पंक्ति का उपयोग करता है जो अब तक अनुक्रम में दिखाई देते हैं।

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

01\    Input is already on the stack
...... Initialises the sequence with 1 and 0
...... Goes to the second line
......

......
..\:&+{:}% Gets the next number in the modded Fibonacci sequence while preserving the previous number
......
......

......
..........:1$0p&$: Puts a 1 at that cell number on the first line
.......
.......

......             If the number is a 0 go to the third line
?!\..............: Check if the next number is a 1, meaning we've reached the end of the sequence
v0\~:1=?           Go to the fourth line if so
>.....             Re-add the 0 and go back to the second line if not

......           While input:
......             Get the cell from the first line
......             If not 0: print the number
>?!;1-::0g?!nao:   Finally, print a newline and decrement the input

Answer 5

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

m=input();r=set(range(m))
a=b=1
exec"a,b=b,a+b;r-={a%m};"*m*6
print r

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

Answer 6

MATL , 19 18 बाइट्स

0lbU:"yy+]vG\G:qX~

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

-1 बाइट ग्यूसेप की बदौलत।

  bU:"   ]         % Do K^2 (>6K) times.
0l    yy+          %  Fibbonaci
                X~ % Set exclusive difference between
          vG\      %  the fibonacci numbers mod K
             G:q   %  and 0...K-1

Comments

18 बाइट्स ; पुनर्व्यवस्थित करने से आपका उपयोग ठीक हो जाता है X~!

— ग्यूसेप

@Giuseppe धन्यवाद! हालाँकि अभी भी बहुत लंबा है ....

— Sanchises

Answer 7

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

lambda n:{*range(n)}-{*f(n*n,n)}
f=lambda c,m,l=[1,0]:f(c-1,m,[(l[0]+l[1])%m]+l)if c else l

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

Answer 8

भूसी , 13 12 10 बाइट्स

धन्यवाद @ बगर -2 बाइट्स के लिए!

-U2m%⁰İfŀ⁰

सभी पूर्णांकों के प्रदर्शित होने की स्थिति में एक रिक्त सूची प्रिंट करता है, इसे ऑनलाइन आज़माएं!

व्याख्या

-U2m%⁰İfŀ⁰  -- named argument ⁰, example with: 8
-           -- difference of
        ŀ⁰  -- | lowered range: [0,1,2,3,4,5,6,7]
            -- and
      İf    -- | Fibonacci sequence: [1,1,2,3,5,8,13,21,34,55,89,144,233,377…
   m%⁰      -- | map (modulo ⁰): [1,1,2,3,5,0,5,5,2,7,1,0,1,1…
 U2         -- | keep longest prefix until 2 adjacent elements repeats: [1,1,2,3,5,0,5,5,2,7,1,0,1]
            -- : [4,6]

Comments

आप U2सबसे लंबे समय तक उपसर्ग प्राप्त करने के लिए उपयोग कर सकते हैं जहां कोई आसन्न जोड़ी दोहराती नहीं है।

— जर्गब

Answer 9

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

def m(K):M=0,1;exec(K*6*'M+=sum(M[-2:])%max(K,2),;'+'print({*range(K)}-{*M})')

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

एक सेट को प्रिंट करता है, इसलिए खाली परीक्षण मामलों के लिए आउटपुट है set(), जो खाली सेट है।

Comments

एक पूर्ण कार्यक्रम के रूप में 72 बाइट्स

— ओन्स

@ आप पायथन 2 में हैं, ठीक है? ज़रूर

— आउटगॉल्फ

Answer 10

आर, 92 86 बाइट्स

6 बाइट बचाने के लिए @Giuseppe को धन्यवाद !

function(k,n=!!0:2){while(any((z=tail(n,2))-n[1:2]))n=c(n,sum(z)%%k);setdiff(1:k-1,n)}

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

बहुत सरल कार्यान्वयन ( पिछले संस्करण , लेकिन एक ही अवधारणा):

function(k,
         K=1:k-1,      #Uses default arguments to preset variables for legibility 
         n=c(0,1,1)){  #(wouldn't change byte-count to put them in the body of the function)
    while(any((z=tail(n,2))!=n[1:2])) #Do as long as first 2 elements are not identical to last 2 elements
        n=c(n,sum(z)%%k) #Built the fibonacci mod k sequence
    K[!K%in%n] #Outputs integers < k if not in sequence.
}

Comments

86 बाइट्स

— Giuseppe

@Giuseppe आह setdiff, अच्छा विचार है!

— प्लेनापस

70 बाइट्स1:k^2 ने उस दृष्टिकोण को चित्रित किया, जिसका उपयोग हर कोई करता है

— Giuseppe

Answer 11

पायथन 3, 173 152 143 131 बाइट्स

f=lambda n,m,a=0,b=1:a%m if n<=0else f(n-1,m,b,a+b)
p=lambda n,i=2,y={0}:y^{*range(n)}if f(i,n)==1>f(i-1,n)else p(n,i+1,y|{f(i,n)})

@Ovs को विशेष धन्यवाद।

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

यह कैसे काम करता है?

पहला फ़ंक्शन दो पैरामीटर m और n लेता है, और यह nth फाइबोनैचि नंबर mod m देता है। दूसरा फ़ंक्शन फाइबोनैचि संख्या mod k के माध्यम से लूप करता है और जाँचता है कि 0 और 1 दोहराए जाते हैं। यह एक सूची में संख्याओं को संग्रहीत करता है और 1-n संख्याओं वाली सूची के साथ इसकी तुलना करता है। डुप्लिकेट नंबर हटा दिए जाते हैं और बाकी नंबर वापस कर दिए जाते हैं।

Comments

इसका हेडर का एक हिस्सा है और यह कोड में शामिल करने के लिए अनिवार्य नहीं है।

— मनीष कुंडू

ठीक है, तय रहा। @ovs बताने के लिए धन्यवाद, मैं इससे अनजान था।

— मनीष कुंडू

131 बाइट्स के बजाय सेट set()और जंजीरों की तुलना में घुंघराले ब्रैकेट के साथ सेट करें ।

— ओवंस

Answer 12

05AB1E , 10 बाइट्स

L<InLÅfI%K

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

-3 बाइट्स एमिग्ना के लिए धन्यवाद।

Comments

L <I6 * LÅfI% K

— एमिग्ना

@Emigna मैं उस अंतर्निहित युग की तलाश में हूं! धन्यवाद!

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

Answer 13

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

->n{a=b=1;[*1...n]-(1..n*n).map{a,b=b,a+b;a%n}}

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

हालांकि यह कुछ इसी तर्क का उपयोग करता है, यह बंद नहीं है जीबी के उत्तर पर ।

स्पष्टीकरण:

->n{
  a=b=1;   # start sequence with 1,1
  [*1...n] # all the numbers from 1 to n-1 as an array
           # 0 is excluded as it should never be in the final answer 
  -  # set operation; get all items in the first set and not in the second
  (1..n*n).map{ # n squared times
    a,b=b,a+b;  # assign next fibonacci numbers 
    a%n         # return a fibonacci number mod n
  }    # Map to an array
}

Answer 14

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

(lambda(k)(do((a 1 b)c(b 1(mod(+ a b)k)))((=(1- b)0 a)(dotimes(i k)(or(member i c)(print i))))(push a c)))

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

Answer 15

परी / जीपी , 55 बाइट्स

n->setminus([0..n-1],Set([fibonacci(i)%n|i<-[0..n^2]]))

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

Answer 16

अमृत , 148 144 बाइट्स

 fn x->Enum.to_list(1..x-1)--List.flatten Enum.take_while Stream.chunk(Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end),2),&Enum.sum(&1)!=1end

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

विशेष रूप से प्रतिस्पर्धी उत्तर नहीं, लेकिन वास्तव में गोल्फ के लिए मजेदार था! अमृत ​​काफी पठनीय भाषा है, लेकिन बीच में पात्रों की गड़बड़ी के लिए एक स्पष्टीकरण इस प्रकार है।

---

यह स्पष्टीकरण दो वर्गों में है, मॉड-रिट्रेसमेंट और उस पर परिचालन

मॉड-मिथ्या:

Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end)

यह रिटर्न्स मॉड की एक अनंत धारा देता है x। यह एक संचायक के साथ शुरू होता है {1,1}, और निम्न ऑपरेशन विज्ञापन इनफ़िनिटम को लागू करता है: दिए गए संचायक {p,n}, p mod xस्ट्रीम में आउटपुट । फिर, संचायक को सेट करें{n,p+n} ।

बाकी:

fn x->                              Define a fxn f(x) that returns
  Enum.to_list(1..x-1)--            The numbers from 1..x-1 that are not in
  List.flatten                      The flattened list constructed by
    Enum.take_while                 Taking from mod-fib until
      Stream.chunk(                 A 2-size chunk
        Stream.unfold({1,1},fn{p,n}->{rem(p,x),{n,p+n}}end) (of mod fib)
        ,2)
      ,&Enum.sum(&1)!=1             sums to 1, representing [0,1] or [1,0]
end

Answer 17

SNOBOL4 (CSNOBOL4) , 153 बाइट्स

 k =input
 a =table()
 y =1
i z =remdr(x + y,k)
 a<z> =1
 x =y
 y =z
 i =lt(i,k * 6) i + 1 :s(i)
o output =eq(a<o>) lt(o,k) o
 o =lt(o,k) o + 1 :s(o)
end

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

Answer 18

रूबी , 55 53 बाइट्स

->n{*a=0,b=1;(n*n).times{a<<(b+=a[-2])%n};[*1...n]-a}

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

Answer 19

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

f=(n,a=0,b=1,q=[...Array(n).keys()])=>a*b+a-1?f(n,b,(a+b)%n,q,q[b]=0):q.filter(x=>x)

Answer 20

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

def t(n,r=[1]):
 while n*n>len(r):r+=[sum(r[-2:])%n]
 return{*range(n)}-{*r}

यह बस फिबोनेसी संख्याओं (n ^ 2) के सबसे लंबे संभावित चक्र को देखता है, और उस समय में होने वाली सभी संख्याओं की एक सूची बनाता है। तर्क को सरल बनाने के लिए संख्याओं को मोडुलो एन संग्रहित किया जाता है।