Nhiệm vụ là tính tổng số chia của một số cho hệ số nguyên tố của nó.

Đầu vào

Hai mảng (hoặc một cái gì đó tương đương) có độ dài n , một mảng chứa thừa số nguyên tố và mảng kia chứa số mũ tương ứng.

Đầu ra

Tổng của tất cả các ước (bao gồm cả số chính nó).

Thí dụ

Số 240 có 2, 3 và 5 là các thừa số nguyên tố với 4, 1 và 1 là các số mũ tương ứng. Sản lượng dự kiến ​​sau đó sẽ là 744.

Input: [2,3,5] [4,1,1]
Output: 744

Chấm điểm

Mã ngắn nhất trong byte thắng!

Nếu độ phức tạp thời gian chạy của giải pháp của bạn là O (tổng số mũ) thay vì O (sản phẩm của số mũ), điểm của bạn có thể được nhân với 0,8.

Có một câu hỏi tương tự được đăng ở đây, nhưng đó không phải là một thách thức. Tôi nghĩ rằng vấn đề là đủ thú vị để được chơi golf.

Người chiến thắng sẽ được chọn vào cuối tuần này

Bình thường, 13 byte * 0,8 = 10,4

*Fms^LhdhedCQ

Trình diễn.

Câu trả lời này hoạt động hơi khác với những người ở trên. Để tính tổng các yếu tố của các lũy thừa của số, thay vì sử dụng công thức số học, các yếu tố được xây dựng và tổng hợp một cách rõ ràng.

Ví dụ, trên [đắc địa, số mũ] cặp [2, 4], chúng tôi lập bản đồ 2 ^ xtrên 0, 1, 2, 3, 4, cho [1, 2, 4, 8, 16], sau đó được tổng hợp đến 31.

Các kết quả sau đó được nhân với nhau và được in.

Nếu lũy thừa được thực hiện đúng, hoặc nếu có bộ đệm kết quả trung gian, điều này sẽ được O(sum of exponents).

CJam, 15 byte * 0,8 = 12

q~.{_@)#(\(/}:*

Hãy thử trực tuyến . Thứ tự đầu vào là danh sách số mũ trước, sau đó là danh sách các số nguyên tố (-3 byte nhờ @Dennis) .

Đối với mỗi số nguyên tố-mũ cặp (p, e)tìm

(p^(e+1) - 1)/(p - 1)

sau đó tìm sản phẩm của tất cả những thứ này Ví dụ: 240 sẽ là

(1 + 2 + 4 + 8 + 16)(1 + 3)(1 + 5) = 31 * 4 * 6 = 744

Tùy thuộc vào cách thức lũy thừa được thực hiện, điều này có thể tốt hơn O(sum of exponents).

APL, 18 13 byte * 0,8 = 10,4

×/(1-⊣×*)÷1-⊣

Điều này tạo ra một hàm chức năng dyadic lấy mảng các yếu tố ở bên trái và số mũ ở bên phải.

×/             ⍝ Vector product of
  (1-⊣×*)      ⍝ each factor^(exponent+1)-1
         ÷1-⊣  ⍝ divided by factor-1

Hãy thử trực tuyến . Lưu ý rằng đây là cách tiếp cận tương tự như câu trả lời CJam cực kỳ thông minh của Sp3000 .

Đã lưu 5 byte nhờ Dennis!

TI-BASIC, 17 byte * 0,8 = 13,6

Cũng sử dụng phương pháp của Sp3000, mặc dù tôi thấy nó độc lập. Lấy một danh sách từ Input và một từ màn hình chính.

Input E
prod(AnsAns^∟E-1)/prod(Ans-1

Sử dụng prod (hai lần nhỏ hơn vì nó cho phép chúng tôi sử dụng dấu ngoặc đơn mở miễn phí. Lưu ý rằng câu trả lời này không hỗ trợ mảng trống, vì không có mảng trống trong TI-BASIC.

Haskell, 38 * 0,8 = 30,4

product$zipWith(\p e->(p*p^e-1)/(p-1))

Sử dụng:

product$zipWith(\p e->(p*p^e-1)/(p-1)) [2,3,5] [4,1,1]
744.0

Hàm ẩn danh sẽ (p,e)tính tổng chia cho p^ethông qua tổng chuỗi hình học. Kết hợp hai danh sách này với nhau khi kết nối và lấy sản phẩm sẽ cho kết quả.

Tôi đã không thể tìm thấy bất cứ điều gì ngắn hơn biểu thức số học

(p*p^e-1)/(p-1)
sum$map(p^)[0..e]

Có lẽ có một cách để thoát khỏi (\p e->_).

Định nghĩa hàm Infix cho cùng độ dài (38):

p%e=(p*p^e-1)/(p-1)
product$zipWith(%)

C ++, 111 80 77 byte * 0,8 = 61,6

int g(int*p,int*e,int n){return n?g(p+1,e+1,n-1)*(pow(*p,*e-1)-1)/(*p-1):1;}

Điều này tính toán (p ^ (e + 1) -1) / (p-1) và nhân đệ quy tất cả các yếu tố. Tìm thấy điều đó một năm trước.

Cảm ơn bạn đã giúp đỡ, hoàn toàn quên mất cách sử dụng boolean kiểu c ++.

Matlab, 53

function t=f(x,y)
s=1:prod(x.^y);t=s*~mod(s(end),s)';

Thí dụ:

>> f([2 3 5], [4 1 1])
ans =
   744

Con trăn 2.156

from itertools import*
from operator import*
i=input()
print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])))

Đầu vào

[[2,3,5],[4,1,1]]

Đầu ra

744

Giải trình

Chương trình này nhận được danh sách 2 danh sách: các yếu tố và số mũ.

i=input() # Receive list of 2 lists: i[0] for factors i[1] for exponents

Sau đó, nó tạo danh sách tất cả các kết hợp có thể có của danh sách số mũ.

[x+1 for x in i[1]] # [4,1,1]->[5,2,2] (to include last element)
map(range,[x+1 for x in i[1]]) # [[0, 1, 2, 3, 4], [0, 1], [0, 1]]
product(*map(range,[x+1 for x in i[1]])) # [(0, 0, 0), (0, 0, 1), ..., (4, 1, 1)]

và nén nó với các yếu tố:

zip(i[0],p) for p in product(*map(range,[x+1 for x in i[1]])) # [[(2, 0), (3, 0), (5, 0)], ..., [(2, 4), (3, 1), (5, 1)]]

Tính các yếu tố cho sức mạnh của số mũ:

 [a**b for a,b in zip(i[0],p)]for p in product(*map(range,[x+1 for x in i[1]])) # [[1, 1, 1], ..., [16, 3, 5]]

và nhân từng danh sách (điều này cho chúng ta tất cả các ước số):

reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])) # [1, 5, 3, 15, ..., 240]

Cuối cùng, tổng hợp tất cả các danh sách và in:

print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]]))) # 744

Trăn 3, 134 120 117

Đầu vào: hai mảng được phân tách bằng dấu phẩy cách nhau bởi dấu phẩy.

Thí dụ:

(2,3,7,11),(4,2,3,2)
21439600

from functools import*
a=eval(input())
print(reduce(int.__mul__,(sum(x**j for j in range(y+1))for x,y in zip(*a)),1))

Với NumPy có thể giảm xuống còn 100 byte:

import numpy
a=eval(input())
print(numpy.product([sum(x**j for j in range(y+1))for x,y in zip(*a)]))

Thạch, không cạnh tranh

Câu trả lời này là không cạnh tranh, vì thử thách trước khi tạo ra Jelly.

5 byte (không có tiền thưởng)

*PÆDS

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

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

*PÆDS    Main link. Left input: p (prime factors). Right input: e (exponents).

*        Elevate the prime factors to the corresponding exponents.
 P       Take the product of all powers.
  ÆD     Find all divisors of the product.
    S    Compute the sum of the divisors.

7 byte (5,6 byte sau khi thưởng)

*‘}’:’{P

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

×*’:’{P  Main link. Left input: p (prime factors). Right input: e (exponents).

 *       Elevate the prime factors to the corresponding exponents.
         This yields p ** e.
×        Multiply the prime factors with the corresponding powers.
         This yields p ** (e + 1).
  ’      Decrement the resulting products.
         This yields p ** (e + 1) - 1.
    ’{   Decrement the prime factors.
         This yields p - 1.
   :     Divide the left result by the right one.
         This yields (p ** (e + 1) - 1) / (p - 1).
      P  Take the product of all quotients.

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

APL, 12 byte * 0,8 = 9,6

×/1++/¨⎕*⍳¨⎕

Điều này đọc hai danh sách từ bàn phím, số mũ đầu tiên, nghĩa là:

      ×/1++/¨⎕*⍳¨⎕
⎕:
      4 1 1
⎕:
      2 3 5
744

Giải trình:

• ⎕: đọc danh sách từ bàn phím (số mũ)
• ⍳¨: cho mỗi số trong danh sách, tạo danh sách [1..n].
• ⎕*: đọc danh sách khác từ bàn phím (số nguyên tố) và nâng từng số nguyên tố lên từng số mũ trong danh sách tương ứng
• +/¨: tổng hợp từng danh sách
• 1+: thêm một vào mỗi kết quả, để bù cho phần còn thiếu x^0trong mỗi danh sách
• ×/: lấy sản phẩm của kết quả

Vợt (Lược đồ), 65 * 0,8 = 52 byte

Số học giống như những người khác

(λ(x y)(foldl(λ(m n o)(*(/(-(expt m(+ n 1))1)(- m 1))o))1 x y))

Giải trình:

(λ (x y)    ;defines anonymous function with two inputs
    (foldl    ;recursively applies the following function to all elements of the lists given to an argument given (foldl function argument lists lists lists...)
        (λ (m n o) (* (/ (- (expt m (+ n 1)) 1) (- m 1)) o))    ;an anonymous function representing the same arithmetic used in the CJam answer, then multiplying it with our incrementor
        1 x y))    ;the incrementor argument is 1, and the input lists are the ones provided into the original function

Python 2, 80 byte * 0,8 = 64

Điều này giả định đầu vào đến cái khác. Theo công thức tương tự như được nêu trong câu trả lời CJam của Sp3000.

print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(input(),input())],1)) 

Nếu điều này không được phép, thì tôi sẽ sử dụng nó như một giải pháp, được điểm 84 byte * 0.8 = 67.2. Đầu vào nên được phân tách bằng dấu phẩy, nghĩa là [2,3,5],[4,1,1].

k=input()
print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(k[0],k[1])],1))

^{Thánh ca Chào! Đây là một giải pháp khả thi trong Symbolic, một cái gì đó tôi đang làm việc:Ƥ(П([~-(x**-~y)/~-xϝx,yϊʐ(Ί,Ί)],1))}

Toán học, 40 byte

Total[Outer@@{*}~Join~(#^0~Range~#2),3]&

Không sử dụng bất kỳ inbuilts nào liên quan đến ước số, để phân biệt với các giải pháp toán học khác trong luồng.

Đầu vào là (sử dụng ví dụ) [{2, 3, 5}, {4, 1, 1}]

Perl 5, 96 byte

Rõ ràng đây là không chiến thắng, nhưng tôi quyết định viết nó cho vui.

Đó là một chương trình con:

{($b,$e)=@_;$s=1;map$s*=$b->[$_]**$e->[$_],0..@$b-1;$_=1x$s;for$j(1..$s){$i+=$j*/^(.{$j})*$/}$i}

Xem nó trong hành động như vậy:

perl -e'print sub{...}->([2,3,5],[4,1,1])'

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

• ($b,$e)=@_đọc các mảng đầu vào $b(cơ sở) và $e(số mũ).
• $s=1 khởi tạo sản phẩm.
• map$s*=$b->[$_]**$e->[$_],0..@$b-1nhân với $scác lũy thừa cơ sở liên tiếp. Bây giờ $slà số tổng hợp.
• $_=1x$sbộ $_bằng một chuỗi của những cái, $sdài. $iđược khởi tạo ở 0.
• for$j(1..$s){$i+=$j*/^(.{$j})*$/}cố gắng, cho mọi số $jtừ 1 đến $s, chia $_tay khi các $jký tự lặp lại bất kỳ số lần nào. Nếu có thể, thì $jchia $svà /^(.{$j})*$/là 1 (nếu không là 0) và $iđược tăng thêm $j. Vì vậy, chúng tôi thêm vào $isố lượng phân vùng trong một phân vùng có kích thước bằng nhau $_. Như Omar E. Pol chỉ ra , $ilà con số chúng tôi đang tìm kiếm.
• $itại trở về cuối $i.

J, 14 byte * 0,8 = 11,2

[:*/(^>:)%&<:[

Sử dụng

   f =: [:*/(^>:)%&<:[
   2 3 5 f 4 1 1
744