A famosa sequência de Fibonacci é F(0) = 0; F(1) = 1; F(N+1) = F(N) + F(N-1)(para este desafio, começamos com 0).

Seu desafio: Dado n , saída a soma de toda a d th números de Fibonacci para todos os divisores de d do n º número de Fibonacci. Se você preferir uma notação mais formal,

Entrada : um número inteiro positivo n

Saída : a soma

Por exemplo, considere n=4. F(4) = 3Os divisores de 3 são 1 e 3, portanto a saída deve ser F(1) + F(3) = 1 + 2 = 3.

Para n=6, F(6) = 8, e os divisores de 8 são 1, 2, 4, 8, de modo que a saída é F(1) + F(2) + F(4) + F(8) = 1 + 1 + 3 + 21 = 26.

Casos de teste:

1 => 1
2 => 1
3 => 2
4 => 3
5 => 6
6 => 26

Este é o código-golfe , a resposta mais curta em bytes ganha. Aplicam-se brechas padrão .

Na verdade , 5 bytes

F÷♂FΣ

Experimente online!

Como funciona

       (implicit) Read n from STDIN.
F      Compute F(n).
 ÷     Get F(n)'s divisors.
  ♂F   Map F over the divisors.
    Σ  Take the sum.

Geléia , 7 bytes

ÆḞÆDÆḞS

Experimente online!

Explicação:

ÆḞÆDÆḞS Main link (Arguments: z)
ÆḞ      zth Fibonacci number's
  ÆD                           divisors'
    ÆḞ                                   Fibonacci numbers'
      S                                                     sum

Mathematica, 29 bytes

f=Fibonacci;f@#~DivisorSum~f&

Mathematica Simplificado , 14 bytes

Fi@#~Div9`~Fi&

Bem, isso acabou sendo idêntico à solução da @ MartinEnder ...

Japt , 11 bytes

MgU â x@MgX

Experimente online!

05AB1E , 11 bytes

!ÅFDI<èÑ<èO

Experimente online!

Explicação

!            # factorial of input
 ÅF          # get the list of fibonacci numbers (starting at 1)
             # smaller than or equal to this
   D         # duplicate list of fibonacci number
    I<è      # get the element at index (input-1)
       Ñ     # get the list of its divisors
        <    # decrement each
         è   # get the fibonacci numbers at those indices
          O  # sum

Haskell, 54 bytes

f=0:scanl(+)1f
g x=sum[f!!d|d<-[1..f!!x],mod(f!!x)d<1]

Exemplo de uso: g 6-> 26. Experimente online!

Alice , 38 36 bytes

Agradecemos a Leo por salvar 2 bytes.

/ow;B1dt&w;31J
\i@/01dt,t&w.2,+k;d&+

Experimente online!

Quase certamente não é o ideal. O fluxo de controle é bastante elaborado e, embora eu esteja feliz com a quantidade de bytes que foram salvos nas versões anteriores, sinto que estou complicando demais as coisas, que podem ser mais simples e solução mais mais curta.

Explicação

Primeiro, preciso elaborar um pouco a pilha de endereços de retorno (RAS) de Alice. Como muitos outros fungeóides, Alice tem um comando para pular o código. No entanto, também possui comandos para retornar de onde você veio, o que permite implementar sub-rotinas de maneira bastante conveniente. Obviamente, sendo uma linguagem 2D, as sub-rotinas realmente existem apenas por convenção. Não há nada que impeça você de entrar ou sair de uma sub-rotina por outros meios além de um comando de retorno (ou em qualquer ponto da sub-rotina) e, dependendo de como você usa o RAS, talvez não exista uma hierarquia de salto / retorno limpa.

Em geral, isso é implementado com o comando jump jenviar o endereço IP atual ao RAS antes de saltar. O comando de retorno kaparece um endereço do RAS e salta para lá. Se o RAS estiver vazio, knão fará nada.

Há também outras maneiras de manipular o RAS. Dois deles são relevantes para este programa:

• wenvia o endereço IP atual para o RAS sem ir para qualquer lugar. Se você repetir esse comando, poderá escrever loops simples de maneira bastante conveniente,&w...k , já fiz em respostas anteriores.
• Jé como, jmas não se lembra do endereço IP atual no RAS.

Também é importante observar que o RAS não armazena informações sobre a direção do IP. Portanto, retornar a um endereço com ksempre preservará a direção atual do IP (e, portanto, também se estamos no modo Cardinal ou Ordinal), independentemente de como passamos pelo jouw que empurrou o endereço IP em primeiro lugar.

Com isso, vamos começar examinando a sub-rotina no programa acima:

01dt,t&w.2,+k

Essa sub-rotina puxa o elemento inferior da pilha, n , para o topo e depois calcula os números de Fibonacci F (n) e F (n + 1) (deixando-os no topo da pilha). Nunca precisamos de F (n + 1) , mas ele será descartado fora da sub-rotina, devido à forma como os &w...kloops interagem com o RAS (que tipo de requer que esses loops estejam no final de uma sub-rotina). A razão pela qual estamos pegando elementos da parte inferior em vez da parte superior é que isso nos permite tratar a pilha mais como uma fila, o que significa que podemos calcular todos os números de Fibonacci de uma só vez sem precisar armazená-los em outro lugar.

Aqui está como essa sub-rotina funciona:

                                                          Stack
01    Push 0 and 1, to initialise Fibonacci sequence.     [n ... 0 1]
dt,   Pull bottom element n to top.                       [... 0 1 n]
t&w   Run this loop n times...                            [... F(i-2) F(i-1)]

  .     Duplicate F(i-1).                                 [... F(i-2) F(i-1) F(i-1)]
  2,    Pull up F(i-2).                                   [... F(i-1) F(i-1) F(i-2)]
  +     Add them together to get F(i).                    [... F(i-1) F(i)]

k     End of loop.

O final do ciclo é um pouco complicado. Enquanto houver uma cópia do endereço 'w' na pilha, isso inicia a próxima iteração. Uma vez esgotados, o resultado depende de como a sub-rotina foi invocada. Se a sub-rotina foi chamada com 'j', o último 'k' retorna lá, então o final do loop é duplicado como o retorno da sub-rotina. Se a sub-rotina foi chamada com 'J' e ainda há um endereço anterior na pilha, pulamos para lá. Isso significa que se a sub-rotina foi chamada no próprio loop externo, esse 'k' retorna ao início desse loop externo . Se a sub-rotina foi chamada com 'J', mas o RAS está vazio agora, esse 'k' não faz nada e o IP simplesmente continua se movendo após o loop. Usaremos todos os três casos no programa.

Finalmente, para o próprio programa.

/o....
\i@...

Estas são apenas duas excursões rápidas ao modo Ordinal para ler e imprimir números inteiros decimais.

Após o i, existe um wque lembra a posição atual antes de passar para a sub-rotina, devido à segunda /. Essa primeira chamada da sub-rotina calcula F(n)e F(n+1)na entrada n. Depois, voltamos para cá, mas estamos indo para o leste agora, então o restante dos operadores do programa está no modo Cardinal. O programa principal fica assim:

;B1dt&w;31J;d&+
        ^^^

Aqui 31Jestá outra chamada para a sub-rotina e, portanto, calcula um número de Fibonacci.

                                              Stack
                                              [F(n) F(n+1)]
;     Discard F(n+1).                         [F(n)]
B     Push all divisors of F(n).              [d_1 d_2 ... d_p]
1     Push 1. This value is arbitrary.        [d_1 d_2 ... d_p 1]
      The reason we need it is due to
      the fact that we don't want to run
      any code after our nested loops, so
      the upcoming outer loop over all
      divisors will *start* with ';' to
      discard F(d+1). But on the first
      iteration we haven't called the
      subroutine yet, so we need some 
      dummy value we can discard.
dt&w  Run this loop once for each element     [d_1 d_2 ... d_p 1]
      in the stack. Note that this is once    OR
      more than we have divisors. But since   [d_i d_(i+1) ... F(d_(i-1)) F(d_(i-1)+1)] 
      we're treating the stack as a queue,
      the last iteration will process the 
      first divisor for a second time. 
      Luckily, the first divisor is always 
      1 and F(1) = 1, so it doesn't matter 
      how often we process this one.

  ;     Discard the dummy value on the        [d_1 d_2 ... d_p]
        first iteration and F(d+1) of         OR
        the previous divisor on subsequent    [d_i d_(i+1) ... F(d_(i-1))]
        iterations.
  31J   Call the subroutine without pushing   [d_(i+1) ... F(d_i) F(d_i+1)]
        the current address on the RAS.
        Thereby, this doubles as our outer
        loop end. As long as there's an
        address left from the 'w', the end
        of the subroutine will jump there
        and start another iteration for the
        next divisor. Once that's done, the
        'k' at the end of the subroutine will
        simply do nothing and we'll continue
        after it.

;     Discard the final F(d_i+1).
d&+   Get the stack depth D and add the top   [final result]
      D+2 values. Of course that's two more
      than we have divisors, but the stack is
      implicitly padded with zeros, so that
      doesn't matter.

Axioma, 68 bytes

g==>fibonacci;f(x:NNI):NNI==(x<3=>1;reduce(+,map(g,divisors(g(x)))))

algum teste

(46) -> [[i,f(i)] for i in [0,1,2,3,4,5,6,10,15] ]
   (46)
   [[0,1], [1,1], [2,1], [3,2], [4,3], [5,6], [6,26], [10,139583862540],
     [15,
      135823697912782666169062844948067355657769395021071830756126284114988028_
       12823029319917411196081011510136735503204397274473084444
     ]
   ]
                                       Type: List List NonNegativeInteger

Pari / GP , 34 bytes

n->sumdiv((f=fibonacci)(n),x,f(x))

Experimente online!

Python 2 , 89 84 bytes

^{-5 bytes graças a ovs}

lambda n:sum(f(i)for i in range(1,f(n)+1)if f(n)%i<1)
f=lambda x:x<3or f(x-1)+f(x-2)

Experimente online!

R, 77 bytes

F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)

Faz uso da biblioteca 'gmp'. Isso possui uma função Fibonacci integrada e fornece a capacidade de realizar grandes números. Isso causou alguns problemas com seqs e applys, embora ainda seja menor do que criar minha própria função Fibonacci.

Explicação

F=gmp::fibnum;               # Set F as fibnum function
N=F(scan());                 # get input and set N to the fibonacci number of that index
i=n=N-N;                     # set i and n to 0 with data type bigz
while(i<N)                   # loop while i < N
   if(N%%(i=i+1)<1)          # if incremented i is divisor of N 
       n=n+F(i);             # add F(i) to rolling sum
print(n)                     # output final result

Teste

> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 6
2: 
Read 1 item
Big Integer ('bigz') :
[1] 26
> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 10
2: 
Read 1 item
Big Integer ('bigz') :
[1] 139583862540
> F=gmp::fibnum;N=F(scan());i=n=N-N;while(i<N)if(N%%(i=i+1)<1)n=n+F(i);print(n)
1: 15
2: 
Read 1 item
Big Integer ('bigz') :
[1] 13582369791278266616906284494806735565776939502107183075612628411498802812823029319917411196081011510136735503204397274473084444

Sem usar gmp

81 bytes , função recursiva que é irremediavelmente lenta quando números grandes (9+) são selecionados

F=function(n)`if`(n<2,n,F(n-1)+F(n-2));sum(sapply(which((N=F(scan()))%%1:N<1),F))

88 bytes , a fórmula de Binet que funcionará razoavelmente bem com números maiores, mas ainda atinge o limite inteiro rapidamente

F=function(n)round(((5+5^.5)/10)*((1+5^.5)/2)^(n-1));sum(F(which(F(N<-scan())%%1:N<1)))

Perl 6 , 49 bytes

{my \f=0,1,*+*...*;sum f[grep f[$_]%%*,1..f[$_]]}

CJam , 26 bytes

qi_[XY@{_2$+}*]_@\f%:!.*:+

Experimente online!

Tenho certeza que isso pode ser feito melhor. Explicação:

A idéia é ter uma matriz de números de Fibonacci e pontuá-la com uma matriz com 1s e 0s se esse número for ou não um divisor da entrada.

qi                                 Read the input (n)
   [XY        ]                    Array starting with [1,2,...]
  _   @{_2$+}*                     Append n times the sum of the previous two
               _                   Duplicate the array
                @\f%               Modulo each item with n (0 if divisor, a number otherwise)
                    :!             Logical NOT everything (1 if divisor, 0 otherwise) 
                      .*:+         Dot product those two arrays

JavaScript (ES6), 76 65 bytes

f=(n,i=k=(F=n=>n>1?F(n-1)+F(n-2):n)(n))=>i&&(k%i?0:F(i))+f(n,i-1)

Casos de teste

f=(n,i=k=(F=n=>n>1?F(n-1)+F(n-2):n)(n))=>i&&(k%i?0:F(i))+f(n,i-1)

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))

JavaScript (ES6), 105 104 103 101 97 bytes

i=>[...Array((g=(n,x=0,y=1)=>n--?g(n,y,x+y):x)(i)+1)].map((_,y)=>s+=g((z=g(i)/y)%1?0:z|0),s=0)&&s

Tente

f=
i=>[...Array((g=(n,x=0,y=1)=>n--?g(n,y,x+y):x)(i)+1)].map((_,y)=>s+=g((z=g(i)/y)%1?0:z|0),s=0)&&s
o.innerText=f(j.value=4)
oninput=_=>o.innerText=f(+j.value)

<input id=j type=number><pre id=o>

Q, 75 bytes

{f:{$[x<2;x;.z.s[x-1]+.z.s[x-2]]};sum f each m where(~)b mod m:1+til b:f x}

C (gcc) , 93 90 80 bytes

F(n){n=n<2?n:F(n-1)+F(n-2);}i,s;f(n){for(s=0,i=F(n);i;i--)s+=F(n)%i?0:F(i);n=s;}

Experimente online!

Adicionar ++ , 89 bytes

D,f,@@@@*,V$2D+G1+dAppp=0$Qp{f}p
D,r,@,¿1=,1,bM¿
D,g,@,¿1_,1_001${f},1¿{r}
D,d,@,{g}dF€gs

Experimente online!