Chuỗi Fibonacci nổi tiếng là F(0) = 0; F(1) = 1; F(N+1) = F(N) + F(N-1)(đối với thử thách này, chúng tôi đang bắt đầu bằng 0).

Thử thách của bạn: Cho n , xuất tổng của tất cả các số Fibonacci thứ d cho tất cả các ước số d của số Fibonacci thứ n . Nếu bạn thích ký hiệu chính thức hơn,

Đầu vào : một số nguyên dương n

Đầu ra : tổng

Ví dụ, xem xét n=4. F(4) = 3Các ước của 3 là 1 và 3, vì vậy đầu ra phải là F(1) + F(3) = 1 + 2 = 3.

Vì n=6, F(6) = 8và các ước của 8 là 1, 2, 4, 8, nên đầu ra là F(1) + F(2) + F(4) + F(8) = 1 + 1 + 3 + 21 = 26.

Các trường hợp thử nghiệm:

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

Đây là mã golf , câu trả lời ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

Trên thực tế , 5 byte

F÷♂FΣ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Thạch , 7 byte

ÆḞÆDÆḞS

Hãy thử trực tuyến!

Giải trình:

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

Toán học, 29 byte

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

Toán học Đơn giản hóa , 14 byte

Fi@#~Div9`~Fi&

Ồ, điều này cuối cùng giống hệt với giải pháp của @ MartinEnder ...

Japt , 11 byte

MgU â x@MgX

Hãy thử trực tuyến!

05AB1E , 11 byte

!ÅFDI<èÑ<èO

Hãy thử trực tuyến!

Giải trình

!            # 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 byte

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

Ví dụ sử dụng: g 6-> 26. Hãy thử trực tuyến!

Alice , 38 36 byte

Cảm ơn Leo đã lưu 2 byte.

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

Hãy thử trực tuyến!

Hầu như chắc chắn không tối ưu. Luồng điều khiển khá phức tạp và trong khi tôi khá hài lòng với số lượng byte được lưu so với các phiên bản trước đó, tôi có cảm giác rằng tôi đang quá lạm dụng những thứ có thể có một giải pháp đơn giản và ngắn hơn.

Giải trình

Đầu tiên, tôi cần xây dựng một chút về ngăn xếp địa chỉ trả lại của Alice (RAS). Giống như nhiều loại nấm khác, Alice có lệnh nhảy xung quanh trong mã. Tuy nhiên, nó cũng có các lệnh để trở về nơi bạn đến, cho phép bạn triển khai chương trình con khá thuận tiện. Tất nhiên, đây là ngôn ngữ 2D, chương trình con thực sự chỉ tồn tại theo quy ước. Không có gì ngăn bạn vào hoặc rời khỏi chương trình con thông qua các phương tiện khác ngoài lệnh trả về (hoặc tại bất kỳ điểm nào trong chương trình con), và tùy thuộc vào cách bạn sử dụng RAS, dù sao đi nữa, có thể không có phân cấp nhảy / trả lại sạch.

Nói chung, điều này được thực hiện bằng cách có lệnh nhảy jđẩy địa chỉ IP hiện tại đến RAS trước khi nhảy. Lệnh return ksau đó bật một địa chỉ của RAS và nhảy tới đó. Nếu RAS trống, kkhông làm gì cả.

Cũng có những cách khác để thao túng RAS. Hai trong số này có liên quan đến chương trình này:

• wđẩy địa chỉ IP hiện tại đến RAS mà không phải nhảy ở bất cứ đâu. Nếu bạn lặp lại lệnh này, bạn có thể viết các vòng lặp đơn giản khá thuận tiện như &w...kđiều mà tôi đã thực hiện trong các câu trả lời trước đây.
• Jgiống như jnhưng không nhớ địa chỉ IP hiện tại trên RAS.

Cũng cần lưu ý rằng RAS lưu trữ không có thông tin về hướng của IP. Vì vậy, trở về một địa chỉ với ksẽ luôn giữ gìn hiện hướng chỉ IP (và do đó cũng cho dù chúng ta đang ở trong Đức Hồng Y hay chế độ TT) bất kể thế nào chúng ta đi qua jhoặc wlà đẩy địa chỉ IP ở nơi đầu tiên.

Theo cách đó, hãy bắt đầu bằng cách xem xét chương trình con trong chương trình trên:

01dt,t&w.2,+k

Chương trình con này kéo phần tử dưới cùng của ngăn xếp, n , lên trên cùng và sau đó tính toán các số Fibonacci F (n) và F (n + 1) (để chúng ở trên cùng của ngăn xếp). Chúng ta không bao giờ cần F (n + 1) , nhưng nó sẽ bị loại bỏ bên ngoài chương trình con, do cách &w...kcác vòng lặp tương tác với RAS (loại yêu cầu các vòng lặp này ở cuối chương trình con). Lý do chúng tôi lấy các phần tử từ dưới lên thay vì trên cùng là vì điều này cho phép chúng tôi coi ngăn xếp giống như một hàng đợi hơn, điều đó có nghĩa là chúng tôi có thể tính toán tất cả các số Fibonacci trong một lần mà không phải lưu trữ chúng ở nơi khác.

Đây là cách chương trình con này hoạt động:

                                                          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.

Kết thúc của vòng lặp là một chút khó khăn. Miễn là có một bản sao của địa chỉ 'w' trên ngăn xếp, điều này sẽ bắt đầu lần lặp tiếp theo. Một khi những cái đó đã cạn kiệt, kết quả phụ thuộc vào cách chương trình con được gọi. Nếu chương trình con được gọi với 'j', 'k' cuối cùng sẽ trả về đó, vì vậy kết thúc vòng lặp sẽ tăng gấp đôi khi trở lại của chương trình con. Nếu chương trình con được gọi với 'J' và vẫn còn một địa chỉ từ trước đó trên ngăn xếp, chúng ta sẽ nhảy tới đó. Điều này có nghĩa là nếu chương trình con được gọi trong chính vòng lặp bên ngoài, 'k' này sẽ trở về điểm bắt đầu của vòng lặp bên ngoài đó . Nếu chương trình con được gọi với 'J' nhưng RAS hiện đang trống, thì 'k' này không làm gì cả và IP chỉ tiếp tục di chuyển sau vòng lặp. Chúng tôi sẽ sử dụng cả ba trường hợp này trong chương trình.

Cuối cùng, vào chương trình chính nó.

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

Đây chỉ là hai chuyến du ngoạn nhanh vào chế độ Thông thường để đọc và in số nguyên thập phân.

Sau iđó, có một wvị trí nhớ vị trí hiện tại trước khi chuyển sang chương trình con, do vị trí thứ hai /. Lệnh đầu tiên này của chương trình con tính toán F(n)và F(n+1)trên đầu vào n. Sau đó chúng tôi quay trở lại đây, nhưng chúng tôi đang di chuyển về phía đông, vì vậy phần còn lại của các nhà khai thác chương trình ở chế độ Cardinal. Chương trình chính trông như thế này:

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

Ở đây, 31Jlà một cuộc gọi khác đến chương trình con và do đó tính toán một số 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.

Tiên đề, 68 byte

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

một số bài kiểm tra

(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 byte

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

Hãy thử trực tuyến!

Python 2 , 89 84 byte

^{-5 byte nhờ vào 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)

Hãy thử trực tuyến!

R, 77 byte

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)

Làm cho việc sử dụng thư viện 'gmp'. Điều này có chức năng Fibonacci dựng sẵn và cung cấp khả năng thực hiện số lượng lớn. Nó đã gây ra một vài vấn đề với seqs và áp dụng, mặc dù nó vẫn nhỏ hơn so với việc tạo hàm Fibonacci của riêng tôi.

Giải trình

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

Kiểm tra

> 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

Không sử dụng gmp

81 byte , Hàm đệ quy chậm vô vọng khi số lớn (9+) được chọn

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

88 byte , công thức của Binet sẽ hoạt động hợp lý với số lượng lớn hơn, nhưng vẫn đạt giới hạn số nguyên khá nhanh

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 byte

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

CJam , 26 byte

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

Hãy thử trực tuyến!

Tôi chắc chắn rằng nó có thể được thực hiện tốt hơn. Giải trình:

Ý tưởng là có một mảng các số Fibonacci và chấm sản phẩm đó với một mảng có 1s và 0 nếu số đó là hoặc không phải là ước của đầu vào.

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 byte

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)

Các trường hợp thử nghiệm

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 byte

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

Thử nó

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 byte

{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 byte

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

Hãy thử trực tuyến!

Thêm ++ , 89 byte

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

Hãy thử trực tuyến!