이 작업은 소인수 분해를 고려하여 숫자의 제수 합계를 계산하는 것입니다.

입력

길이 n 의 두 배열 (또는 동등한 것) , 하나는 소인수를 포함하고 다른 하나는 해당 지수를 포함합니다.

산출

모든 제수의 합 (수 자체 포함).

예

240은 2, 3, 5를 소인수로, 4, 1, 1을 각각의 지수로 갖습니다. 그러면 예상 출력은 744입니다.

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

채점

바이트 단위의 최단 코드가 승리합니다!

솔루션의 런타임 복잡도가 O (지수의 곱)가 아닌 O (지수의 합) 인 경우 점수에 0.8을 곱할 수 있습니다.

거기에 있었다 비슷한 질문 여기에 게시,하지만 그것은 문제가 아니었다. 문제는 골프를 치기에는 충분하다고 생각합니다.

이번 주말에 우승자가 선정됩니다

Pyth, 13 바이트 * 0.8 = 10.4

*Fms^LhdhedCQ

데모.

이 답변은 위의 답변과 약간 다르게 작동합니다. 산술 공식을 사용하는 대신 숫자의 주요 거듭 제곱의 요인의 합을 계산하기 위해 요인을 명시 적으로 구성하고 합산합니다.

예를 들어, [프라임 지수] 쌍 [2, 4], 우리는지도 2 ^ x위에 0, 1, 2, 3, 4제공 [1, 2, 4, 8, 16]한 다음 31 합산된다.

그런 다음 결과를 곱한 후 인쇄합니다.

지수가 올바르게 구현되거나 중간 결과 캐싱이있는 경우이 값이됩니다 O(sum of exponents).

CJam, 15 바이트 * 0.8 = 12

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

온라인으로 사용해보십시오 . 입력 순서는 먼저 지수 목록이고 소수 목록 (@Dennis 덕분에 -3 바이트) 입니다.

각 프라임 지수 쌍에 대한 (p, e)발견

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

그런 다음이 모든 제품을 찾으십시오. 예를 들어 240의 경우

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

지수가 구현되는 방법에 따라이 방법이 낫습니다 O(sum of exponents).

APL, 18 13 바이트 * 0.8 = 10.4

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

이것은 왼쪽에있는 요소와 오른쪽에있는 지수의 배열을 취하는 2 차원 함수 트레인을 만듭니다.

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

온라인으로 사용해보십시오 . 이것은 Sp3000의 굉장히 영리한 CJam 답변 과 동일한 접근 방식 입니다.

Dennis 덕분에 5 바이트를 절약했습니다!

TI-BASIC, 17 바이트 * 0.8 = 13.6

Sp3000의 방법을 사용하지만 독립적으로 찾았습니다. 입력과 홈 화면에서 하나의 목록을 가져옵니다.

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

prod (두 번 사용하면 오픈 괄호를 무료로 사용할 수 있기 때문에 더 작습니다. TI-BASIC에는 빈 배열이 없으므로이 답변은 빈 배열을 지원하지 않습니다.

하스켈, 38 * 0.8 = 30.4

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

용법:

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

익명 함수는 기하 계열 합계 (p,e)를 p^e통해 제수 합계를 취 합니다 . 두 목록을 함께 결합하여 제품을 결합하고 결과를 가져옵니다.

산술 표현보다 짧은 것을 찾을 수 없었습니다.

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

를 제거하는 방법이있을 수 (\p e->_)있습니다.

삽입 함수 정의는 동일한 길이 (38)를 제공합니다.

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

C ++, 111 80 77 바이트 * 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;}

이것은 (p ^ (e + 1) -1) / (p-1)을 계산하고 모든 요소를 ​​재귀 적으로 곱합니다. 1 년 전에 그 사실을 알았습니다.

C ++ 스타일의 부울 사용법을 완전히 잊어 버렸습니다.

MATLAB, 53

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

예:

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

파이썬 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]])))

입력

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

산출

744

설명

이 프로그램은 요인과 지수의 두 가지 목록을받습니다.

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

그런 다음 지수 목록의 가능한 모든 조합 목록을 만듭니다.

[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)]

그리고 요인으로 압축하십시오 :

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)]]

지수의 거듭 제곱에 대한 요소를 계산합니다.

 [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]]

각 목록을 곱하십시오 (이것은 모든 제수를 제공합니다).

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]

마지막으로 모든 목록을 요약하고 인쇄하십시오.

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

파이썬 3 134 120 117

입력 : 쉼표로 구분 된 두 개의 쉼표로 구분 된 배열.

예:

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

NumPy를 사용하면 100 바이트로 줄일 수 있습니다.

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

경쟁하지 않는 젤리

이 도전은 젤리의 창조에 앞서 도전이되기 때문에 경쟁이 아닙니다.

5 바이트 (보너스 없음)

*PÆDS

온라인으로 사용해보십시오!

작동 원리

*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 바이트 (보너스 후 5.6 바이트)

*‘}’:’{P

작동 원리

×*’:’{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.

온라인으로 사용해보십시오!

APL, 12 바이트 * 0.8 = 9.6

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

키보드에서 두 개의 목록을 읽습니다 (예 : 지수).

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

설명:

• ⎕: 키보드에서 목록을 읽습니다 (지수)
• ⍳¨: 목록의 각 숫자에 대해 목록을 생성하십시오 [1..n].
• ⎕*: 키보드 (프라임)에서 다른 목록을 읽고 각 목록을 해당 목록의 각 지수로 올립니다.
• +/¨: 각 목록 합계
• 1+: x^0각 목록에 누락 된 부분을 보완하기 위해 각 결과에 하나씩 추가
• ×/: 결과의 곱을 가져옵니다

라켓 (스키마), 65 * 0.8 = 52 바이트

다른 사람들과 같은 산술

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

설명:

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

파이썬 2, 80 바이트 * 0.8 = 64

이것은 입력이 차례대로 들어 온다고 가정합니다. Sp3000의 CJam 답변에 설명 된 것과 동일한 공식을 따릅니다.

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

이것이 허용되지 않으면 이것을 84 바이트 * 0.8 = 67.2의 점수를 얻는 솔루션으로 사용합니다. 입력은 쉼표로 구분해야합니다 (예 :) [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))

^{Psst. 야! 이것은 Symbolic에서 가능한 해결책입니다.Ƥ(П([~-(x**-~y)/~-xϝx,yϊʐ(Ί,Ί)],1))}

Mathematica, 40 바이트

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

제수를 다루는 내장 함수를 사용하지 않고 스레드의 다른 수학 솔루션과 차별화 할 수 있습니다.

입력은 (예를 사용하여) [{2, 3, 5}, {4, 1, 1}]

펄 5, 96 바이트

분명히 이것은 이기지 못했지만 재미있게 작성하기로 결정했습니다.

서브 루틴입니다.

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

따라서 실제로 작동하는 것을보십시오.

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

작동 방식 :

• ($b,$e)=@_입력 배열 참조 $b(기본) 및 $e(지수)를 읽습니다 .
• $s=1 제품을 초기화합니다.
• map$s*=$b->[$_]**$e->[$_],0..@$b-1$s연속 기하 지수에 곱 합니다. 이제 $s복합 번호입니다.
• $_=1x$s$_1의 문자열과 동일하게 설정합니다 $s. $i0에서 초기화됩니다.
• for$j(1..$s){$i+=$j*/^(.{$j})*$/}시도는 모든 번호 $j1 사이 $s, 깰 $_로 최대 $j문자가 여러 번 반복했다. 가능하면을 $j나누고 1 $s이고 /^(.{$j})*$/(그렇지 않으면 0) $i으로 증가합니다 $j. 따라서 $i동일한 크기의 파티션에있는 파티션 수를 추가합니다 $_. 으로 오마르 E. 폴 지적 , $i우리가 추구하고있는 번호입니다.
• $i끝에는를 반환합니다 $i.

J, 14 바이트 * 0.8 = 11.2

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

용법

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