O desafio é bastante simples:

1. Tome um número inteiro positivo ncomo entrada.
2. Emita o nnúmero primo de Fibonacci.

A entrada pode ser um parâmetro para uma função (e a saída será o valor de retorno) ou pode ser obtida na linha de comando (e emitida lá).

Nota: Não é permitido o uso de funções de verificação primária incorporadas ou geradores da série Fibonacci.

Boa sorte!

Ruby, 55

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

Chama a si próprio de forma recursiva, acompanhando os dois últimos números na sequência de Fibonacci em ae b, e com quantos primos ele é visto até agora n. né decrementado quando o menor fator maior que 1 de b, dividido por be arredondado para o número inteiro mais próximo, é 1 em vez de 0, o que ocorre apenas para o prime b. Quando é visto todos os primos que deve, ele imprime a, que é o mais recente btestado para primalidade.

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

• estilo de código emprestado da verificação simplificada de número primo da @Gautam

• função C independente (sem globais)

Teste:

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

./a.out 10
433494437

./a.out 4
13

Mathematica, 59 ou 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)&

Essas são funções sem nome que recebem ncomo entrada e retornam o Fibonacci prime correto. A versão mais curta usa Divisors. Não tenho muita certeza se isso é permitido, mas a outra resposta do Mathematica ainda usa FactorInteger.

O segundo não usa nenhuma função relacionada à fatoração, mas conta o número de números inteiros menores do que os nque são produzidos 0em uma operação de módulo. Até mesmo esta versão supera todos os envios válidos, mas tenho certeza de que apenas publicar esta resposta fará com que algumas pessoas forneçam respostas competitivas no GolfScript, APL ou J.;)

Mathematica 147 143 141 caracteres

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 é a definição recursiva do número de Fibonacci.

q detecta números primos.

ké um Fibonacci prime iff q@f@ké True.

Para n= 10, a saída é 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

Golfe: (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

Para obter o nnúmero, ligue para ele fp !! n.

EDIT: Sic. Resposta errada, eu conserto.

Groovy: 105 (134 com espaços em branco)

b é a função fibonacci.

o fechamento dentro do if é a função de verificação primária. Atualização: uma pequena correção

r é o número primo de fibonacci.

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

Casos de teste:

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

Uma versão legível:

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 (com espaços)

implementação de fibonacci usando programação dinâmica:

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

Código legível:

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

Faz um loop de Fibonacci até que o array tenha o comprimento n, mas apenas adiciona ao array se prime.

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

Meio lento, mas atingiu n = 10 em ~ 15 segundos. Provavelmente pode ser jogado mais.

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