Знаменита послідовність Фібоначчі F(0) = 0; F(1) = 1; F(N+1) = F(N) + F(N-1)(для цього виклику ми починаємо з 0).

Ваше завдання: Дано п , вихід сума всіх ї - й чисел Фібоначчі для всіх дільників d від п - го числа Фібоначчі. Якщо ви віддаєте перевагу більш офіційним позначенням,

Введення : натуральне число n

Вихід : сума

Наприклад, розглянемо n=4. F(4) = 3Дільники 3 дорівнюють 1 і 3, тому вихід повинен бути F(1) + F(3) = 1 + 2 = 3.

Бо n=6, F(6) = 8і дільники 8 дорівнюють 1, 2, 4, 8, тому вихід є F(1) + F(2) + F(4) + F(8) = 1 + 1 + 3 + 21 = 26.

Випробування:

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

Це кодовий гольф , найкоротша відповідь у виграші байтів. Застосовуються стандартні лазівки .

Власне , 5 байт

F÷♂FΣ

Спробуйте в Інтернеті!

Як це працює

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

Желе , 7 байт

ÆḞÆDÆḞS

Спробуйте в Інтернеті!

Пояснення:

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

Математика, 29 байт

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

Математика спрощена , 14 байт

Fi@#~Div9`~Fi&

Ну добре, це виявилося ідентичним рішенням @ MartinEnder ...

Japt , 11 байт

MgU â x@MgX

Спробуйте в Інтернеті!

05AB1E , 11 байт

!ÅFDI<èÑ<è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 байти

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

Приклад використання: g 6-> 26. Спробуйте в Інтернеті!

Аліса , 38 36 байт

Дякуємо Лео за збереження 2 байтів.

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

Спробуйте в Інтернеті!

Майже точно не оптимально. Контрольний потік досить складний, і хоча я цілком задоволений тим, скільки байтів збережено за попередні версії, у мене є відчуття, що я надмірно ускладнюю те, що може бути простіше і коротше рішення.

Пояснення

По-перше, мені потрібно трохи розробити стек зворотної адреси Аліси (RAS). Як і багато інших фрінгейдів, Аліса має команду стрибати навколо коду. Однак у нього також є команди повертатися туди, звідки ви прийшли, що дозволяє досить зручно реалізувати підпрограми. Звичайно, що це 2D мова, підпрограми дійсно існують лише за умовами. Ніщо не заважає вам входити або залишати підпрограму за допомогою іншого способу, ніж команда return (або в будь-якій точці підпрограми), і залежно від того, як ви використовуєте RAS, інакше не може бути ієрархії стрибків / повернень.

Взагалі це реалізується за рахунок того, щоб команда стрибок jнатискала поточну IP-адресу до RAS перед переходом. Потім команда return повертається kдо адреси RAS і стрибає туди. Якщо RAS порожній,k взагалі нічого не робить.

Існують також інші способи маніпулювання RAS. Дві з них стосуються цієї програми:

• wнатискає поточну IP-адресу до RAS, не перестрибуючи нікуди. Якщо ви повторите цю команду, ви можете написати прості цикли досить зручно &w...k, що я вже робив у минулих відповідях.
• Jяк, jале не пам'ятає поточну IP-адресу в RAS.

Важливо також зазначити, що RAS не зберігає інформації про напрямок ІС. Тож повернення до адреси з адресою kзавжди буде зберігати поточний напрямок IP (а отже, також, перебуваємо ми в режимі кардинала чи ординалу) незалежно від того, як ми пройшли через jабоw що натиснули IP-адресу в першу чергу.

Із цього шляху почнемо з того, що розглянемо підпрограму у вищевказаній програмі:

01dt,t&w.2,+k

Ця підпрограма витягує нижній елемент стека, n , до верхнього, а потім обчислює числа Фібоначчі F (n) і F (n + 1) (залишаючи їх у верхній частині стека). Нам ніколи не потрібен F (n + 1) , але він буде відкинутий поза підпрограмою через те, як &w...kпетлі взаємодіють з RAS (який тип вимагає, щоб ці петлі були в кінці підпрограми). Причина, за якою ми беремо елементи знизу, а не зверху, полягає в тому, що це дозволяє нам ставитись до стека як до черги, а це означає, що ми можемо обчислити всі числа Фібоначчі за один раз без необхідності зберігати їх в іншому місці.

Ось як працює ця підпрограма:

                                                          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.

Кінець петлі трохи складний. Поки на стеку є копія адреси 'w', це починає наступну ітерацію. Після того, як вони будуть вичерпані, результат залежить від того, як викликалася підпрограма. Якщо підпрограму викликали з 'j', то останній 'k' повертається туди, тому кінець циклу подвоюється як повернення підпрограми. Якщо підпрограма була викликана символом "J", а в стеці є ще адреса з попереднього, ми переходимо туди. Це означає, що якщо підпрограма була викликана у самій зовнішній циклі, це 'k' повертається до початку цього зовнішнього циклу. Якщо підпрограма була викликана "J", але RAS зараз порожній, то цей "k" нічого не робить, і IP просто продовжує рухатися після циклу. Ми будемо використовувати всі ці три випадки в програмі.

Нарешті, до самої програми.

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

Це лише дві швидкі екскурсії в звичайний режим для читання та друку десяткових цілих чисел.

Після цього i, є a, wяке запам'ятовує поточну позицію перед переходом у підпрограму, завдяки другій /. Цей перший виклик обчислень підпрограми F(n)і F(n+1)на вході n. Потім ми стрибаємо сюди, але зараз рухаємося на схід, тому решта програмних операторів у режимі Кардинала. Основна програма виглядає так:

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

Ось 31Jще один виклик підпрограми і тому обчислює число Фібоначчі.

                                              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.

Аксіома, 68 байт

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

якийсь тест

(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

Парі / GP , 34 байти

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

Спробуйте в Інтернеті!

Python 2 , 89 84 байт

^{-5 байт завдяки овам}

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)

Спробуйте в Інтернеті!

R, 77 байт

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)

Використовує бібліотеку 'gmp'. Це має вбудовану функцію Фібоначчі і забезпечує можливість робити великі числа. Це спричинило кілька проблем із послідовностями та застосунками, хоча це все-таки менше, ніж створення власної функції Фібоначчі.

Пояснення

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

Тест

> 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

Без використання gmp

81 байт , рекурсивна функція, яка безнадійно повільна, коли вибираються великі (9+) числа

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

88 байт , формула Біне, яка буде досить добре працювати з більшими числами, але все ще досягає цілої межі досить швидко

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 байт

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

CJam , 26 байт

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

Спробуйте в Інтернеті!

Я впевнений, що це можна зробити краще. Пояснення:

Ідея полягає у тому, щоб мати масив чисел Фібоначчі і дотримати його масивом з 1s та 0s, якщо це число є або не є дільником введення.

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 байт

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)

Тестові справи

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 байт

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

Спробуй це

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 байт

{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 байт

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

Спробуйте в Інтернеті!

Додайте ++ , 89 байт

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

Спробуйте в Інтернеті!