... sayılır!

Programınıza dolar ve / veya sent cinsinden bir miktar parayı temsil eden bir değişken ve bir jeton değeri dizisini geçeceksiniz. Buradaki zorunluluk, koda geçirilen miktara ekleyebilecek verilen jeton değerleri dizisinin olası kombinasyonlarının sayısını çıkarmaktır. Eğer adlandırılan paralar ile mümkün değilse, programın geri dönmesi gerekir 0.

Amerikan nümismatik terminolojisi hakkında not:

• 1 kuruş para: kuruş
• 5 kuruş para: nikel
• 10 kuruş para: kuruş
• 25 kuruş para: çeyrek dolar (çeyrek dolar)

Örnek 1:

Program geçildi:

12, [1, 5, 10]

(12 kuruş)

Çıktı:

4

12 sent üretmek için adlandırılan paraları birleştirmenin 4 olası yolu vardır:

1. 12 kuruş
2. 1 nikel ve 7 pennies
3. 2 nikel ve 2 pennies
4. 1 kuruş ve 2 kuruş

Örnek 2:

Program geçildi:

26, [1, 5, 10, 25]

(26 sent)

Çıktı:

13

26 sent üretmek için adlandırılan paraları birleştirmenin 13 olası yolu vardır:

1. 26 kuruş
2. 21 kuruş ve 1 nikel
3. 16 kuruş ve 2 nikel
4. 11 kuruş ve 3 nikel
5. 6 kuruş ve 4 nikel
6. 1 kuruş ve 5 nikel
7. 16 kuruş ve 1 kuruş
8. 6 pennies ve 2 dimes
9. 11 kuruş, 1 kuruş ve 1 nikel
10. 6 kuruş, 1 kuruş ve 2 nikel
11. 1 kuruş, 1 kuruş ve 3 nikel
12. 1 kuruş, 2 dimes ve 1 nikel
13. 1 çeyrek ve 1 kuruş

Örnek 3:

Program geçildi:

19, [2, 7, 12]

Çıktı:

2

19 sent üretmek için adlandırılan sikkeleri birleştirmenin 2 olası yolu vardır:

1. 1 12 kuruş madeni para ve 1 7 kuruş madeni para
2. 1 7 kuruş para ve 6 2 kuruş para

Örnek 4:

Program geçildi:

13, [2, 8, 25]

Çıktı:

0

13 sent üretmek için adlandırılan sikkeleri birleştirmenin hiçbir yolu yoktur.

Bu Sandbox'tan geçti. Standart boşluklar uygulanır. Bu kod golf, yani en az bayt olan cevap kazanıyor.

Jöle ( çatal ), 2 bayt

æf

Bu , Frobenius'un çözdüğü atomları uygulamak için çalıştığım Jelly şubesine dayanıyor, bu yüzden ne yazık ki çevrimiçi deneyemezsiniz.

kullanım

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

açıklama

æ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 bayt

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

Kullanım örneği: 26 # [1,5,10,25]-> 13.

Basit özyinelemeli yaklaşım: Listedeki her iki sayıyı da deneyin (miktara eşit veya daha az olduğu sürece) ve atlayın. Sayının çıkarılması sıfır miktarına yol açarsa, bir 1başkasını al (veya liste öğeleri tükenirse) a 0. Bu Sum 1s ve 0s.

Düzenleme: @Damien: özyineleme için daha kısa bir temel durumu işaret ederek 3 bayt kaydetti (ayrıca @xnors yanıtında da bulunabilir ).

Mathematica, 35 22 bayt

FrobeniusSolve13 byte öneri ve tasarruf için kilometrelerce teşekkür ederiz .

Length@*FrobeniusSolve

Madeni para listesini ilk argüman ve hedef değeri ikinci olarak alan adsız bir işlevi değerlendirir. FrobeniusSolveformun Diophantine denklemlerini çözmek için bir steno

a1x1 + a2x2 + ... + anxn = b

için negatif olmayan tamsayılar üzerinde ve bize tüm çözümler sunar.xi

Pyth, 8 bayt

/sM{yS*E

Ham kaba kuvvet, gerçek test için yoğun bellek. Bu, O (2 ^mn ), ki burada n , sikke sayısıdır ve m , hedef toplamdır. Girişi olarak alır 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 bayt

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

İlk madalyonun bir hkaçının kullanılması, gerekli toplamı s, azalan ilerlemede negatif olmayan bir değere düşürür [s,s-h..0]ve daha sonra kalan paralarla yapılması gerekir. Madeni para kalmamışsa, toplamın aritmetik olarak sıfır olduğunu kontrol edin 0^s.

JavaScript (ES6), 51 48 bayt

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

Herhangi bir sırayla para kabul eder. İlk madalyonu kullanıp kullanmamayı dener, kombinasyon sayısını her iki şekilde de tekrarlayarak hesaplar. n==0bir eşleştirme birleşimi n<0anlamına c==undefinedgelir; Fonksiyonun çok yavaş olduğuna ve bir kuruş paraya sahipseniz, aşağıdaki fonksiyonun daha hızlı olduğuna dikkat edin (kuruş parasını bozuk para dizisinde geçirmeyin):

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

Perl, 45 bayt

Bayt sayısı, 44 baytlık kod ve -pbayrağını içerir.

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

İlk satırdaki jeton değerlerini ve ikinci satırdaki hedeflenen miktarı alır:

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

Kısa açıklamalar:

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

Jöle , 10 9 bayt

œċЀS€€Fċ

Çevrimiçi deneyin!

Nasıl?

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

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

Madeni paralar en yüksekten en düşüğe kadardır f(26,[100,25,10,5,1]). Bir kuruşunuz varsa, çıkarın ve bunun yerine daha hızlı bu sürümü kullanın:

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

Bu, @ nimi'ninkine benzeyen özyinelemeli bir formül kullanır. Aslında bunu birkaç gün önce, meydan okuma hala sanal alandayken yazdım; şuna benziyordu:

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

Varsayılan değerini olmanın tek fark c(o özgün sorun ayarlanmış bir değeri vardı) ve değişen 0içinde .reduceişlev 1(bu iki oldu trilyonlarca kat daha hızlı daha kısa bayt ve c=[100,25,10,5,1]).

İşte, kombinasyon sayısı yerine tüm kombinasyonları çıkaran değiştirilmiş bir versiyon:

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 Bayt

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

Dene

Aksiyom, 63 62 bayt

@JonathanAllan tarafından kaydedilen 1 bayt

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

Bu yaklaşım üretici işlevler kullanır. Muhtemelen bu kod boyutunu düşürmek için yardımcı olmadı. Axiom ile oynadığım ilk kez, kendi işlevimi tanımlayana kadar gittim.

Fonksiyon ilk defa çağrıldığında korkunç bir uyarı verir, ancak yine de doğru sonucu verir. Bundan sonra, liste boş olmadığı sürece her şey yolunda.

R, 81 76 63 bayt

13 baytlık golf sahası için @rturnbull'a teşekkürler!

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

Örnek ( c(...)değerlerin vektörlerini R'ye nasıl aktardığınızı not edin ):

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

Açıklama:

uistenen değer, vjeton değerlerinin vektörüdür.

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

Her muhtemel 0 ila k jeton kombinasyonu ile bir veri çerçevesi oluşturur (k, kime göre değişir), k, en düşük k değerinin, o madalyonun değerinin en azından u (elde edilecek değer) olduğu şekildedir.

Normalde bunu as.matrixbir matrise dönüştürmek için kullanırız , ancak bu birçok karakterdir. Bunun yerine, onu otomatik olarak zorlayan, ama daha az karakter alan transpozisyonun (!) Geçişini ele alıyoruz.

%*% vdaha sonra her satırın parasal değerini hesaplar. Son adım, bu değerlerin kaç tanesinin istenen değere eşit olduğunu saymaktır u.

Bunun hesaplama karmaşıklığı ve hafıza gereksinimlerinin korkunç olduğunu ama kod golfü olduğunu unutmayın.

J, 27 bayt

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

kullanım

   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

açıklama

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 bayt

Bu, bu 4 jeton tipinde yalnızca bir dolara kadar çıkabilir. Topraksız sürüm 4 dolara kadar çıkabiliyor, ancak çok yavaş - benim kutumda bu 27 saniye sürüyor. Sonuç 10045 btw birleşimidir

golfed:

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

Ungolfed:

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

Keman

tinylisp repl, 66 bayt

(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

Özyinelemeli çözüm: ilk parayı kullanmaya çalışır, ilk parayı kullanmaz, sonra her birinden sonuçları ekler. Üstel zaman karmaşıklığı ve kuyruk özyineleme yok, ancak test durumlarını gayet iyi hesaplıyor.

Ungolfed (yerleşiklerin anahtarı: d= define, q= quote, i= if, l= daha küçük, s= çıkarma, h= kafa, t= kuyruk):

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

Örnek kullanım:

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 bayt

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

Geçerli bayrağın değerini hedeften tekrar tekrar çıkaran ve kendisini yeni değer ve diğer madeni paralarla çağıran 99 bayt özyinelemeli işlev (ve onu çağırmanın 31 baytı). Hedefin tam olarak 0'a ulaştığı sayısı sayar. Gibi koş:

 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

Raket 275 bayt

(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

Ungolfed:

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

Test yapmak:

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

Çıktı:

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

Aşağıdaki özyinelemeli çözüm bazı hata var:

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

Şunlar için düzgün çalışmıyor:

(f 8 '[1 2 3])

Çıktı:

'((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) mümkündür ancak çözüm listesine girmez.

Jöle , 15 bayt

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

Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın.

Bu, daha fazla yerleşik yapmadan Jelly'de etkili bir sürüm yazma alıştırmasıydı. Bu, değişiklik yapmanın yollarının sayısını hesaplamak için kullanılan tipik dinamik programlama yaklaşımına dayanmaktadır.

açıklama

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

Aslında 15 bayt

Golf önerileri kabul edilir. Çevrimiçi deneyin!

╗;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 bayt

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)

Hedef değere kadar olan bütün madeni para kombinasyonlarını kullanarak bruteforces (en küçük 1 olmasa bile).