...dénombré!

Vous passerez à votre programme une variable qui représente une quantité d'argent en dollars et / ou cents et un tableau de valeurs de pièces. Votre défi est de produire le nombre de combinaisons possibles du tableau donné de valeurs de pièces qui correspondraient au montant transmis au code. Si ce n'est pas possible avec les pièces nommées, le programme devrait revenir 0.

Remarque sur la terminologie numismatique américaine:

• Pièce de 1 cent: penny
• Pièce de 5 cents: nickel
• Pièce de 10 cents: dix sous
• Pièce de 25 cents: quart (quart de dollar)

Exemple 1:

Le programme est réussi:

12, [1, 5, 10]

(12 cents)

Sortie:

4

Il existe 4 façons possibles de combiner les pièces nommées pour produire 12 cents:

1. 12 centimes
2. 1 nickel et 7 sous
3. 2 nickels et 2 penny
4. 1 centime et 2 centimes

Exemple 2:

Le programme est réussi:

26, [1, 5, 10, 25]

(26 cents)

Sortie:

13

Il y a 13 façons possibles de combiner les pièces nommées pour produire 26 cents:

1. 26 centimes
2. 21 centimes et 1 nickel
3. 16 centimes et 2 nickels
4. 11 centimes et 3 nickels
5. 6 centimes et 4 nickels
6. 1 penny et 5 nickels
7. 16 centimes et 1 centime
8. 6 centimes et 2 centimes
9. 11 centimes, 1 centime et 1 nickel
10. 6 centimes, 1 centime et 2 nickels
11. 1 centime, 1 centime et 3 nickels
12. 1 penny, 2 dimes et 1 nickel
13. 1 quart et 1 penny

Exemple 3:

Le programme est réussi:

19, [2, 7, 12]

Sortie:

2

Il existe 2 façons possibles de combiner les pièces nommées pour produire 19 cents:

1. 1 pièce de 12 cents et 1 pièce de 7 cents
2. 1 pièce de 7 cents et 6 pièces de 2 cents

Exemple 4:

Le programme est réussi:

13, [2, 8, 25]

Sortie:

0

Il n'y a aucun moyen de combiner les pièces nommées pour produire 13 cents.

Cela a été fait via le Sandbox. Des échappatoires standard s'appliquent. C'est le golf de code, donc la réponse avec le moins d'octets gagne.

Gelée ( fourchette ), 2 octets

æf

Cela repose sur une branche de Jelly où je travaillais sur la mise en œuvre des atomes de résolution de Frobenius, donc malheureusement vous ne pouvez pas l'essayer en ligne.

Usage

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

Explication

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

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

Exemple d'utilisation: 26 # [1,5,10,25]-> 13.

Approche récursive simple: essayez à la fois le nombre suivant dans la liste (tant qu'il est inférieur ou égal au montant) et sautez-le. Si la soustraction du nombre conduit à un montant de zéro, prenez un 1autre (ou si la liste manque d'éléments), prenez un 0. Additionnez ces 1s et 0s.

Edit: @Damien: économisé 3 octets en pointant vers un cas de base plus court pour la récursivité (qui peut également être trouvé dans la réponse @xnors ).

Mathematica, 35 22 octets

Merci aux miles d'avoir suggéré FrobeniusSolveet économisé 13 octets.

Length@*FrobeniusSolve

Évalue à une fonction sans nom, qui prend la liste de pièces comme premier argument et la valeur cible comme deuxième. FrobeniusSolveest un raccourci pour résoudre les équations diophantiennes de la forme

a1x1 + a2x2 + ... + anxn = b

pour les sur les entiers non négatifs et nous donne toutes les solutions.xi

Pyth, 8 octets

/sM{yS*E

Force brute brute, trop de mémoire pour les tests réels. C'est O (2 ^mn ), où n est le nombre de pièces et m est la somme cible. Prend l'entrée comme 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 octets

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

L'utilisation d'un multiple de la première pièce hdiminue la somme requise sà une valeur non négative dans la progression décroissante [s,s-h..0], qui doit ensuite être effectuée avec les pièces restantes. Une fois qu'il n'y a plus de pièces, vérifiez que la somme est nulle arithmétiquement comme 0^s.

JavaScript (ES6), 51 48 octets

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

Accepte les pièces dans n'importe quel ordre. Essaie d'utiliser et de ne pas utiliser la première pièce, calculant récursivement le nombre de combinaisons dans les deux sens. n==0signifie une combinaison correspondante, n<0signifie que les pièces dépassent la quantité tandis que c==undefinedsignifie qu'il n'y a plus de pièces. Notez que la fonction est très lente et si vous avez une pièce d'un centime, la fonction suivante est plus rapide (ne passez pas la pièce d'un centime dans le tableau des pièces):

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

Perl, 45 octets

Le nombre d'octets comprend 44 octets de code et d' -pindicateur.

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

Prend les valeurs des pièces sur la première ligne et le montant ciblé sur la deuxième ligne:

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

Explications courtes:

-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ée , 10 9 octets

œċЀS€€Fċ

Essayez-le en ligne!

Comment?

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

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

Les pièces sont entrées du plus haut au plus bas, par exemple f(26,[100,25,10,5,1]). Si vous avez un sou, supprimez-le et utilisez plutôt cette version beaucoup plus rapide:

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

Cela utilise une formule récursive semblable à celle de @ nimi. J'ai écrit ceci il y a quelques jours quand le défi était toujours dans le bac à sable; cela ressemblait à ceci:

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

Les seules différences étant la valeur par défaut de c(il y avait une valeur définie dans le défi d'origine) et la modification 0de la .reducefonction en 1(c'était deux octets plus court et un bazillion fois plus rapide que c=[100,25,10,5,1]).

Voici une version modifiée qui génère toutes les combinaisons, plutôt que le nombre de combinaisons:

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 octets

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

Essayez-le

Axiome, 63 62 octets

1 octet enregistré par @JonathanAllan

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

Cette approche utilise des fonctions de génération. Cela n'a probablement pas aidé à réduire la taille du code. Je pense que c'est la première fois que dans mon jeu avec Axiom je vais jusqu'à définir ma propre fonction.

La première fois que la fonction est appelée, elle donne un avertissement horrible, mais produit toujours le résultat correct. Après cela, tout va bien tant que la liste n'est pas vide.

R, 81 76 63 octets

Merci à @rturnbull d'avoir joué au golf 13 octets!

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

Exemple (notez que c(...)c'est ainsi que vous passez des vecteurs de valeurs à R):

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

Explication:

uest la valeur souhaitée, vest le vecteur des valeurs des pièces.

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

crée un bloc de données avec toutes les combinaisons possibles de 0 à k pièces (k dépend de la valeur nominale), où k est le plus bas de sorte que k fois la valeur de cette pièce soit au moins u (la valeur à atteindre).

Normalement, nous utiliserions as.matrixpour transformer cela en une matrice, mais cela fait beaucoup de caractères. Au lieu de cela, nous prenons la transposition de la transposition (!) Qui la contraint automatiquement, mais prend moins de caractères.

%*% vcalcule ensuite la valeur monétaire de chaque ligne. La dernière étape consiste à compter combien de ces valeurs sont égales à la valeur souhaitée u.

Notez que la complexité de calcul et les besoins en mémoire de ceci sont horribles mais bon, c'est du golf de code.

J, 27 octets

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

Usage

   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

Explication

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 octets

Cela ne peut gérer jusqu'à un dollar avec ces 4 types de pièces. La version non golfée peut gérer jusqu'à environ 4 dollars, mais très lentement - sur ma boîte, cela prend 27 secondes. Le résultat est 10045 combinaisons btw

Golfé:

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

Non golfé:

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

Violon

tinylisp repl , 66 octets

(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

Solution récursive: essaie d'utiliser la première pièce et non pas la première pièce, puis ajoute les résultats de chacune. Complexité temporelle exponentielle et aucune récursivité de queue, mais elle calcule très bien les cas de test.

Non golfé (clé des commandes intégrées: d= définir, q= citer, i= si, l= inférieur à, s= soustraire, h= tête, t= queue):

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

Exemple d'utilisation:

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 octets

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

Fonction récursive de 99 octets (et 31 octets de l'appeler) qui supprime à plusieurs reprises la valeur de la pièce actuelle de la cible et s'appelle avec la nouvelle valeur et les autres pièces. Compte le nombre de fois où la cible atteint 0 exactement. Courez comme:

 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

Raquette 275 octets

(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

Non golfé:

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

Essai:

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

Sortie:

'((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 solution récursive suivante a une erreur:

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

Ne fonctionne pas correctement pour:

(f 8 '[1 2 3])

Sortie:

'((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) est possible mais ne figure pas dans la liste des solutions.

Gelée , 15 octets

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

Essayez-le en ligne! ou Vérifiez tous les cas de test.

Il s'agissait plus d'un exercice d'écriture d'une version efficace dans Jelly sans utiliser de fonction intégrée. Ceci est basé sur l'approche de programmation dynamique typique utilisée pour calculer le nombre de façons d'apporter des changements

Explication

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

En fait , 15 octets

Suggestions de golf bienvenues. Essayez-le en ligne!

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

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 à travers toutes les combinaisons de pièces jusqu'à la valeur cible (même si la plus petite n'est pas 1).