एक्स फाइबोनैचि संख्या तक प्राइम फाइबोनैचि संख्याओं का अंकगणितीय माध्य

18

आपने फाइबोनैचि संख्याओं के बारे में सुना होगा , जिसे अक्सर फाइबोनैचि अनुक्रम कहा जाता है। इस क्रम में पहले दो पद 0 और 1 हैं, और पहले दो के बाद हर संख्या दो पूर्ववर्ती का योग है। दूसरे शब्दों में, F(n) = F(n-1) + F(n-2)।

यहाँ पहले 20 फाइबोनैचि संख्याएँ हैं:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

कार्य:

पूर्णांक को देखते हुए x, प्रमुख फाइबोनैचि संख्याओं के अंकगणितीय माध्य (औसत) की गणना xफाइबोनैचि अनुक्रम की संख्या तक की जाती है।

नियम:

  • इस चुनौती के लिए फाइबोनैचि अनुक्रम 0 और 1 से शुरू होता है
  • 3 < x < 40, क्योंकि उच्च मूल्यों के xकारण कुछ विशाल निष्पादन समय हो सकता है या बहुत अधिक उत्पादन हो सकता है
  • 1 अभाज्य नहीं है , क्योंकि इसमें केवल 1 भाजक है
  • अंकगणितीय माध्य में दशमलव शामिल होना चाहिए, यदि यह मामला है, या एक सटीक अंश के रूप में प्रदर्शित किया जाना चाहिए
  • आपको केवल xइनपुट के रूप में लेने की अनुमति है और इनपुट लेने के लिए आवश्यक कोड की गिनती नहीं है (जैसे: यदि आपको किसी चीज़ की आवश्यकता है x = input(), तो आपको बाइट्स की गिनती करते समय इसे ध्यान में नहीं रखना चाहिए)

उदाहरण:

पूर्व। 1: के लिए x=10, उत्पादन होता है 5.75, क्योंकि 10 वीं फाइबोनैचि संख्या है, 55और प्रधानमंत्री फिबोनैकी संख्या अप करने के लिए 55कर रहे हैं 2, 3, 5, 13, उनकी औसत से किया जा रहा5.75

उदाहरण 1 से स्पष्टीकरण के बाद, अन्य उदाहरण हैं:

पूर्व। 2: के लिए x=15, आउटपुट है57.5

पूर्व। 3: के लिए x=20, उत्पादन होता है 277.428571428571, या किसी अन्य करीबी सन्निकटन। इस मामले में 277.4286, उदाहरण के लिए, एक स्वीकृत मूल्य है

पूर्व। 4: के लिए x=11, आउटपुट है22.4

पूर्व। 5: के लिए x=30, आउटपुट है 60536.4444444444, या किसी अन्य करीबी सन्निकटन, जैसे कि60536.444

लीडरबोर्ड:

कोड स्निपेट दिखाएं

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

code-golf  math  sequence  arithmetic  fibonacci 
— मिस्टर एक्सकोडर
स्रोत
क्या परिणाम एक गोल दशमलव के बजाय एक सटीक अंश के रूप में वापस किया जा सकता है?
— मार्टिन एंडर
हां, जब तक यह सही मूल्य है। प्रश्न का संपादन किया :))
— मिस्टर एक्सकोडर
यदि उत्तर अंश के रूप में दिया जाता है, तो क्या अंश को कम करना पड़ता है?
— DLosc
यह आप पर निर्भर है। आप चाहें तो इसे कम कर सकते हैं, लेकिन मुझे नहीं लगता कि यह आवश्यक है।
— श्री एक्सकोडर
कृपया स्वीकृत उत्तर अपडेट करें।
— एर्ग आउटफोलर

जवाबों:

5

दरअसल , 10 बाइट्स

कोड:

R♂F;Mr♂P∩æ

स्पष्टीकरण:

R            # On the input, create the range [1 .. input].
 ♂F          # Map the nth Fibonacci command over it.
   ;M        # Duplicate and get the maximum of the list.
     r       # Create the range [0 .. maximum - 1].
      ♂P     # Map the nth prime operator over each element (zero-indexed).
        ∩    # Intersection of both.
         æ   # Get the mean and implicitly display.

CP-437 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
वाह, ऐसा काम सिर्फ 10 बाइट्स में किया। प्रभावशाली!
— मिस्टर एक्सकोडर
12

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

s=2.;a=b=c=1
exec"p=2**a%a==2;c+=p;s+=a*p;a,b=b,a+b;"*input()
print s/c

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

पाइथन के पास इसके लिए उपयोगी अंकगणित बिल्ट-इन नहीं है, इसलिए हम चीजों को हाथ से करते हैं। यह कोड फिबोनाची संख्या से a,b=b,a+bशुरू होने के माध्यम से पुनरावृत्त करता है a=b=1।

फर्मेट primality परीक्षण आधार 2 के साथ के रूप में अभाज्य संख्या की पहचान के लिए प्रयोग किया जाता है aजहां 2^a == 2 (mod a)। हालांकि यह केवल संभावित अपराधों के लिए जाँच करता है, कोई भी गलत सकारात्मक पहले 40 फाइबोनैचि संख्याओं के भीतर नहीं है।

प्राइम की वर्तमान राशि sऔर गणना cको अपडेट किया जाता है हर बार जब एक प्राइम का सामना किया जाता है, और उनका अनुपात (मतलब) अंत में मुद्रित होता है। क्योंकि प्राइम चेक मिस हो जाता है a=2और इसकी इनपुट रेंज में होने की गारंटी होती है, योग 2 से शुरू होता है और क्षतिपूर्ति के लिए गिनती 1 से शुरू होती है।

— XNOR
स्रोत
8

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

ÆḞ€ÆPÐfµS÷L

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

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

ÆḞ€ÆPÐfµS÷L  Main link. Argument: n (integer)

ÆḞ€          Map the Fibonacci atom over [1, ..., n].
   ÆPÐf      Filter by primality.
       µ     Begin a new chain. Argument: A (array of Fibonacci primes)
        S    Yield the sum of A.
          L  Yield the length of A.
         ÷   Compute the quotient.
— डेनिस
स्रोत
11
गणित निर्मित ins पर 3 का एक ठोस 2। फाइबोनैचि, जांच। परिमाण, जाँच। अंकगणित का मतलब है, नहीं।
— xnor
मैंने स्वीकृत उत्तर को बदल दिया है, क्योंकि एक छोटा पोस्ट किया गया था।
— मिस्टर एक्सकोडर
7

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

Mean@Select[Fibonacci@Range@#,PrimeQ]&

(* or *)

Mean@Select[Fibonacci~Array~#,PrimeQ]&

व्याख्या

Mean@Select[Fibonacci@Range@#,PrimeQ]&  
                                     &  (* For input # *)
                      Range@#           (* List {1, 2, 3, ... #} *)
            Fibonacci@                  (* Find the corresponding fibonacci numbers *)
     Select[                 ,PrimeQ]   (* Select the prime terms *)
Mean@                                   (* Take the Mean *)
— जंगवान मिन
स्रोत
2
मुझे लगता है कि आप चाहते हैं #और नहीं #-1: ओपी का कहना है कि 55 वीं फिबोनाची संख्या है, इसलिए उनकी सूची 0-अनुक्रमित होनी चाहिए (जैसा कि सबसे अच्छा सम्मेलन है)। इनपुट के लिए अपने आउटपुट की तुलना करें 10और 11ओपी के साथ। सौभाग्य से यह वास्तव में आपको तीन बाइट्स बचाता है!
— ग्रेग मार्टिन
आप ड्रॉप कर सकते हैं &और बदलने के #साथ x(सवाल का कहना है कि इनपुट लेने कोड रन बनाए नहीं है)
— CalculatorFeline
5

MATL , 16 बाइट्स

lOi:"yy+]vtZp)Ym

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

व्याख्या

lO     % Push 1, then 0. This way the generated numbers with indices 1, 2, 3, ...
       % will be 1, 1, 2, ... as required
i      % Input n
:"     % Do the following n times
  yy   %   Duplicate top two numbers
  +    %   Add
]      % End
v      % Concatenate all numbers into a column vector
t      % Duplicate
Zp     % Vector of logical values: true for prime numbers, false otherwise
)      % Apply that vector as an index. This keeps only prime numbers
Ym     % Mean. Implicitly display
— लुइस मेंडो
स्रोत
4

ऑक्टेव , 75 71 बाइट्स

@(n)mean((t=fix(((1+(s=5^.5)).^(x=1:n)-(1-s).^x)/s./2.^x))(isprime(t)))

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

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

— लुइस मेंडो
स्रोत
1
बिल्ट के फार्मूले के दिलचस्प उपयोग के लिए +1, बिल्ट-इन के साथ संयुक्त है isprimeजो इस चुनौती के लिए एकदम सही है।
— श्री एक्सकोडर
4

मैक्सिमा, 49 बाइट्स

f(n):=mean(sublist(makelist(fib(x),x,n),primep));
— rahnema1
स्रोत
4

प्रोलोग (एसडब्ल्यूआई) , 269 264 254 218 बाइट्स

  • 37 बाइट बचाने के लिए घातक परिणाम के लिए धन्यवाद !
  • 9 बाइट बचाने के लिए Emigna को धन्यवाद !

मुझे पूरा यकीन है कि मैं कुछ और बाइट्स नीचे कर सकता हूं।

X/X:-X<3.
N/R:-A is N-1,B is N-2,A/C,B/D,R is C+D.
2^0^0.
C^S^E:-G is C-1,G/M,G^Q^R,(p(M)->S=M+Q,E is R+1;S=Q,E is R).
a(X,S):-X^R^Q,S is R/Q.
p(N):-N*(N-1).
p(2).
p(3).
N*2:-N mod 2=\=0.
N*C:-N mod C=\=0,D is C-1,N*D.

के रूप में यह भागो a(15, R).के लिए एक्स = 15 , आर उत्पादन चर रहा है।

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

अधिक पठनीय संस्करण:

fibonacci(1, 1) :- !.
fibonacci(2, 2) :- !.

fibonacci(N, R) :-
  N0 is N - 1,
  N1 is N - 2,
  fibonacci(N0, R1),
  fibonacci(N1, R2),
  R is R1 + R2.

listed(2, 0, 0) :- !.

listed(C, S, Successes) :-
  C0 is C - 1,
  fibonacci(C0, Result),
  listed(C0, S0, S1),
  (
    is_prime(Result)
    ->
      S = Result + S0, Successes is S1 + 1
    ; S = S0, Successes is S1
  ).

f(X, S) :-
  listed(X, R, Q),
  S is R / Q.

is_prime(Num) :- is_prime(Num, Num - 1).

is_prime(2).
is_prime(3).

is_prime(Num, 2) :- Num mod 2 =\= 0, !.

is_prime(Num, C) :-
  Num mod C =\= 0,
  C0 is C - 1,
  is_prime(Num, C0).
— अदनान
स्रोत
1
SWI प्रोलॉग में गोल्फिंग सुनहरा है (और बहुत कठिन है), इतना अच्छा काम!
— मिस्टर एक्सकोडर
मुझे पूरा यकीन है कि N*C:-पीपीसीजी में प्रमुख घोषणाओं के लिए अनुमति दी जाती है, जो आपको कुछ बाइट्स बचा सकती है।
— घातक
@ जानिए मैंने इस प्रोग्रामिंग लैंग्वेज को लगभग एक हफ्ते पहले सीखा था, इसलिए मुझे यकीन नहीं है कि आपका क्या मतलब है: पी। क्या आप के p(N,C):-साथ स्थानापन्न करने का मतलब है N*C:-?
— अदनान
@ अदनान बिल्कुल!
— घातक
@ फ़ातेज़ करो ओह्ह्ह, ये सच में साफ़ है! धन्यवाद :)।
— अदनान
3

रोड़ा , 98 94 93 बाइट्स

f n{z=0;i=1;j=1;s=0;seq 2,n-1|{|_|c=i+j;i=j;j=c;seq 2,c-1|{z+=1;s+=c}if[c%p>0]()for p}_[s/z]}

यह एक फ़ंक्शन है जो परिणाम को एक फ्लोटिंग पॉइंट नंबर के रूप में लौटाता है।

Ungolfed संस्करण:

function f(n) {
    i = 1
    j = 1
    sum = 0
    num = 0
    seq(2, n-1) | for _ do
        /* calculate next fibonacci number: */
        c = i+j
        i = j
        j = c
        /* if it's prime: */
        {
            num += 1
            sum += c
        /* primality test: */
        } if [c%p > 0]() for p in [seq(2, c-1)]
    done
    return sum/num
}
— fergusq
स्रोत
क्या आप इसके c%p>0बजाय कर सकते हैं c%p!=0?
— क्रिति लिथोस
@KritiiLithos हाँ! धन्यवाद।
— फर्ग्यूसक
3

05AB1E , 13 बाइट्स

!ÅF¹£DpÏDOsg/

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

!ÅF             # get a list of fibonacci numbers up to fac(input)
   ¹£           # take the first input elements of that list
     D          # duplicate
      p         # isprime on the copy
       Ï        # keep the fibonacci numbers which are true in the isprime list
        D       # duplicate the list of fibonacci primes
         O      # sum the list
          s     # swap the other copy to the top of the stack
           g    # get its length
            /   # divide sum by length
— Emigna
स्रोत
2

जाप , 14 बाइट्स

ò@MgXÃfj
x /Ul

झसे आज़माओ

व्याख्या

पूर्णांक का निहित इनपुट U।
30

ò

0 से Uसमावेशी तक पूर्णांकों की एक सरणी उत्पन्न करें ।
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]

@   Ã

फ़ंक्शन के माध्यम से प्रत्येक पूर्णांक पास करें।

MgX

Xवें फिबोनाची संख्या प्राप्त करें , जहां Xवर्तमान तत्व है।

[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040]

fj

fउन तत्वों को फ़िल्टर करें ( ) जो सत्यता की जांच करते समय सत्यता लौटाते हैं ( j)। परिणामी सरणी को चर में लागू करें U।
[2,3,5,13,89,233,1597,28657,514229]

x

सरणी को संक्षेप में कम करें।
544828

/Ul

परिणाम को सरणी की लंबाई ( l) से विभाजित करें और परिणाम को आउटपुट करें।
60536.444444444445

— झबरा
स्रोत
वाह, मुझे पुराने सवालों के नए जवाब पसंद हैं। अन्य गोल्फ भाषाओं के करीब भी, इसलिए +1।
— मिस्टर एक्सकोडर
1

पर्ल, 91 बाइट्स

$b=1;map{($a,$b)=($b,$a+$b),$p=("x"x$b)!~/^(.|(..+)\2+)$/,$s+=$b*$p,$c+=$p}2..$x;print$s/$c

Cuold 8 बाइट्स छोटा होता है यदि मोडुलो स्यूडोप्राइम टेस्ट पर्ल में और साथ ही पायथन उत्तर में काम करता है:

$b=1;$s=2;map{($a,$b)=($b,$a+$b),$p=2**$b%$b==2,$s+=$b*$p,$c+=$p}2..$x;print$s/++$c

... लेकिन यह इनपुट के लिए गलत जवाब देता है> 16 perl में।

— केजेटिल एस।
स्रोत
1

Axiom, 104 बाइट्स

g(n)==(y:=x:=r:=0;repeat(x>n=>break;j:=fibonacci(x);x:=x+1;if prime?(j)then(r:=r+j;y:=y+1));y=0=>-1;r/y)

ungolfed, परीक्षण कोड और परिणाम

f(n)==
  y:=x:=r:=0
  repeat
     x>n=>break
     j:=fibonacci(x)
     x:=x+1
     if prime?(j) then(r:=r+j;y:=y+1)
  y=0=>-1
  r/y

(3) -> [[i,g(i)::Float] for i in [1,2,3,10,15,20,11,30,50]]
   Compiling function g with type PositiveInteger -> Fraction Integer
   (3)
   [[1.0,- 1.0], [2.0,- 1.0], [3.0,2.0], [10.0,5.75], [15.0,57.5],
    [20.0,277.4285714285 7142857], [11.0,22.4], [30.0,60536.4444444444 44444],
    [50.0,309568576.1818181818 2]]

मैं matematica, ऑक्टेव आदि भाषाओं की प्रविष्टि की नकल करने की कोशिश करता हूं, यदि कोई मतलब () फ़ंक्शन को नहीं गिनता है, तो इसे लागू करने के लिए यहां 62 बाइट्स इतनी अच्छी होंगी

mean(a:List Float):Any== 
    i:=1; s:=0.0
    repeat  
       if~index?(i,a)then break
       s:=s+a.i
       i:=i+1
    i=1=>[]
    s/(i-1)

--62 bytes
f(x:NNI):Any==mean(select(prime?,[fibonacci(i)for i in 1..x]))
— RosLuP
स्रोत
1

जावास्क्रिप्ट ईएस 6, 137 136 118 113 बाइट्स

m=

n=>(a=[],(f=x=>a[x]=x<2?x:f(--x)+f(--x))(n),eval((a=a.filter(x=>eval("for(y=x;x%--y;);y==1"))).join`+`)/a.length)

console.log(m(10))
console.log(m(15))
console.log(m(20))
console.log(m(11))
console.log(m(30))
स्निपेट का विस्तार करें

इतिहास

118 बाइट्स

n=>(a=[0,1,1],(f=x=>a[--x]=a[x]||f(x)+f(--x))(n),eval((a=a.filter(x=>eval("for(y=x;x%--y;);y==1"))).join`+`)/a.length)

136 बाइट्स

n=>(a=[0,1,1],(f=x=>a[--x]=a[x]||f(x)+f(--x))(n),eval((a=a.filter(x=>x>1&&!Array(x).fill().some((i,j)=>j>1&&!(x%j)))).join`+`)/a.length)

137 बाइट्स

n=>(a=[0,1,1],(f=x=>a[--x]=a[x]||f(x)+f(--x))(n),eval((a=a.filter(x=>{d=x;while(--d>1)if(!(x%d))return 0;return x>1})).join`+`)/a.length)
— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.