... contou!

Você passará ao seu programa uma variável que representa uma quantidade de dinheiro em dólares e / ou centavos e uma matriz de valores de moedas. Seu desafio é gerar o número de combinações possíveis da matriz especificada de valores de moedas que somariam a quantia passada para o código. Se não for possível com as moedas nomeadas, o programa deve retornar 0.

Nota sobre a terminologia numismática americana:

• Moeda de 1 centavo: centavo
• Moeda de 5 cêntimos: níquel
• Moeda de 10 cêntimos: moeda de dez centavos
• Moeda de 25 cêntimos: quarto de dólar

Exemplo 1:

Programa é passado:

12, [1, 5, 10]

(12 centavos)

Saída:

4

Existem 4 maneiras possíveis de combinar as moedas nomeadas para produzir 12 centavos:

1. 12 centavos
2. 1 níquel e 7 centavos
3. 2 níquel e 2 centavos
4. 1 centavo e 2 centavos

Exemplo 2:

Programa é passado:

26, [1, 5, 10, 25]

(26 centavos)

Saída:

13

Existem 13 maneiras possíveis de combinar as moedas nomeadas para produzir 26 centavos:

1. 26 centavos
2. 21 centavos e 1 níquel
3. 16 centavos e 2 níquel
4. 11 centavos e 3 níquel
5. 6 tostões e 4 níquel
6. 1 centavo e 5 níquel
7. 16 centavos e 1 centavo
8. 6 centavos e 2 centavos
9. 11 centavos, 1 centavo e 1 níquel
10. 6 centavos, 1 centavo e 2 níquel
11. 1 centavo, 1 centavo e 3 níquel
12. 1 centavo, 2 centavos e 1 níquel
13. 1 quarto e 1 centavo

Exemplo 3:

Programa é passado:

19, [2, 7, 12]

Saída:

2

Existem 2 maneiras possíveis de combinar as moedas nomeadas para produzir 19 centavos:

1. 1 moeda de 12 centavos e 1 moeda de 7 centavos
2. 1 moeda de 7 centavos e 6 moedas de 2 centavos

Exemplo 4:

Programa é passado:

13, [2, 8, 25]

Saída:

0

Não há maneiras possíveis de combinar as moedas nomeadas para produzir 13 centavos.

Isso já passou pela Sandbox. Aplicam-se brechas padrão. Isso é código de golfe, então a resposta com o menor número de bytes vence.

Geléia ( garfo ), 2 bytes

æf

Isso se baseia em um ramo do Jelly, onde eu estava trabalhando na implementação de átomos de solução Frobenius. Infelizmente, você não pode experimentá-lo 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

Explicação

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

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

Exemplo de uso: 26 # [1,5,10,25]-> 13.

Abordagem recursiva simples: tente o próximo número da lista (contanto que seja menor ou igual à quantidade) e pule-o. Se subtrair o número levar a um valor zero, use 1outro (ou se a lista ficar sem elementos) use a 0. Soma aqueles 1s e 0s.

Edit: @Damien: salvou 3 bytes apontando para um caso base mais curto para a recursão (que também pode ser encontrada na resposta @xnors ).

Mathematica, 35 22 bytes

Graças a milhas por sugerir FrobeniusSolvee salvar 13 bytes.

Length@*FrobeniusSolve

Avalia como uma função sem nome, que leva a lista de moedas como o primeiro argumento e o valor alvo como o segundo. FrobeniusSolveé uma abreviação para resolver equações diofantinas da forma

a1x1 + a2x2 + ... + anxn = b

para os números inteiros não negativos e fornece todas as soluções.xi

Pitão, 8 bytes

/sM{yS*E

Força bruta bruta, muita memória para testes reais. Este é O (2 ^mn ), onde n é o número de moedas e m é a soma alvo. Toma entrada como 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 bytes

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

O uso de alguns múltiplos da primeira moeda hdiminui a soma necessária spara um valor não negativo na progressão decrescente [s,s-h..0], que deve ser feita com as moedas restantes. Quando não sobrar moedas, verifique se a soma é zero aritmeticamente como 0^s.

JavaScript (ES6), 51 48 bytes

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

Aceita moedas em qualquer ordem. Tenta usar e não usar a primeira moeda, calculando recursivamente o número de combinações de qualquer maneira. n==0significa uma combinação correspondente, n<0significa que as moedas excedem a quantidade, enquanto c==undefinedsignifica que não restam moedas. Observe que a função é muito lenta e, se você tiver uma moeda de um centavo, a função a seguir será mais rápida (não passe a moeda de um centavo no conjunto de moedas):

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

Perl, 45 bytes

A contagem de bytes inclui 44 bytes de código e -psinalizador.

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

Toma os valores das moedas na primeira linha e o valor alvo na segunda linha:

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

Breves explicações:

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

Geléia , 10 9 bytes

œċЀS€€Fċ

Experimente online!

Quão?

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

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

As moedas são inseridas do mais alto para o mais baixo, por exemplo f(26,[100,25,10,5,1]). Se você tiver um centavo, remova-o e use esta versão muito mais rápida:

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

Isso usa uma fórmula recursiva muito parecida com a do @ nimi. Eu escrevi isso originalmente alguns dias atrás, quando o desafio ainda estava na caixa de areia; ficou assim:

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

As únicas diferenças eram o valor padrão de c(tinha um valor definido no desafio original) e a alteração 0da .reducefunção para 1(isso era dois bytes mais curto e um bazilhão de vezes mais rápido que c=[100,25,10,5,1]).

Aqui está uma versão modificada que gera todas as combinações, em vez do número de combinações:

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 bytes

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

Tente

Axioma, 63 62 bytes

1 byte salvo por @JonathanAllan

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

Essa abordagem usa funções de geração. Provavelmente isso não ajudou a diminuir o tamanho do código. Penso que esta é a primeira vez que, ao jogar com o Axiom, fui até definir minha própria função.

A primeira vez que a função é chamada, ela dá um aviso horrendo, mas ainda produz o resultado correto. Depois disso, tudo ficará bem, desde que a lista não esteja vazia.

R, 81 76 63 bytes

Graças a @rturnbull por jogar fora 13 bytes!

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

Exemplo (note que c(...)é assim que você passa vetores de valores para R):

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

Explicação:

ué o valor desejado, vé o vetor dos valores das moedas.

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

cria um quadro de dados com todas as combinações possíveis de 0 a k moedas (k depende da denominação), onde k é o menor, de modo que k vezes o valor dessa moeda seja pelo menos u (o valor a ser alcançado).

Normalmente, usamos isso as.matrixpara transformar isso em uma matriz, mas são muitos caracteres. Em vez disso, assumimos a transposição da transposição (!) Que a força automaticamente, mas leva menos caracteres.

%*% vdepois calcula o valor monetário de cada linha. O último passo é contar quantos desses valores são iguais ao valor desejado u.

Observe que a complexidade computacional e os requisitos de memória disso são horríveis, mas ei, é código de golfe.

J, 27 bytes

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

Explicação

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 bytes

Isso pode suportar até um dólar com esses 4 tipos de moedas. A versão não-gasta pode suportar até cerca de 4 dólares, mas muito lenta - na minha caixa, isso leva 27 segundos. O resultado é 10045 combinações entre

Golfe:

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

repl do tinylisp , 66 bytes

(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

Solução recursiva: tenta usar a primeira moeda e não a primeira, depois adiciona os resultados de cada uma. Complexidade de tempo exponencial e sem recursão de cauda, ​​mas calcula bem os casos de teste.

Ungolfed (chave para builtins: d= definir, q= citar, i= se, l= menor que, s= subtrair, h= cabeça, t= cauda):

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

Exemplo de uso:

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 bytes

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

Função recursiva de 99 bytes (e 31 bytes de chamá-lo) que remove repetidamente o valor da moeda atual do destino e se chama com o novo valor e as outras moedas. Conta o número de vezes que o alvo atinge 0 exatamente. Executar como:

 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

Raquete 275 bytes

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

Teste:

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

Saída:

'((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 seguinte solução recursiva apresenta algum erro:

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

Não funciona corretamente para:

(f 8 '[1 2 3])

Saída:

'((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) é possível, mas não aparece na lista de soluções.

Gelatina , 15 bytes

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

Experimente online! ou Verifique todos os casos de teste.

Este foi mais um exercício para escrever uma versão eficiente no Jelly sem usar os recursos internos. Isso se baseia na abordagem típica de programação dinâmica usada para calcular o número de maneiras de fazer alterações

Explicação

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

Na verdade , 15 bytes

Sugestões de golfe são bem-vindas. Experimente 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 bytes

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)

Força bruta através de todas as combinações de moedas até o valor alvo (mesmo que o menor não seja 1).