... contati!

Passerai al tuo programma una variabile che rappresenta una quantità di denaro in dollari e / o centesimi e una matrice di valori delle monete. La tua sfida è quella di produrre il numero di possibili combinazioni di un dato array di valori di moneta che si sommerebbero all'importo passato al codice. Se non è possibile con le monete nominate, il programma dovrebbe tornare 0.

Nota sulla terminologia numismatica americana:

• Moneta da 1 centesimo: penny
• Moneta da 5 centesimi: nichel
• Moneta da 10 centesimi: centesimo
• Moneta da 25 cent: quarto (quarto di dollaro)

Esempio 1:

Il programma è passato:

12, [1, 5, 10]

(12 centesimi)

Produzione:

4

Esistono 4 modi possibili per combinare le monete nominate per produrre 12 centesimi:

1. 12 penny
2. 1 nichel e 7 penny
3. 2 nichel e 2 penny
4. 1 centesimo e 2 centesimi

Esempio 2:

Il programma è passato:

26, [1, 5, 10, 25]

(26 centesimi)

Produzione:

13

Esistono 13 modi possibili per combinare le monete nominate per produrre 26 centesimi:

1. 26 penny
2. 21 penny e 1 nickel
3. 16 penny e 2 nichel
4. 11 penny e 3 nichel
5. 6 penny e 4 nichel
6. 1 penny e 5 nichel
7. 16 penny e 1 centesimo
8. 6 penny e 2 dimes
9. 11 penny, 1 centesimo e 1 nickel
10. 6 penny, 1 centesimo e 2 nichel
11. 1 penny, 1 centesimo e 3 nickel
12. 1 penny, 2 dimes e 1 nickel
13. 1 quarto e 1 penny

Esempio 3:

Il programma è passato:

19, [2, 7, 12]

Produzione:

2

Ci sono 2 modi possibili per combinare le monete nominate per produrre 19 centesimi:

1. 1 moneta da 12 centesimi e 1 moneta da 7 centesimi
2. 1 moneta da 7 centesimi e 6 monete da 2 centesimi

Esempio 4:

Il programma è passato:

13, [2, 8, 25]

Produzione:

0

Non ci sono modi possibili di combinare le monete nominate per produrre 13 centesimi.

Questo è stato attraverso il Sandbox. Si applicano scappatoie standard. Questo è il codice golf, quindi vince la risposta con il minor numero di byte.

Jelly ( fork ), 2 byte

æf

Questo si basa su un ramo di Jelly in cui stavo lavorando per implementare gli atomi di risoluzione di Frobenius, quindi sfortunatamente non puoi provarlo online.

uso

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

Spiegazione

æ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

Esempio di utilizzo: 26 # [1,5,10,25]-> 13.

Approccio ricorsivo semplice: prova sia il numero successivo nell'elenco (purché sia ​​inferiore o uguale all'importo) e saltalo. Se sottraendo il numero si ottiene un valore pari a zero, prendere un 1altro (o se l'elenco si esaurisce di elementi) prendere a 0. Somma quelle 1s e 0s.

Modifica: @Damien: salvato 3 byte indicando un caso base più corto per la ricorsione (che si trova anche nella risposta @xnors ).

Mathematica, 35 22 byte

Grazie a miglia per aver suggerito FrobeniusSolvee risparmiato 13 byte.

Length@*FrobeniusSolve

Valuta una funzione senza nome, che accetta l'elenco di monete come primo argomento e il valore target come secondo. FrobeniusSolveè una scorciatoia per risolvere le equazioni diofantantiche della forma

a1x1 + a2x2 + ... + anxn = b

per i numeri interi non negativi e ci offre tutte le soluzioni.xi

Pyth, 8 byte

/sM{yS*E

Forza bruta grezza, troppo memoria intensa per test reali. Questo è O (2 ^mn ), dove n è il numero di monete e m è la somma target. Accetta input come 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

L'uso di alcuni multipli della prima moneta hriduce la somma richiesta sa un valore non negativo nella progressione decrescente [s,s-h..0], che deve quindi essere effettuata con le monete rimanenti. Una volta che non sono rimaste monete, controlla che la somma sia zero aritmeticamente 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

Accetta monete in qualsiasi ordine. Cerca sia di usare che di non usare la prima moneta, calcolando ricorsivamente il numero di combinazioni in entrambi i modi. n==0indica una combinazione corrispondente, n<0significa che le monete superano la quantità mentre c==undefinedindica che non sono rimaste monete. Si noti che la funzione è molto lenta e se si dispone di una moneta da un penny, la seguente funzione è più veloce (non passare la moneta da un penny nell'array di monete):

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

Perl, 45 byte

Il conteggio dei byte include 44 byte di codice e -pflag.

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

Prende i valori delle monete sulla prima riga e l'importo target sulla seconda riga:

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

Brevi spiegazioni:

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

Gelatina , 10 9 byte

œċЀS€€Fċ

Provalo online!

Come?

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

Le monete vengono inserite dal più alto al più basso, ad es f(26,[100,25,10,5,1]). Se hai un penny, rimuovilo e usa invece questa versione molto più veloce:

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

Questo utilizza una formula ricorsiva molto simile a quella di @nimi. Inizialmente l'ho scritto qualche giorno fa quando la sfida era ancora nella sandbox; sembrava così:

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

Le uniche differenze sono il valore predefinito di c(aveva un valore impostato nella sfida originale) e la modifica 0della .reducefunzione in 1(questo era due byte più corto e un bazillion volte più veloce di c=[100,25,10,5,1]).

Ecco una versione modificata che genera tutte le combinazioni, anziché il numero di combinazioni:

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

Provalo

Assioma, 63 62 byte

1 byte salvato da @JonathanAllan

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

Questo approccio utilizza funzioni di generazione. Probabilmente ciò non ha aiutato a ridurre le dimensioni del codice. Penso che questa sia la prima volta che suonando con Axiom sono arrivato a definire la mia funzione.

La prima volta che viene chiamata la funzione, viene emesso un avviso orrendo, ma si ottiene comunque il risultato corretto. Dopodiché, tutto va bene finché l'elenco non è vuoto.

R, 81 76 63 byte

Grazie a @rturnbull per aver giocato a golf a 13 byte!

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

Esempio (nota che c(...)è come passare i vettori di valori a R):

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

Spiegazione:

uè il valore desiderato, vè il vettore dei valori delle monete.

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

crea un frame di dati con ogni possibile combinazione di monete da 0 a k (k dipende dalla denominazione), dove k è il più basso in modo tale che k volte il valore di quella moneta sia almeno u (il valore da raggiungere).

Normalmente usiamo as.matrixper trasformarlo in una matrice, ma sono molti personaggi. Invece prendiamo la trasposizione della trasposizione (!) Che la costringe automaticamente, ma richiede meno caratteri.

%*% vquindi calcola il valore monetario di ogni riga. L'ultimo passo è contare quanti di questi valori sono uguali al valore desiderato u.

Nota che la complessità computazionale e i requisiti di memoria di questo sono orribili ma ehi, è il golf del codice.

J, 27 byte

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

uso

   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

Spiegazione

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

Questo può gestire solo fino a un dollaro con questi 4 tipi di monete. La versione ungolfed può gestire fino a circa 4 dollari, ma molto lentamente - sulla mia scatola ci vogliono 27 secondi. Il risultato è 10045 combinazioni tra

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)

Violino

tinylisp sostitu , 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

Soluzione ricorsiva: prova a usare la prima moneta e non a usare la prima moneta, quindi aggiunge i risultati di ciascuna. Complessità temporale esponenziale e nessuna ricorsione della coda, ma calcola bene i casi di test.

Ungolfed (chiave per builtins: d= define, q= quote, i= if, l= less-than, s= subtract, 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))))

Esempio di utilizzo:

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

Funzione ricorsiva a 99 byte (e 31 byte della sua chiamata) che rimuove ripetutamente il valore della moneta corrente dal bersaglio e si chiama con il nuovo valore e le altre monete. Conta il numero di volte in cui l'obiettivo raggiunge esattamente 0. Esegui come:

 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

Racchetta 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

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:

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

Produzione:

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

La seguente soluzione ricorsiva presenta alcuni errori:

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

Non funziona correttamente per:

(f 8 '[1 2 3])

Produzione:

'((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) è possibile ma non compare nell'elenco delle soluzioni.

Gelatina , 15 byte

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

Provalo online! oppure Verifica tutti i casi di test.

Questo è stato più un esercizio per scrivere una versione efficiente in Jelly senza usare i builtin. Questo si basa sul tipico approccio di programmazione dinamica utilizzato per calcolare il numero di modi per apportare modifiche

Spiegazione

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

In realtà , 15 byte

Suggerimenti di golf benvenuti. Provalo online!

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

Forza bruta attraverso tutte le combinazioni di monete fino al valore target (anche se il più piccolo non è 1).