... Đã tính!

Bạn sẽ chuyển cho chương trình của mình một biến đại diện cho một lượng tiền bằng đô la và / hoặc xu và một loạt các giá trị tiền xu. Thách thức của bạn là đưa ra số lượng kết hợp có thể có của mảng giá trị đồng xu đã cho sẽ cộng với số tiền được chuyển vào mã. Nếu không thể với các đồng tiền được đặt tên, chương trình sẽ quay trở lại 0.

Lưu ý về thuật ngữ số của người Mỹ:

• Đồng xu 1 xu: xu
• Đồng xu 5 xu: niken
• Đồng xu 10 xu: xu
• Đồng xu 25 xu: quý (quý đô la)

Ví dụ 1:

Chương trình được thông qua:

12, [1, 5, 10]

(12 xu)

Đầu ra:

4

Có 4 cách kết hợp các đồng tiền được đặt tên để tạo ra 12 xu:

1. 12 đồng xu
2. 1 niken và 7 đồng xu
3. 2 nick và 2 penny
4. 1 xu và 2 đồng xu

Ví dụ 2:

Chương trình được thông qua:

26, [1, 5, 10, 25]

(26 xu)

Đầu ra:

13

Có 13 cách kết hợp các đồng tiền được đặt tên để tạo ra 26 xu:

1. 26 đồng xu
2. 21 đồng xu và 1 niken
3. 16 đồng xu và 2 nick
4. 11 đồng xu và 3 nick
5. 6 đồng xu và 4 nick
6. 1 xu và 5 nick
7. 16 đồng xu và 1 xu
8. 6 đồng xu và 2 xu
9. 11 đồng xu, 1 xu và 1 niken
10. 6 đồng xu, 1 xu và 2 nick
11. 1 xu, 1 xu và 3 nick
12. 1 xu, 2 xu và 1 niken
13. 1 quý và 1 xu

Ví dụ 3:

Chương trình được thông qua:

19, [2, 7, 12]

Đầu ra:

2

Có 2 cách kết hợp các đồng tiền được đặt tên để tạo ra 19 xu:

1. 1 xu 12 xu và 1 xu 7 xu
2. 1 xu 7 xu và 6 xu 2 xu

Ví dụ 4:

Chương trình được thông qua:

13, [2, 8, 25]

Đầu ra:

0

Không có cách nào có thể kết hợp các đồng tiền được đặt tên để tạo ra 13 xu.

Điều này đã được thông qua Sandbox. Tiêu chuẩn áp dụng. Đây là mã golf, vì vậy câu trả lời có ít byte nhất sẽ thắng.

Jelly ( ngã ba ), 2 byte

æf

Điều này phụ thuộc vào một nhánh của Jelly nơi tôi đang thực hiện triển khai các nguyên tử giải Frobenius nên rất tiếc bạn không thể thử trực tuyến.

Sử dụng

$ ./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

Giải trình

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

Haskell, 37 34 byte

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

Ví dụ sử dụng: 26 # [1,5,10,25]-> 13.

Phương pháp đệ quy đơn giản: thử cả hai số tiếp theo trong danh sách (miễn là nó ít hơn hoặc bằng số tiền) và bỏ qua nó. Nếu trừ đi số dẫn đến một số không, hãy lấy một số 1khác (hoặc nếu danh sách hết các phần tử) lấy a 0. Tính tổng 1s và 0s.

Chỉnh sửa: @Damien: đã lưu 3 byte bằng cách chỉ vào trường hợp cơ sở ngắn hơn cho đệ quy (cũng có thể được tìm thấy trong câu trả lời @xnors ).

Toán học, 35 22 byte

Nhờ dặm cho gợi ý FrobeniusSolvevà tiết kiệm 13 byte.

Length@*FrobeniusSolve

Đánh giá một hàm không tên, lấy danh sách các đồng tiền làm đối số thứ nhất và giá trị đích làm giá trị thứ hai. FrobeniusSolvelà một tốc ký để giải các phương trình Diophantine của mẫu

a1x1 + a2x2 + ... + anxn = b

cho các số nguyên không âm và cung cấp cho chúng tôi tất cả các giải pháp.xi

Bình thường, 8 byte

/sM{yS*E

Lực lượng vũ phu, quá nhiều bộ nhớ cho thử nghiệm thực tế. Đây là O (2 ^mn ), trong đó n là số xu và m là tổng mục tiêu. Đưa đầu vào là 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

Haskell, 37 byte

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

Sử dụng một số bội số của đồng tiền đầu tiên hsẽ làm giảm tổng số cần thiết sthành giá trị không âm trong quá trình giảm dần [s,s-h..0], sau đó phải được thực hiện với các đồng tiền còn lại. Khi không còn tiền, hãy kiểm tra xem tổng có bằng không 0^s.

JavaScript (ES6), 51 48 byte

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

Chấp nhận tiền theo thứ tự bất kỳ. Thử cả sử dụng và không sử dụng đồng tiền đầu tiên, tính toán đệ quy số lượng kết hợp theo một trong hai cách. n==0có nghĩa là một sự kết hợp phù hợp, n<0có nghĩa là các đồng tiền vượt quá số lượng trong khi c==undefinedcó nghĩa là không còn tiền. Lưu ý rằng chức năng này rất chậm và nếu bạn có một đồng xu thì chức năng sau sẽ nhanh hơn (không chuyển đồng xu trong mảng tiền xu):

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

Perl, 45 byte

Số byte bao gồm 44 byte mã và -pcờ.

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

Lấy các giá trị đồng xu trên dòng đầu tiên và số tiền được nhắm mục tiêu trên dòng thứ hai:

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

Giải thích ngắn gọn:

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

Thạch , 10 9 byte

œċЀS€€Fċ

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

Làm sao?

œċЀ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

JavaScript (ES6), 59 byte

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

Tiền xu là đầu vào từ cao nhất đến thấp nhất, ví dụ f(26,[100,25,10,5,1]). Nếu bạn có một xu, hãy xóa nó và sử dụng phiên bản nhanh hơn nhiều này để thay thế:

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

Điều này sử dụng một công thức đệ quy giống như @ nimi's. Ban đầu tôi đã viết cái này vài ngày trước khi thử thách vẫn còn trong hộp cát; nó trông như thế này:

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

Sự khác biệt duy nhất là giá trị mặc định c(nó có giá trị thiết lập trong thử thách ban đầu), và thay đổi 0trong .reducechức năng để 1(điều này là hai byte ngắn hơn và một bazillion lần nhanh hơnc=[100,25,10,5,1] ).

Đây là phiên bản sửa đổi, đưa ra tất cả các kết hợp, thay vì số lượng kết hợp:

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 byte

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

Thử nó

Tiên đề, 63 62 byte

1 byte được lưu bởi @Jonathan ALLan

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

Cách tiếp cận này sử dụng các hàm tạo. Có lẽ điều đó đã không giúp giảm kích thước mã. Tôi nghĩ rằng đây là lần đầu tiên trong khi chơi với Axiom, tôi đã đi xa hơn khi xác định chức năng của chính mình.

Lần đầu tiên hàm được gọi, nó đưa ra một cảnh báo khủng khiếp, nhưng vẫn tạo ra kết quả chính xác. Sau đó, mọi thứ đều ổn miễn là danh sách không trống.

R, 81 76 63 byte

Cảm ơn @rturnbull đã chơi golf 13 byte!

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

Ví dụ (lưu ý đó c(...)là cách bạn truyền vectơ giá trị cho R):

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

Giải trình:

ulà giá trị mong muốn, vlà vectơ của các giá trị coin.

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

tạo một khung dữ liệu với mọi sự kết hợp có thể từ 0 đến k xu (k phụ thuộc vào mệnh giá), trong đó k là giá trị thấp nhất sao cho k lần giá trị của đồng tiền đó ít nhất là u (giá trị cần đạt được).

Thông thường chúng ta sẽ sử dụng as.matrix để biến điều đó thành một ma trận, nhưng đó là nhiều ký tự. Thay vào đó, chúng ta sử dụng chuyển vị của transpose (!) Tự động ép buộc nó, nhưng mất ít ký tự hơn.

%*% vsau đó tính giá trị tiền tệ của mỗi hàng. Bước cuối cùng là tính xem có bao nhiêu trong số các giá trị đó bằng với giá trị mong muốnu .

Lưu ý rằng độ phức tạp tính toán và yêu cầu bộ nhớ của điều này là khủng khiếp nhưng hey, đó là mã golf.

J, 27 byte

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

Sử dụng

   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

Giải trình

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 byte

Điều này chỉ có thể xử lý tối đa một đô la với 4 loại tiền này. Phiên bản không có bản quyền có thể xử lý lên đến khoảng 4 đô la, nhưng rất chậm - trên hộp của tôi, việc này mất 27 giây. Kết quả là 10045 kết hợp btw

Chơi gôn

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=@

Ung dung:

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

Vĩ cầm

tinylisp thay thế , 66 byte

(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

Giải pháp đệ quy: thử sử dụng đồng tiền đầu tiên và không sử dụng đồng tiền đầu tiên, sau đó thêm kết quả từ mỗi đồng tiền. Độ phức tạp thời gian theo cấp số nhân và không có đệ quy đuôi, nhưng nó tính toán các trường hợp thử nghiệm tốt.

Ungolfed (khóa để xây dựng: d= xác định, q= quote, i= if, l= less-than, s= trừ, 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))))

Ví dụ sử dụng:

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 byte

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

Hàm đệ quy 99 byte (và 31 byte gọi nó) liên tục loại bỏ giá trị của đồng tiền hiện tại khỏi mục tiêu và tự gọi nó bằng giá trị mới và các đồng tiền khác. Đếm số lần chính xác mục tiêu đạt 0. Chạy như sau:

 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

Vợt 275 byte

(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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

Sau giải pháp đệ quy có một số lỗi:

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

Không hoạt động đúng cho:

(f 8 '[1 2 3])

Đầu ra:

'((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) là có thể nhưng không có trong danh sách giải pháp.

Thạch , 15 byte

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

Hãy thử trực tuyến! hoặc là Xác minh tất cả các trường hợp thử nghiệm.

Đây là một bài tập viết một phiên bản hiệu quả trong Jelly mà không cần sử dụng nội dung. Điều này dựa trên phương pháp lập trình động điển hình được sử dụng để tính toán số cách thực hiện thay đổi

Giải trình

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

Thực ra , 15 byte

Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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

Ungolfing

         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.

Python, 120 byte

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)

Bruteforces thông qua tất cả các kết hợp tiền xu lên đến giá trị mục tiêu (ngay cả khi nhỏ nhất không phải là 1).