Moyenne arithmétique des nombres de Fibonacci premiers jusqu'au nombre de Fibonacci x

18

Vous auriez dû entendre parler des nombres de Fibonacci , souvent appelés la séquence de Fibonacci. Dans cette séquence, les deux premiers termes sont 0 et 1, et chaque nombre après les deux premiers est la somme des deux précédents. En d' autres termes, F(n) = F(n-1) + F(n-2).

Voici les 20 premiers numéros de Fibonacci:

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

Tâche:

Étant donné un entier x, calculer la moyenne arithmétique (la moyenne) des nombres de Fibonacci premiers jusqu'au xnombre de la séquence de Fibonacci.

Règles:

  • la séquence de Fibonacci commence par 0 et 1 pour ce défi
  • 3 < x < 40, car des valeurs plus élevées de xpeuvent entraîner un temps d'exécution énorme ou des débordements et des valeurs plus petites n'ont pas de sortie
  • 1 n'est pas un nombre premier, car il n'a qu'un diviseur
  • la moyenne arithmétique doit inclure des décimales, si c'est le cas, ou doit être affichée comme une fraction exacte
  • vous êtes uniquement autorisé à prendre xen entrée et le code nécessaire pour prendre l'entrée ne compte pas (par exemple: si vous avez besoin de quelque chose comme x = input(), vous ne devriez pas le prendre en considération lors du comptage des octets)

Exemples:

Ex. 1: Pour x=10la sortie est 5.75, parce que le 10 nombre de Fibonacci est 55et les premiers nombres de Fibonacci jusqu'à 55sont 2, 3, 5, 13, leur moyenne étant5.75

Après l'explication de l'exemple 1, d'autres exemples sont:

Ex. 2: Pour x=15, la sortie est57.5

Ex. 3: Pour x=20, la sortie est 277.428571428571, ou toute autre approximation proche. Dans ce cas 277.4286, par exemple, est une valeur acceptée

Ex. 4: Pour x=11, la sortie est22.4

Ex. 5: Pour x=30, la sortie est 60536.4444444444, ou toute autre approximation proche, telle que60536.444

Classement:

Afficher l'extrait de code

Pour changer de leader, soumettez une solution valide plus courte. Votre code doit être aussi court que possible, car il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte. Bonne chance!

code-golf math sequence arithmetic fibonacci M. Xcoder
la source
Le résultat peut-il être renvoyé sous forme de fraction exacte au lieu d'une décimale arrondie?
Martin Ender
Oui bien sûr, tant que c'est la bonne valeur. Modifié la question :))
M. Xcoder
Si la réponse est donnée sous forme de fraction, la fraction doit-elle être réduite?
DLosc
C'est à toi de voir. Vous pouvez le réduire si vous le souhaitez, mais je ne pense pas que ce soit nécessaire.
M. Xcoder
Veuillez mettre à jour la réponse acceptée.
Erik the Outgolfer

Réponses:

5

En fait , 10 octets

Code:

R♂F;Mr♂P∩æ

Explication:

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.

Utilise l' encodage CP-437 . Essayez-le en ligne!

Adnan
la source
Wow, fait un tel travail en seulement 10 octets. Impressionnant!
M. Xcoder
12

Python 2 , 71 octets

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

Essayez-le en ligne!

Python n'a pas d'intégrations arithmétiques utiles pour cela, donc nous faisons les choses à la main. Le code parcourt les numéros de Fibonacci en a,b=b,a+bpartant de a=b=1.

Le test de primalité de Fermat avec la base 2 est utilisé pour identifier les nombres premiers comme aoù 2^a == 2 (mod a). Bien que cela ne vérifie que les nombres premiers probables, aucun des faux positifs ne se trouve dans les 40 premiers nombres de Fibonacci.

La somme set le nombre actuels cde nombres premiers sont mis à jour chaque fois qu'un nombre premier est rencontré, et leur rapport (la moyenne) est imprimé à la fin. Étant donné que le contrôle d'amorçage manque a=2et qu'il est garanti d'être dans la plage d'entrée, la somme commence à 2 et le compte commence à 1 pour compenser.

xnor
la source
8

Gelée , 11 octets

ÆḞ€ÆPÐfµS÷L

Essayez-le en ligne!

Comment ça fonctionne

ÆḞ€Æ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.
Dennis
la source
11
Un solide 2 sur 3 sur les mathématiques intégrées. Fibonacci, vérifiez. Primality, check. Moyenne arithmétique, non.
xnor
J'ai changé la réponse acceptée, car une réponse plus courte a été publiée.
M. Xcoder
7

Mathematica, 38 octets

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

(* or *)

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

Explication

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 *)
JungHwan Min
la source
2
Je pense que vous voulez #et non #-1: l'OP dit que 55 est le 10e numéro de Fibonacci, donc leur liste doit être indexée 0 (comme c'est la meilleure convention). Comparez votre sortie pour les entrées 10et 11avec l'OP. Heureusement, cela vous fait économiser trois octets!
Greg Martin
Vous pouvez supprimer le &et remplacer #par x(la question dit que le code de prise d'entrée n'est pas noté)
CalculatorFeline
6

Perl 6 , 51 octets

{sum($/=[grep *.is-prime,(0,1,*+*...*)[0..$_]])/$/}

Essayez-le

Étendu:

{
  sum(
    $/ = [                # store as an Array in $/

      grep
        *.is-prime,       # find the primes
        (
          0, 1, *+* ... * # Fibonacci sequence
        )[ 0 .. $_ ]      # grab the indicated values in the sequence

    ]
  )

  /

  $/   # use the Array as a number (elems)
}
Brad Gilbert b2gills
la source
5

MATL , 16 octets

lOi:"yy+]vtZp)Ym

Essayez-le en ligne!

Explication

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
Luis Mendo
la source
4

Octave , 75 71 octets

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

Fonction anonyme qui utilise la formule de Binet . L'entrée et la sortie sont sous forme d'arguments de fonction.

Essayez-le en ligne!

Luis Mendo
la source
1
+1 pour l'utilisation intéressante de la formule de Binet, combinée avec la fonction intégrée isprimequi est parfaite pour ce défi.
M. Xcoder
4

Maxima, 49 octets

f(n):=mean(sublist(makelist(fib(x),x,n),primep));
rahnema1
la source
4

Prolog (SWI) , 269 264 254 218 octets

  • Merci à Fatalize pour avoir économisé 37 octets!
  • Merci à Emigna pour avoir économisé 9 octets!

Je suis assez certain que je pourrais jouer au golf encore plus d'octets.

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.

Exécutez-le comme a(15, R).pour x = 15 , R est la variable de sortie.

Essayez-le en ligne!

Une version plus lisible:

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).
Adnan
la source
1
Le golf à SWI Prolog est doré (et très dur), donc beau travail!
M. Xcoder
Je suis presque sûr que des choses comme N*C:-sont autorisées pour les déclarations de tête dans PPCG, ce qui peut vous faire économiser quelques octets.
Fatalize
@Fatalize Je viens d'apprendre ce langage de programmation il y a environ une semaine, donc je ne sais pas trop ce que vous voulez dire: p. Voulez-vous remplacer p(N,C):-par N*C:-?
Adnan
@Adnan Exactement!
Fatalize
@Fatalize Oohhh, c'est vraiment bien! Merci :).
Adnan
3

Röda , 98 94 93 octets

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]}

C'est une fonction qui renvoie le résultat sous forme de nombre à virgule flottante.

Version non golfée:

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
la source
Pouvez-vous faire à la c%p>0place de c%p!=0?
Kritixi Lithos
@KritixiLithos Oui! Je vous remercie.
fergusq
3

05AB1E , 13 octets

!ÅF¹£DpÏDOsg/

Essayez-le en ligne! ou comme suite de tests

Explication

!Å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
la source
2

dc , 129 octets

?sa0sb1sd0ss0sz[[lF1+sF]sqlelG!=q]si[ls+sslz1+sz]sw[lddlb+dsdrsbdsG2se0sF[lGdle%0=ile1+dse<p]dspxlF0=wla1-dsa1<c]dscxEkls1-lz1-/p

Un générateur de nombres Fibonacci et un vérificateur de primalité tout en un. Agréable.

Essayez-le en ligne!

R. Kap
la source
2

Japt , 14 octets

ò@MgXÃfj
x /Ul

Essaye-le

Explication

Saisie implicite d'entier U.
30

ò

Générez un tableau d'entiers de 0 à Uinclus.
[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]

@   Ã

Passez chaque entier à travers une fonction.

MgX

Obtenez le Xnuméro de Fibonacci, où Xest l'élément actuel.

[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

Filter ( f) le tableau pour les éléments qui retournent véridique lorsqu'il est vérifié pour primality ( j). Attribuez implicitement le tableau résultant à la variable U.
[2,3,5,13,89,233,1597,28657,514229]

x

Réduisez le tableau en additionnant.
544828

/Ul

Divisez le résultat par la longueur du tableau ( l) et affichez implicitement le résultat.
60536.444444444445

Hirsute
la source
Wow, j'aime les nouvelles réponses aux vieilles questions. Également proche des autres langues de golf, donc +1.
M. Xcoder
1

perl, 91 octets

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

Cuold a été raccourci de 8 octets si le test modulo pseudoprime fonctionnait aussi bien en perl que dans la réponse python:

$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

... mais cela donne une mauvaise réponse pour une entrée> 16 en perl.

Kjetil S.
la source
1

Axiome, 104 octets

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)

non golfé, code de test et résultats

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]]

j'essaie de dupliquer l'entrée des langues matematica, octave etc., si l'on ne compte pas la fonction mean (), pour l'implémenter, ce serait ici 62 octets si bien aussi

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
la source
1

JavaScript ES6, 137 136 118 113 octets

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))
Développer l'extrait

Histoire

118 octets

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 octets

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 octets

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)
Hirsute
la source