Die Herausforderung ist ziemlich einfach:

1. Nehmen Sie eine positive ganze Zahl nals Eingabe.
2. Geben Sie die nth Fibonacci-Primzahl aus.

Die Eingabe kann als Parameter für eine Funktion erfolgen (und die Ausgabe ist der Rückgabewert) oder über die Befehlszeile erfolgen (und dort ausgegeben werden).

Hinweis: Die Verwendung integrierter Hauptprüffunktionen oder Generatoren der Fibonacci-Serie ist nicht zulässig.

Viel Glück!

Ruby, 55

f=->n,a=1,b=2{n<1?a:f[n-(2..b).find{|f|b%f<1}/b,b,a+b]}

Ruft sich rekursiv auf und verfolgt die letzten beiden Zahlen in der Fibonacci-Sequenz in aund bund wie viele Primzahlen es bisher gesehen hat n. nwird dekrementiert, wenn der kleinste Faktor größer als 1 von b, geteilt durch bund abgerundet auf die nächste ganze Zahl, 1 statt 0 ist, was nur für Primzahlen geschieht b. Wenn alle Primzahlen angezeigt werden, die es soll, wird gedruckt a, was die zuletzt bauf Primalität getestete ist.

C, 66

f(n,a,b){int i=2;while(a%i&&i++<a);return(n-=i==a)?f(n,b,a+b):a;}

C 85 , 81 , 76

f(n){int i=1,j=0,k;for(;n;n-=k==i)for(j=i-j,i+=j,k=2;i%k&&k++<i;);return i;}

• Ausgeliehener Codestil der vereinfachten Primzahlprüfung von @Gautam

• in sich geschlossene C-Funktion (keine Globalen)

Testen:

main(int n,char**v){printf("%d\n",f(atoi(v[1])));}

./a.out 10
433494437

./a.out 4
13

Mathematica, 59 oder 63 Bytes

(a=b=1;Do[While[{a,b}={b,a+b};Length@Divisors@b>2],{#}];b)&
(a=b=1;Do[While[{a,b}={b,a+b};b~Mod~Range@b~Count~0>2],{#}];b)&

Dies sind unbenannte Funktionen, die nals Eingabe die korrekte Fibonacci-Primzahl zurückgeben. Die kürzere Version verwendet Divisors. Ich bin mir nicht ganz sicher, ob dies erlaubt ist, aber die andere Mathematica-Antwort verwendet sie sogar FactorInteger.

Die zweite verwendet überhaupt keine faktorisierungsbezogenen Funktionen, sondern zählt stattdessen die Anzahl der Ganzzahlen, die kleiner sind als ndie, die 0in einer Modulo-Operation erzeugt werden. Sogar diese Version übertrifft alle gültigen Einsendungen, aber ich bin sicher, dass nur das Posten dieser Antwort einige Leute dazu veranlasst, wettbewerbsfähige Antworten in GolfScript, APL oder J zu liefern.)

Mathematica 147 143 141 Zeichen

f@0 = 0; f@1 = 1; f@n_ := f[n - 1] + f[n - 2]
q@1 = False; q@n_ := FactorInteger@n~MatchQ~{{_, 1}}
p = {}; k = 1; While[Length@p < n, If[q@f@k, p~AppendTo~f[k]]; k++];p[[-1]]

f ist die rekursive Definition der Fibonacci-Zahl.

q erkennt Primzahlen.

kist eine Fibonacci-Primzahl, wenn q@f@kwahr ist.

Für n= 10 ist die Ausgabe 433494437.

Ruby, 94 68 67

n=->j{a=b=1
while j>0
a,b=b,a+b
(2...b).all?{|m|b%m>0}&&j-=1
end
b}

Clojure, 112

Ungolfed:

(defn nk [n]
  (nth 
    (filter
      (fn[x] (every? #(> (rem x %) 0) (range 2 x)))    ; checks if number is prime
      ((fn z[a b] (lazy-seq (cons a (z b (+ a b))))) 1 2)) ; Fib seq starting from [1, 2]
    n)) ; get nth number

Golf: (defn q[n](nth(filter(fn[x](every? #(>(rem x %)0)(range 2 x)))((fn z[a b](lazy-seq(cons a(z b(+ a b)))))2 3))n))

Haskell 108

p=2 : s [3,5..]  where
    s (p:xs) = p : s [x|x<-xs,rem x p /= 0]
f=0:1:(zipWith (+) f$tail f)
fp=intersect p f

Um die nNummer zu bekommen, rufen Sie sie an fp !! n.

EDIT: Sic. Falsche Antwort, ich behebe es.

Groovy: 105 (134 mit Leerzeichen)

b ist die Fibonacci-Funktion.

Der Verschluss im if ist die Hauptprüffunktion. Update: eine kleine Korrektur

r ist die primäre Fibonacci-Zahl.

r={ n->
  c=k=0
  while(1) {
    b={a->a<2?a:b(a-1)+b(a-2)}
    f=b k++
    if({z->z<3?:(2..<z).every{z%it}}(f)&&c++==n)return f
  }
}

Testfälle:

assert r(0) == 0
assert r(1) == 1
assert r(2) == 1
assert r(3) == 2
assert r(4) == 3
assert r(5) == 5
assert r(6) == 13
assert r(7) == 89
assert r(8) == 233
assert r(9) == 1597

Eine lesbare Version:

def fib(n) { 
  n < 2 ? n : fib(n-1) + fib(n-2)
}
def prime(n) {
  n < 2 ?: (2..<n).every { n % it }
}
def primeFib(n) { 
  primes = inc = 0
  while( 1 ) {
    f = fib inc++
    if (prime( f ) && primes++ == n) return f
  }
}

C, 105 (mit Leerzeichen)

Fibonacci-Implementierung mit dynamischer Programmierung:

long f(int n){int i;long b2=0,b1=1,n;if(n)return 0;for(i=2;i<n;i++){n=b1+b2;b2=b1;b1=n;}return b1+b2;}

Lesbarer Code:

long f(int n)
{
  int i;
  long back2 = 0, back1 = 1;
  long next;

  if ( n == 0 ) return 0;

  for ( i=2; i<n; i++ )
  {
    next  = back1 + back2;
    back2 = back1;
    back1 = next;
  }

  return back1 + back2;
}

Pyth - 29 Bytes

Schleift Fibonacci, bis das Array die Länge n hat, fügt es jedoch nur dann zum Array hinzu, wenn es prim ist.

J2K1W<lYQAJK,+KJJI!tPK~Y]K;eY

Etwas langsam, erreichte aber in ~ 15 Sekunden n = 10. Kann wahrscheinlich mehr Golf gespielt werden.

J2              J=2
K1              K=1
W        <lYQ   While length of array<input
 AJK,+KJJ       J,K=K+J,J
 I!tPK          If K prime(not builtin prime function, uses prime factorization)
  ~Y]K          append K to Y
;               End loop so next is printed
eY              last element of Y

Javascript:

Number.prototype.fiboN = function()
{
var r = (Math.pow((1 + Math.sqrt(5)) / 2,this) - (Math.pow(1 - (1 + Math.sqrt(5)) / 2,this))) / Math.sqrt(5);
return r.toFixed(0);
}

alert((10).fiboN()); // = 55 assuming the serie starts with 1,1,2,3,5,8,13,...
alert((46).fiboN()); // = 1836311903