... 계산!

당신은 달러와 센트로 돈의 양을 나타내는 변수와 동전 값의 배열을 프로그램에 전달할 것입니다. 코드에 전달 된 금액에 합산되는 주어진 코인 값 배열의 가능한 조합 수를 출력해야합니다. 이름이 지정된 동전으로 불가능한 경우 프로그램은을 반환해야합니다 0.

미국의 화폐 용어에 대한 참고 사항 :

• 1 센트 동전 : 페니
• 5 센트 동전 : 니켈
• 10 센트 동전 : 다임
• 25 센트 동전 : 쿼터 (쿼터 달러)

예 1 :

프로그램이 통과되었습니다 :

12, [1, 5, 10]

(12 센트)

산출:

4

12 센트를 생산하기 위해 명명 된 동전을 결합하는 4 가지 방법이 있습니다 :

1. 12 페니
2. 니켈 1 개와 동전 7 개
3. 니켈 2 개와 동전 2 개
4. 한 푼과 두 개의 동전

예 2 :

프로그램이 통과되었습니다 :

26, [1, 5, 10, 25]

(26 센트)

산출:

13

26 센트를 생산하기 위해 명명 된 동전을 결합하는 13 가지 방법이 있습니다 :

1. 페니 26 개
2. 페니 21 개 및 니켈 1 개
3. 16 페니 및 2 니켈
4. 동전 11 개와 니켈 3 개
5. 페니 6 개 및 니켈 4 개
6. 1 페니 및 5 니켈
7. 동전 16 개와 다임 1 개
8. 페니 6 개와 다임 2 개
9. 페니 11 개, 다임 1 개, 니켈 1 개
10. 페니 6 개, 다임 1 개, 니켈 2 개
11. 1 페니, 1 다임 및 3 니켈
12. 1 페니, 2 다임 및 1 니켈
13. 1 쿼터와 1 페니

예 3 :

프로그램이 통과되었습니다 :

19, [2, 7, 12]

산출:

2

19 센트를 생산하기 위해 명명 된 동전을 결합하는 두 가지 방법이 있습니다 :

1. 12 센트 동전 1 개 및 7 센트 동전 1 개
2. 1 7 센트 동전 및 6 2 센트 동전

예 4 :

프로그램이 통과되었습니다 :

13, [2, 8, 25]

산출:

0

13 센트를 생산하기 위해 명명 된 동전을 결합 할 수있는 방법은 없습니다.

이것은 샌드 박스를 통해 이루어졌습니다. 표준 허점이 적용됩니다. 이것은 코드 골프이므로 가장 적은 바이트를 가진 답이 이깁니다.

젤리 ( 포크 ), 2 바이트

æf

이것은 내가 Frobenius 해석 원자를 구현하기 위해 일하고있는 Jelly의 한 지점 에 의존 하므로 불행히도 온라인으로 시도 할 수 없습니다.

용법

$ ./jelly eun 'æf' '12' '[1,5,10]'
4
$ ./jelly eun 'æf' '26' '[1,5,10,25]'
13
$ ./jelly eun 'æf' '19' '[2,7,12]'
2
$ ./jelly eun 'æf' '13' '[2,8,25]'
0

설명

æf  Input: total T, denominations D
æf  Frobenius count, determines the number of solutions
    of nonnegative X such that X dot-product D = T

하스켈, 37 34 바이트

s#l@(c:d)|s>=c=(s-c)#l+s#d
s#_=0^s

사용 예 : 26 # [1,5,10,25]-> 13.

간단한 재귀 접근 : 목록에서 다음 숫자를 모두 시도하고 (양보다 작거나 같은 경우) 건너 뛰십시오. 숫자를 빼면 양이 0이되면 1else를 사용하거나 목록에 요소가없는 경우 a를 사용하십시오 0. 1s와 0s를 합산하십시오 .

편집 : @Damien : 재귀에 대한 더 짧은 기본 사례를 가리킴으로써 3 바이트를 절약했습니다 ( @xnors answer 에서도 찾을 수 있음 ).

매스 매 티카, 35 22 바이트

FrobeniusSolve13 바이트 를 제안 하고 절약 해 준 마일 덕분 입니다.

Length@*FrobeniusSolve

이름없는 함수로 평가합니다. 코인 목록을 첫 번째 인수로, 목표 값을 두 번째 인수로 사용합니다. FrobeniusSolveDiophantine 방정식을 풀기위한 약식입니다.

a1x1 + a2x2 + ... + anxn = b

에 대한 비 음수이고 우리에게 모든 솔루션을 제공합니다.xi

Pyth, 8 바이트

/sM{yS*E

실제 무차별 대입, 실제 테스트에는 메모리가 많이 사용됩니다. 이것은 O (2 ^mn )이며, 여기서 n 은 코인 수이고 m 은 목표 합계입니다. 로 입력을 target\n[c,o,i,n,s]받습니다.

/sM{yS*EQQ      (implicit Q's)
      *EQ       multiply coin list by target
     S          sort
    y           powerset (all subsequences)
   {            remove duplicates
 sM             sum all results
/        Q      count correct sums

하스켈, 37 바이트

s%(h:t)=sum$map(%t)[s,s-h..0]
s%_=0^s

첫 번째 코인의 일부 배수를 사용하면 h감소하는 진행에서 필요한 합계 s를 음이 아닌 값으로 줄이며 [s,s-h..0]나머지 코인으로 만들어야합니다. 동전이 남아 있지 않으면 합계가 산술적으로 0인지 확인하십시오 0^s.

자바 스크립트 (ES6), 51 48 바이트

f=(n,a,[c,...b]=a)=>n?n>0&&c?f(n-c,a)+f(n,b):0:1

어떤 순서로든 동전을받습니다. 첫 번째 코인을 사용하거나 사용하지 않고 두 가지 방법으로 조합 수를 재귀 적으로 계산합니다. n==0일치하는 조합을 n<0의미합니다. 동전이 수량을 초과 c==undefined함을 의미하고 동전이 남아 있지 않음 을 의미합니다. 이 기능은 매우 느리고 페니 동전이 있으면 다음 기능이 더 빠릅니다 (코인 배열에 페니 동전을 전달하지 마십시오).

f=(n,a,[c,...b]=a)=>c?(c<=n&&f(n-c,a))+f(n,b):1

펄, 45 바이트

바이트 수에는 44 바이트의 코드와 -p플래그가 포함됩니다.

s%\S+%(1{$&})*%g,(1x<>)=~/^$_$(?{$\++})^/x}{

첫 번째 줄의 동전 값과 두 번째 줄의 목표 금액을 가져옵니다.

$ perl -pE 's%\S+%(1{$&})*%g,(1x<>)=~/^$_$(?{$\++})^/x}{' <<< "1 5 10 25
26"
13

간단한 설명 :

-p                        # Set $_ to the value of the input, 
                          # and adds a print at the end of the code.
s%\S+%(1{$&})*%g,         # Converts each number n to (1{$&})* (to prepare the regex)
                          # This pattern does half the job.
(1x<>)                    # Converts the target to unary representation.
  =~                      # Match against.. (regex)
    /^ $_ $               # $_ contains the pattern we prepared with the first line.
     (?{$\++})            # Count the number of successful matches
     ^                    # Forces a fail in the regex since the begining can't be matched here.
    /x                    # Ignore white-spaces in the regex 
                          # (needed since the available coins are space-separated)
 }{                       # End the code block to avoid the input being printed (because of -p flag) 
                          # The print will still be executed, but $_ will be empty, 
                          # and only $\ will be printed (this variable is added after every print)

젤리 , 10 9 바이트

œċЀS€€Fċ

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

방법?

œċЀS€€Fċ - Main link: coins, target
  Ѐ      - map over right argument, or for each n in [1,2,...,target]
œċ        - combinations with replacement, possible choices of each of n coins
    S€€   - sum for each for each (values of those selections)
       F  - flatten into one list
        ċ - count occurrences of right argument

자바 스크립트 (ES6), 59 바이트

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),0):1

동전은 최고에서 최저로 입력됩니다 (예 :) f(26,[100,25,10,5,1]). 페니가 있으면 제거하고 훨씬 더 빠른 버전을 대신 사용하십시오.

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),1):1

이것은 @nimi와 매우 유사한 재귀 공식을 사용합니다. 나는 며칠 전에 도전이 여전히 샌드 박스에있을 때 이것을 썼습니다. 다음과 같이 보였습니다 :

f=(n,c=[100,25,10,5])=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),1):1

기본값 인 유일한 차이 c(원래 도전 설정치했다) 및 변경 0으로 .reduce하는 함수 1(이것은, 두 바이트 짧고보다 빠른 시간 bazillionc=[100,25,10,5,1] )으로 변경하는 것입니다.

다음은 조합 수가 아닌 모든 조합을 출력하는 수정 된 버전입니다.

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:[...x,...f(n-y,c.slice(i)).map(c=>[...c,y])],[]):[[]]

PHP, 327 바이트

function c($f,$z=0){global$p,$d;if($z){foreach($p as$m){for($j=0;$j<=$f/$d[$z];){$n=$m;$n[$d[$z]]=$j++;$p[]=$n;}}}else for($p=[],$j=0;$j<=$f/$d[$z];$j++)$p[]=[$d[$z]=>$j];if($d[++$z])c($f,$z);}$d=$_GET[a];c($e=$_GET[b]);foreach($p as$u){$s=0;foreach($u as$k=>$v)$s+=$v*$k;if($s==$e&count($u)==count($d))$t[]=$u;}echo count($t);

시도 해봐

공리, 63 62 바이트

@JonathanAllan에 의해 1 바이트 절약

f(n,l)==coefficient(series(reduce(*,[1/(1-x^i)for i in l])),n)

이 접근법은 함수 생성을 사용합니다. 코드 크기를 줄이는 데 도움이되지 않았을 것입니다. 나는 이것이 Axiom과 함께 연주 할 때 내 자신의 기능을 정의하는 한 처음이라고 생각합니다.

함수를 처음 호출하면 끔찍한 경고가 표시되지만 여전히 올바른 결과가 생성됩니다. 그 후에 목록이 비어 있지 않는 한 모든 것이 정상입니다.

R, 81 76 63 바이트

13 바이트를 골라 낸 @rturnbull에게 감사드립니다!

function(u,v)sum(t(t(expand.grid(lapply(u/v,seq,f=0))))%*%v==u)

예 ( c(...)값의 벡터를 R에 전달하는 방법입니다) :

f(12,c(1,5,10))
[1] 4

설명:

u원하는 값이고 v동전 값의 벡터입니다.

expand.grid(lapply(u/v,seq,from=0))

0에서 k 코인 (k는 교파에 따라 다름)의 가능한 모든 조합으로 데이터 프레임을 작성합니다. 여기서 k는 코인 값의 k 배가 u 이상 (달성 할 값)보다 k가 가장 낮습니다.

일반적으로 우리는 as.matrix 이것을 행렬로 바꾸는 데 하지만 많은 문자입니다. 대신 자동으로 강제 변환하지만 더 적은 문자를 사용하는 조옮김 (!)의 조옮김을 사용합니다.

%*% v그런 다음 각 행의 금전적 가치를 계산합니다. 마지막 단계는 원하는 값과 같은 값의 수를 세는 것 u입니다.

이것의 계산 복잡성과 메모리 요구 사항은 끔찍하지만 코드 골프입니다.

J, 27 바이트

1#.[=](+/ .*~]#:,@i.)1+<.@%

용법

   f =: 1#.[=](+/ .*~]#:,@i.)1+<.@%
   12 f 1 5 10
4
   26 f 1 5 10 25
13
   19 f 2 7 12
2
   13 f 2 8 25
0

설명

1#.[=](+/ .*~]#:,@i.)1+<.@%  Input: target T (LHS), denominations D (RHS)
                          %  Divide T by each in D
                       <.@   Floor each
                             These are the maximum number of each denomination
                     1+      Add 1 to each, call these B
                ,@i.         Forms the range 0 the the product of B
             ]               Get B
              #:             Convert each in the range to mixed radix B
     ]                       Get D
       +/ .*~                Dot product between D and each mixed radix number
                             These are all combinations of denominations up to T
   [                         Get T
    =                        Test if each sum is equal to T
1#.                          Convert as base 1 digits to decimal (takes the sum)
                             This is the number of times each sum was true

TSQL, 105 바이트

이 4 가지 코인 유형에서는 최대 1 달러까지만 처리 할 수 ​​있습니다. ungolfed 버전은 최대 4 달러까지 처리 할 수 ​​있지만 매우 느리게 처리됩니다. 제 상자에는 27 초가 걸립니다. 결과는 10045 조합입니다.

골프 :

DECLARE @ INT = 100
DECLARE @t table(z int)
INSERT @t values(1),(5),(10),(25)
;WITH c as(SELECT 0l,0s UNION ALL SELECT z,s+z FROM c,@t WHERE l<=z and s<@)SELECT SUM(1)FROM c WHERE s=@

언 골프 드 :

-- input variables
DECLARE @ INT = 100
DECLARE @t table(z int)
INSERT @t values(1),(5),(10),(25)

-- query
;WITH c as
(
  SELECT 0l,0s
  UNION ALL
  SELECT z,s+z
  FROM c,@t
  WHERE l<=z and s<@
)
SELECT SUM(1)
FROM c
WHERE s=@
-- to allow more than 100 recursions(amounts higher than 1 dollar in this example)
OPTION(MAXRECURSION 0)

깡깡이

tinylisp repl, 66 바이트

(d C(q((Q V)(i Q(i(l Q 0)0(i V(s(C(s Q(h V))V)(s 0(C Q(t V))))0))1

재귀 솔루션 : 첫 번째 코인을 사용하고 첫 번째 코인을 사용하지 않고 각각의 결과를 추가합니다. 지수 시간 복잡성과 꼬리 재귀는 없지만 테스트 사례를 잘 계산합니다.

ungolfed (내장 키 : d= 정의, q= 인용, i= if, l=보다 작음, s= 빼기, h= head, t= tail) :

(d combos
 (q
  ((amount coin-values)
   (i amount
    (i (l amount 0)
     0
     (i coin-values
      (s
       (combos
        (s amount (h coin-values))
        coin-values)
       (s
        0
        (combos
         amount
         (t coin-values))))
      0))
    1))))

사용법 예 :

tl> (d C(q((Q V)(i Q(i(l Q 0)0(i V(s(C(s Q(h V))V)(s 0(C Q(t V))))0))1
C
tl> (C 12 (q (1 5 10)))
4
tl> (C 26 (q (1 5 10 25)))
13
tl> (C 19 (q (2 7 12)))
2
tl> (C 13 (q (2 8 25)))
0
tl> (C 400 (q (1 5 10 25)))
Error: recursion depth exceeded. How could you forget to use tail calls?!

PHP, 130 바이트

function r($n,$a){if($c=$a[0])for(;0<$n;$n-=$c)$o+=r($n,array_slice($a,1));return$o?:$n==0;}echo r($argv[1],array_slice($argv,2));

대상에서 현재 코인의 값을 반복적으로 제거하고 새로운 값과 다른 코인으로 자신을 호출하는 99 바이트 재귀 함수 (및 호출하는 31 바이트). 대상이 정확히 0에 도달 한 횟수를 계산합니다. 다음과 같이 실행하십시오.

 php -r "function r($n,$a){if($c=$a[0])for(;0<$n;$n-=$c)$o+=r($n,array_slice($a,1));return$o?:$n==0;}echo r($argv[1],array_slice($argv,2));" 12 1 5 10

라켓 275 바이트

(set! l(flatten(for/list((i l))(for/list((j(floor(/ s i))))i))))(define oll'())(for((i(range 1(add1(floor(/ s(apply min l)))))))
(define ol(combinations l i))(for((j ol))(set! j(sort j >))(when(and(= s(apply + j))(not(ormap(λ(x)(equal? x j))oll)))(set! oll(cons j oll)))))oll

언 골프 드 :

(define(f s l)
  (set! l              ; have list contain all possible coins that can be used
        (flatten
         (for/list ((i l))
           (for/list ((j              
                       (floor
                        (/ s i))))
             i))))
  (define oll '())                    ; final list of all solutions initialized
  (for ((i (range 1  
                  (add1
                   (floor             ; for different sizes of coin-set
                    (/ s
                       (apply min l)))))))
    (define ol (combinations l i))          ; get a list of all combinations
    (for ((j ol))                           ; test each combination
      (set! j (sort j >))
      (when (and
             (= s (apply + j))              ; sum is correct
             (not(ormap                     ; solution is not already in list
                  (lambda(x)
                    (equal? x j))
                  oll)))
        (set! oll (cons j oll))             ; add found solution to final list
        )))
  (reverse oll))

테스트 :

(f 4 '[1 2])
(println "-------------")
(f 12 '[1 5 10])
(println "-------------")
(f 19 '[2 7 12])
(println "-------------")
(f 8 '(1 2 3))

산출:

'((2 2) (2 1 1) (1 1 1 1))
"-------------"
'((10 1 1) (5 5 1 1) (5 1 1 1 1 1 1 1) (1 1 1 1 1 1 1 1 1 1 1 1))
"-------------"
'((12 7) (7 2 2 2 2 2 2))
"-------------"
'((3 3 2) (2 2 2 2) (3 2 2 1) (3 3 1 1) (2 2 2 1 1) (3 2 1 1 1) (2 2 1 1 1 1) (3 1 1 1 1 1) (2 1 1 1 1 1 1) (1 1 1 1 1 1 1 1))

다음 재귀 솔루션에는 약간의 오류가 있습니다.

(define (f s l)                      ; s is sum needed; l is list of coin-types
  (set! l (sort l >))
  (define oll '())                   ; list of all solution lists
  (let loop ((l l)   
             (ol '()))               ; a solution list initialized
    (when (not (null? l))
        (set! ol (cons (first l) ol)))
    (define ols (apply + ol))        ; current sum in solution list
    (cond
      [(null? l) (remove-duplicates oll)]
      [(= ols s) (set! oll (cons ol oll))
                 (loop (rest l) '()) 
                 ]
      [(> ols s) (loop (rest l) (rest ol))
                 (loop (rest l) '())   
                 ]
      [(< ols s) (loop l ol) 
                 (loop (rest l) ol)
                 ])))

다음에 대해 제대로 작동하지 않습니다.

(f 8 '[1 2 3])

산출:

'((1 1 1 2 3) (1 2 2 3) (1 1 1 1 1 1 1 1) (2 3 3) (1 1 1 1 1 1 2) (1 1 1 1 2 2) (1 1 2 2 2) (2 2 2 2))

(1 1 3 3)은 가능하지만 솔루션 목록에 나오지 않습니다.

젤리 , 15 바이트

s+\Fṁḷ
2*BW;ç/Ṫ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

이것은 내장을 사용하지 않고 Jelly에서 효율적인 버전을 작성하는 데 더 많은 연습이었습니다. 이것은 변경하는 방법의 수를 계산하는 데 사용되는 일반적인 동적 프로그래밍 방식을 기반으로합니다.

설명

s+\Fṁḷ  Helper link. Input: solutions S, coin C
s       Slice the solutions into non-overlapping sublists of length C
 +\     Cumulative sum
   F    Flatten
     ḷ  Left, get S
    ṁ   Mold the sums to the shape of S

2*BW;ç/Ṫ  Main link. Input: target T, denominations D
2*        Compute 2^T
  B       Convert to binary, creates a list with 1 followed by T-1 0's
          These are the number of solutions for each value from 0 to T
          starting with no coins used
   W      Wrap it inside another array
    ;     Concatenate with D
     ç/   Reduce using the helper link
       Ṫ  Tail, return the last value which is the solution

실제로 15 바이트

골프 제안을 환영합니다. 온라인으로 사용해보십시오!

╗;R`╜∙♂S╔♂Σi`Mc

언 골핑

         Implicit input n, then the list of coins a.
╗        Save a to register 0.
;R       Duplicate n and create a range [1..n] from that duplicate.
`...`M   Map the following function over that range. Variable i.
  ╜        Push a from register 0.
  ∙        Push the i-th Cartesian power of a.
  ♂S       Sort each member of car_pow.
  ╔        Uniquify car_pow so we don't count too any duplicate coin arrangements.
  ♂Σ       Take the sum of each coin arrangement.
  i        Flatten the list.
c        Using the result of the map and the remaining n, push map.count(n).
         Implicit return.

파이썬, 120 바이트

from itertools import*
lambda t,L:[sum(map(lambda x,y:x*y,C,L))-t for C in product(range(t+1),repeat=len(L))].count(0)

Brute는 동전의 모든 조합을 목표 값까지 (최소가 1이 아닌 경우에도) 통과합니다.