ドルの価値を与えられたときにコインのすべての組み合わせを見つける方法


114

数か月前に面接準備のために書いているコードを見つけました。

私のコメントによると、それはこの問題を解決しようとしていました:

セント単位のドルの値を指定して(たとえば、200 = 2ドル、1000 = 10ドル)、ドルの値を構成するコインのすべての組み合わせを見つけます。ペニー(1nie)、ニッケル(5¢)、ダイム(10¢)、およびクォーター(25¢)のみが許可されています。

たとえば、100が指定された場合、答えは次のようになります。

4 quarter(s) 0 dime(s) 0 nickel(s) 0 pennies  
3 quarter(s) 1 dime(s) 0 nickel(s) 15 pennies  
etc.

これは反復的かつ再帰的な方法で解決できると私は信じています。私の再帰的な解決策は非常にバグが多く、他の人がこの問題をどのように解決するのか疑問に思っていました。この問題の難しい部分は、それを可能な限り効率的にすることでした。


6
@akappa:ペニー= 1セント; ニッケル= 5セント; ダイム= 10セント; 四半期= 25セント:)
コーディングベア2009

@ジョンT:コードゴルフ?その言葉は聞いたことがありません!とにかく、私はSOのコミュニティがすべての問題を解決することができるので、いくつかの興味深い答えを見るために望んでいる
codingbear

また、家に帰ったら答えを投稿しようとします...まだ仕事中なので、SOに時間をかけすぎてはいけません。
コーディングベア2009

1
@ブリーコードゴルフとは、選択したプログラミング言語を使用して、可能な限り少ない文字数で問題を解決することを指します。このウェブサイトで実行されたいくつかは次のとおりです。stackoverflow.com
John T

回答:


54

私はずっと前にこれを調べました、そしてあなたはそれについて私の小さな記事を読むことができます。これがMathematicaソースです。

生成関数を使用することにより、問題に対する閉じた形式の一定時間の解を得ることができます。Graham、Knuth、およびPatashnikの具象数学はこの本であり、問​​題のかなり広範囲にわたる議論が含まれています。基本的に、n番目の係数がnドルを変更する方法の数である多項式を定義します。

記事の4〜5ページは、Mathematica(またはその他の便利なコンピューター代数システム)を使用して、3行のコードで数秒で10 ^ 10 ^ 6ドルの答えを計算する方法を示しています。

(これは十分に前のことで、75 MHzのペンティアムでは数秒です...)


16
良い答えが、マイナーなあら探し:(1)これは与えることをノートナンバー何らかの理由での質問はすべての方法の実際のセットを要求しながら、いくつかの方法を。もちろん、出力自体が超多項式で多くのエントリを持っているため、多項式時間でセットを見つける方法はありません(2)生成関数が「閉形式」であるかどうかは議論の余地があります(ハーバートウィルフの素晴らしい本Generatingfunctionologymathを参照)。 upenn.edu/~wilf/DownldGF.html)そして(1 +√5)^ nのような式を意味する場合、一定の時間ではなく、Ω(log n)の時間がかかります。
ShreevatsaR

動的プログラミングの穏やかな紹介。また、シーケンスの問題がある人には、generatingfunctionologyを読むことをお勧めします。
大佐パニック

Andrewに感謝します...この説明は私を大いに助けてくれました...以下のスカラ関数の投稿..誰かがそれを必要とする場合
jayaram S

1
「... 1、10、25、50、および100セント硬貨を使用しますか?」と質問するため、最初の質問は少し修正する必要があると思います。しかし、その後、書き込みはセットafbut のドメインとして定義しますa = {1,5,10,25,50,100}。セント硬貨のリストに5があるはずです。そうでなければ、書き込みは素晴らしかったです、ありがとう!
rbrtl 2016年

@rbrtlうわー、あなたは正しい、それに気づいてくれてありがとう!更新します…
andrewdotn 2016年

42

:これはウェイの数のみを示しています。

Scala関数:

def countChange(money: Int, coins: List[Int]): Int =
  if (money == 0) 1
  else if (coins.isEmpty || money < 0) 0
  else countChange(money - coins.head, coins) + countChange(money, coins.tail)

1
0を変更する1つの方法は本当にありますか?それを行う方法はないと思います。
ルーク

2
それは多項式解の数から生じますn1 * coins(0) + n2 * coins(1) + ... + nN * coins(N-1) = money。以下のためのそうmoney=0coins=List(1,2,5,10)の組み合わせのためのカウントが(n1, n2, n3, n4)1である、溶液があります(0, 0, 0, 0)
2016年

3
この実装がなぜ機能するのか、頭を抱えることはできません。誰かが背後にあるアルゴリズムを私に説明できますか?
エイドリアンLemaire

3
これは間違いなくコースラスカラコースのエクササイズ1の問題3に対する正確な答えです。
ジャスティンスタンダード

私があれば、と考えていmoney == 0ますがcoins.isEmpty、それはsol'nとしてカウントされないはずです。したがって、coins.isEmpty || money < 0条件が最初に確認された場合、アルゴはより良いサービスを提供できます。
juanchito 2017年

26

私は再帰的な解決策を支持します。あなたはいくつかの金種のリストを持っていますが、最小のものが残りの通貨額を均等に分割できる場合、これはうまくいくはずです。

基本的に、あなたは最大の金種から最小の金種に移動します。
再帰的に

  1. 現在の合計金額と、最大の額面(1つ以上残っている)があります。金種が1つだけ残っている場合、合計を入力する方法は1つだけです。k * cur denomination <= totalとなるように、現在のデノミのコピーを0〜k個使用できます。
  2. 0からkの場合、変更された合計と新しい最大の額面で関数を呼び出します。
  3. 0からkまでの結果を合計します。これが、現在の額面金額から合計金額を下に向ける方法の数です。この番号を返します。

これがあなたが述べた問題の私のpythonバージョンで、200セントです。1463通りの方法があります。このバージョンでは、すべての組み合わせと最終的なカウントの合計が出力されます。

#!/usr/bin/python

# find the number of ways to reach a total with the given number of combinations

cents = 200
denominations = [25, 10, 5, 1]
names = {25: "quarter(s)", 10: "dime(s)", 5 : "nickel(s)", 1 : "pennies"}

def count_combs(left, i, comb, add):
    if add: comb.append(add)
    if left == 0 or (i+1) == len(denominations):
        if (i+1) == len(denominations) and left > 0:
           if left % denominations[i]:
               return 0
           comb.append( (left/denominations[i], demoninations[i]) )
           i += 1
        while i < len(denominations):
            comb.append( (0, denominations[i]) )
            i += 1
        print(" ".join("%d %s" % (n,names[c]) for (n,c) in comb))
        return 1
    cur = denominations[i]
    return sum(count_combs(left-x*cur, i+1, comb[:], (x,cur)) for x in range(0, int(left/cur)+1))

count_combs(cents, 0, [], None)

実行していませんが、ロジックを実行することにより、それは理にかなっています:)
–codingbear

関数の最後の2行を「return sum(count_combs(...)for ...)」に置き換えることができます。これにより、リストがまったく具体化されなくなります。:)
ニックジョンソン

先端をありがとう。私は常にコードを引き締める方法に興味があります。
leif 2009

2
別の質問で説明したように、このコードは、リストに最後の値denominationsがない場合、誤った出力を提供し1ます。最少量のコードを最も内側のifブロックに追加して修正できます(他の質問への私の回答で説明しています)。
Blckknght 2015

12

Scala関数:

def countChange(money: Int, coins: List[Int]): Int = {

def loop(money: Int, lcoins: List[Int], count: Int): Int = {
  // if there are no more coins or if we run out of money ... return 0 
  if ( lcoins.isEmpty || money < 0) 0
  else{
    if (money == 0 ) count + 1   
/* if the recursive subtraction leads to 0 money left - a prefect division hence return count +1 */
    else
/* keep iterating ... sum over money and the rest of the coins and money - the first item and the full set of coins left*/
      loop(money, lcoins.tail,count) + loop(money - lcoins.head,lcoins, count)
  }
}

val x = loop(money, coins, 0)
Console println x
x
}

ありがとう!これは素晴らしいスタートです。しかし、「money」が0で始まると、これは失敗すると思います。
2014年

10

これは、すべての組み合わせを表示するように要求した問題を解決するための、まったく単純なC ++コードです。

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("usage: change amount-in-cents\n");
        return 1;
    }

    int total = atoi(argv[1]);

    printf("quarter\tdime\tnickle\tpenny\tto make %d\n", total);

    int combos = 0;

    for (int q = 0; q <= total / 25; q++)
    {
        int total_less_q = total - q * 25;
        for (int d = 0; d <= total_less_q / 10; d++)
        {
            int total_less_q_d = total_less_q - d * 10;
            for (int n = 0; n <= total_less_q_d / 5; n++)
            {
                int p = total_less_q_d - n * 5;
                printf("%d\t%d\t%d\t%d\n", q, d, n, p);
                combos++;
            }
        }
    }

    printf("%d combinations\n", combos);

    return 0;
}

しかし、私は組み合わせの数を計算するだけのサブ問題にかなり興味をそそられます。それには閉じた形の方程式があると思います。


9
確かに、これはC ++ではなくCです。
nikhil

1
@ジョージフィリップスは説明できますか?
2013年

かなり簡単だと思います。基本的には、アイデアは、反復するために、すべての(0,1,2を使用して.. MAX)四半期、その後、反復使用の四半期に基づいて、すべてのダイムを介して行われ、など。
ピーター・リー

4
このソリューションのマイナス面は次のとおりです。50セント、100セント、500セントのコインがある場合、6レベルのループを使用する必要があります...
Peter Lee

3
これはかなり悪いです。もしあなたが動的な宗派を持​​っていたり、別の宗派を追加したいなら、これはうまくいきません。
しんぞう

7

サブ問題は、典型的なダイナミックプログラミング問題です。

/* Q: Given some dollar value in cents (e.g. 200 = 2 dollars, 1000 = 10 dollars),
      find the number of combinations of coins that make up the dollar value.
      There are only penny, nickel, dime, and quarter.
      (quarter = 25 cents, dime = 10 cents, nickel = 5 cents, penny = 1 cent) */
/* A:
Reference: http://andrew.neitsch.ca/publications/m496pres1.nb.pdf
f(n, k): number of ways of making change for n cents, using only the first
         k+1 types of coins.

          +- 0,                        n < 0 || k < 0
f(n, k) = |- 1,                        n == 0
          +- f(n, k-1) + f(n-C[k], k), else
 */

#include <iostream>
#include <vector>
using namespace std;

int C[] = {1, 5, 10, 25};

// Recursive: very slow, O(2^n)
int f(int n, int k)
{
    if (n < 0 || k < 0)
        return 0;

    if (n == 0)
        return 1;

    return f(n, k-1) + f(n-C[k], k); 
}

// Non-recursive: fast, but still O(nk)
int f_NonRec(int n, int k)
{
    vector<vector<int> > table(n+1, vector<int>(k+1, 1));

    for (int i = 0; i <= n; ++i)
    {
        for (int j = 0; j <= k; ++j)
        {
            if (i < 0 || j < 0) // Impossible, for illustration purpose
            {
                table[i][j] = 0;
            }
            else if (i == 0 || j == 0) // Very Important
            {
                table[i][j] = 1;
            }
            else
            {
                // The recursion. Be careful with the vector boundary
                table[i][j] = table[i][j-1] + 
                    (i < C[j] ? 0 : table[i-C[j]][j]);
            }
        }
    }

    return table[n][k];
}

int main()
{
    cout << f(100, 3) << ", " << f_NonRec(100, 3) << endl;
    cout << f(200, 3) << ", " << f_NonRec(200, 3) << endl;
    cout << f(1000, 3) << ", " << f_NonRec(1000, 3) << endl;

    return 0;
}

動的ソリューションでは、kをCから1を引いた長さにする必要があります。少し混乱します。あなたはC.の実際の長さをサポートするためにそれを容易に変更することができます
IDAN

7

コードはこの問題を解決するためにJavaを使用しており、それも機能します...ループが多すぎるため、この方法は良い考えではないかもしれませんが、それは本当に簡単な方法です。

public class RepresentCents {

    public static int sum(int n) {

        int count = 0;
        for (int i = 0; i <= n / 25; i++) {
            for (int j = 0; j <= n / 10; j++) {
                for (int k = 0; k <= n / 5; k++) {
                    for (int l = 0; l <= n; l++) {
                        int v = i * 25 + j * 10 + k * 5 + l;
                        if (v == n) {
                            count++;
                        } else if (v > n) {
                            break;
                        }
                    }
                }
            }
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(sum(100));
    }
}

7

これは本当に古い質問ですが、私は他のすべてのものよりも小さく見えるJavaの再帰的解決策を思いついたので、ここに行きます-

 public static void printAll(int ind, int[] denom,int N,int[] vals){
    if(N==0){
        System.out.println(Arrays.toString(vals));
        return;
    }
    if(ind == (denom.length))return;             
    int currdenom = denom[ind];
    for(int i=0;i<=(N/currdenom);i++){
        vals[ind] = i;
        printAll(ind+1,denom,N-i*currdenom,vals);
    }
 }

改善点:

  public static void printAllCents(int ind, int[] denom,int N,int[] vals){
        if(N==0){
            if(ind < denom.length) {
                for(int i=ind;i<denom.length;i++)
                    vals[i] = 0;
            }
            System.out.println(Arrays.toString(vals));
            return;
        }
        if(ind == (denom.length)) {
            vals[ind-1] = 0;
            return;             
        }

        int currdenom = denom[ind];
        for(int i=0;i<=(N/currdenom);i++){ 
                vals[ind] = i;
                printAllCents(ind+1,denom,N-i*currdenom,vals);
        }
     }

6

セットJの値を使用してiセントを作成する組み合わせのセットをC(i、J)とします。

Cは次のように定義できます。

ここに画像の説明を入力してください

(first(J)はセットの要素を決定論的な方法で取り入れます)

それはかなり再帰的な関数であることがわかります...そしてメモ化を使用すればかなり効率的です;)


ええ、これ(ある意味で「動的プログラミング」)が最適なソリューションになるでしょう。
ShreevatsaR

あなたが正しい:セットとしてではなくリストとしてJを取る:first(J)が最初の要素をもたらし、J \ first(J)がリストの残りの部分を与える。
アカッパ2009

これはどんな形の数学ですか?
ムハンマドウメール

5

ユニークな組み合わせの問題を回避するためのセミハック-降順を強制:

$ denoms = [1,5,10,25]
def all_combs(sum、last) 
  合計== 0の場合は1を返します
  $ denoms.select {| d |を返す d&le sum && d&le last} .inject(0){| total、denom |
           total + all_combs(sum-denom、denom)}
終わり

これはメモされないため、実行速度は遅くなりますが、アイデアはわかります。


4
# short and sweet with O(n) table memory    

#include <iostream>
#include <vector>

int count( std::vector<int> s, int n )
{
  std::vector<int> table(n+1,0);

  table[0] = 1;
  for ( auto& k : s )
    for(int j=k; j<=n; ++j)
      table[j] += table[j-k];

  return table[n];
}

int main()
{
  std::cout <<  count({25, 10, 5, 1}, 100) << std::endl;
  return 0;
}

3

これはPythonでの私の答えです。再帰は使用しません。

def crossprod (list1, list2):
    output = 0
    for i in range(0,len(list1)):
        output += list1[i]*list2[i]

    return output

def breakit(target, coins):
    coinslimit = [(target / coins[i]) for i in range(0,len(coins))]
    count = 0
    temp = []
    for i in range(0,len(coins)):
        temp.append([j for j in range(0,coinslimit[i]+1)])


    r=[[]]
    for x in temp:
        t = []
        for y in x:
            for i in r:
                t.append(i+[y])
        r = t

    for targets in r:
        if crossprod(targets, coins) == target:
            print targets
            count +=1
    return count




if __name__ == "__main__":
    coins = [25,10,5,1]
    target = 78
    print breakit(target, coins)

出力例

    ...
    1 ( 10 cents)  2 ( 5 cents)  58 ( 1 cents)  
    4 ( 5 cents)  58 ( 1 cents)  
    1 ( 10 cents)  1 ( 5 cents)  63 ( 1 cents)  
    3 ( 5 cents)  63 ( 1 cents)  
    1 ( 10 cents)  68 ( 1 cents)  
    2 ( 5 cents)  68 ( 1 cents)  
    1 ( 5 cents)  73 ( 1 cents)  
    78 ( 1 cents)  
    Number of solutions =  121

3
var countChange = function (money,coins) {
  function countChangeSub(money,coins,n) {
    if(money==0) return 1;
    if(money<0 || coins.length ==n) return 0;
    return countChangeSub(money-coins[n],coins,n) + countChangeSub(money,coins,n+1);
  }
  return countChangeSub(money,coins,0);
}

2

両方:高から低まですべての金種を反復処理し、金種の1つを取り、要求された合計から減算し、残りを再帰します(使用可能な金種を現在の反復値以下に制限します)。


2

通貨システムで許可されている場合は、最高額の通貨から始めて、各コインをできるだけ多く取得する単純な貪欲アルゴリズム

それ以外の場合、この問題は本質的にナップザック問題であるため、最適なソリューションをすばやく見つけるには動的プログラミングが必要です。

たとえば、通貨システムにコインがある場合:{13, 8, 1}貪欲な解は24をとして変更し{13, 8, 1, 1, 1}ますが、真の最適解は{8, 8, 8}

編集:私たちは、1ドルの変更を行うためのすべての方法をリストするのではなく、最適に変更を行っていると思いました。最近のインタビューで変更方法を尋ねたので、質問を読み終える前に前に飛びました。


問題は必ずしも1ドルではなく、2ドルまたは23ドルである可能性があるため、ソリューションが唯一の正しいものです。
ニールG

2

これは非常に古い質問であることを知っています。私は正しい答えを探していましたが、単純で満足できるものは何も見つかりませんでした。しばらく時間を取ったが、何かを書き留めることができた。

function denomination(coins, original_amount){
    var original_amount = original_amount;
    var original_best = [ ];

    for(var i=0;i<coins.length; i++){
      var amount = original_amount;
      var best = [ ];
      var tempBest = [ ]
      while(coins[i]<=amount){
        amount = amount - coins[i];
        best.push(coins[i]);
      }
      if(amount>0 && coins.length>1){
        tempBest = denomination(coins.slice(0,i).concat(coins.slice(i+1,coins.length)), amount);
        //best = best.concat(denomination(coins.splice(i,1), amount));
      }
      if(tempBest.length!=0 || (best.length!=0 && amount==0)){
        best = best.concat(tempBest);
        if(original_best.length==0 ){
          original_best = best
        }else if(original_best.length > best.length ){
          original_best = best;
        }  
      }
    }
    return original_best;  
  }
  denomination( [1,10,3,9] , 19 );

これはJavaScriptソリューションであり、再帰を使用します。


このソリューションでは、1つの金種しか見つかりません。問題は、「すべての」宗派を見つけることでした。
heinob

2

Scalaプログラミング言語では、次のようにします。

 def countChange(money: Int, coins: List[Int]): Int = {

       money match {
           case 0 => 1
           case x if x < 0 => 0
           case x if x >= 1 && coins.isEmpty => 0
           case _ => countChange(money, coins.tail) + countChange(money - coins.head, coins)

       }

  }

2

これは、手形を取り、合計に達するまで小さい方の手形を再帰的に取り、次に同じ金種の別の手形を取り、再び再帰する単純な再帰アルゴリズムです。例については、以下の出力例を参照してください。

var bills = new int[] { 100, 50, 20, 10, 5, 1 };

void PrintAllWaysToMakeChange(int sumSoFar, int minBill, string changeSoFar)
{
    for (int i = minBill; i < bills.Length; i++)
    {
        var change = changeSoFar;
        var sum = sumSoFar;

        while (sum > 0)
        {
            if (!string.IsNullOrEmpty(change)) change += " + ";
            change += bills[i];

            sum -= bills[i]; 
            if (sum > 0)
            {
                PrintAllWaysToMakeChange(sum, i + 1, change);
            }
        }

        if (sum == 0)
        {
            Console.WriteLine(change);
        }
    }
}

PrintAllWaysToMakeChange(15, 0, "");

以下を印刷します。

10 + 5
10 + 1 + 1 + 1 + 1 + 1
5 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
5 + 5 + 1 + 1 + 1 + 1 + 1
5 + 5 + 5
1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

1

ええと、私は今ばかを感じています。以下は、非常に複雑なソリューションですが、結局のところ、それソリューションであるため、保存しておきます。簡単な解決策はこれです:

// Generate a pretty string
val coinNames = List(("quarter", "quarters"), 
                     ("dime", "dimes"), 
                     ("nickel", "nickels"), 
                     ("penny", "pennies"))
def coinsString = 
  Function.tupled((quarters: Int, dimes: Int, nickels:Int, pennies: Int) => (
    List(quarters, dimes, nickels, pennies) 
    zip coinNames // join with names
    map (t => (if (t._1 != 1) (t._1, t._2._2) else (t._1, t._2._1))) // correct for number
    map (t => t._1 + " " + t._2) // qty name
    mkString " "
  ))

def allCombinations(amount: Int) = 
 (for{quarters <- 0 to (amount / 25)
      dimes <- 0 to ((amount - 25*quarters) / 10)
      nickels <- 0 to ((amount - 25*quarters - 10*dimes) / 5)
  } yield (quarters, dimes, nickels, amount - 25*quarters - 10*dimes - 5*nickels)
 ) map coinsString mkString "\n"

ここに他の解決策があります。このソリューションは、各コインが他のコインの倍数であるという観察に基づいているため、それらはそれらの観点から表すことができます。

// Just to make things a bit more readable, as these routines will access
// arrays a lot
val coinValues = List(25, 10, 5, 1)
val coinNames = List(("quarter", "quarters"), 
                     ("dime", "dimes"), 
                     ("nickel", "nickels"), 
                     ("penny", "pennies"))
val List(quarter, dime, nickel, penny) = coinValues.indices.toList


// Find the combination that uses the least amount of coins
def leastCoins(amount: Int): Array[Int] =
  ((List(amount) /: coinValues) {(list, coinValue) =>
    val currentAmount = list.head
    val numberOfCoins = currentAmount / coinValue
    val remainingAmount = currentAmount % coinValue
    remainingAmount :: numberOfCoins :: list.tail
  }).tail.reverse.toArray

// Helper function. Adjust a certain amount of coins by
// adding or subtracting coins of each type; this could
// be made to receive a list of adjustments, but for so
// few types of coins, it's not worth it.
def adjust(base: Array[Int], 
           quarters: Int, 
           dimes: Int, 
           nickels: Int, 
           pennies: Int): Array[Int] =
  Array(base(quarter) + quarters, 
        base(dime) + dimes, 
        base(nickel) + nickels, 
        base(penny) + pennies)

// We decrease the amount of quarters by one this way
def decreaseQuarter(base: Array[Int]): Array[Int] =
  adjust(base, -1, +2, +1, 0)

// Dimes are decreased this way
def decreaseDime(base: Array[Int]): Array[Int] =
  adjust(base, 0, -1, +2, 0)

// And here is how we decrease Nickels
def decreaseNickel(base: Array[Int]): Array[Int] =
  adjust(base, 0, 0, -1, +5)

// This will help us find the proper decrease function
val decrease = Map(quarter -> decreaseQuarter _,
                   dime -> decreaseDime _,
                   nickel -> decreaseNickel _)

// Given a base amount of coins of each type, and the type of coin,
// we'll produce a list of coin amounts for each quantity of that particular
// coin type, up to the "base" amount
def coinSpan(base: Array[Int], whichCoin: Int) = 
  (List(base) /: (0 until base(whichCoin)).toList) { (list, _) =>
    decrease(whichCoin)(list.head) :: list
  }

// Generate a pretty string
def coinsString(base: Array[Int]) = (
  base 
  zip coinNames // join with names
  map (t => (if (t._1 != 1) (t._1, t._2._2) else (t._1, t._2._1))) // correct for number
  map (t => t._1 + " " + t._2)
  mkString " "
)

// So, get a base amount, compute a list for all quarters variations of that base,
// then, for each combination, compute all variations of dimes, and then repeat
// for all variations of nickels.
def allCombinations(amount: Int) = {
  val base = leastCoins(amount)
  val allQuarters = coinSpan(base, quarter)
  val allDimes = allQuarters flatMap (base => coinSpan(base, dime))
  val allNickels = allDimes flatMap (base => coinSpan(base, nickel))
  allNickels map coinsString mkString "\n"
}

したがって、たとえば37枚のコインの場合:

scala> println(allCombinations(37))
0 quarter 0 dimes 0 nickels 37 pennies
0 quarter 0 dimes 1 nickel 32 pennies
0 quarter 0 dimes 2 nickels 27 pennies
0 quarter 0 dimes 3 nickels 22 pennies
0 quarter 0 dimes 4 nickels 17 pennies
0 quarter 0 dimes 5 nickels 12 pennies
0 quarter 0 dimes 6 nickels 7 pennies
0 quarter 0 dimes 7 nickels 2 pennies
0 quarter 1 dime 0 nickels 27 pennies
0 quarter 1 dime 1 nickel 22 pennies
0 quarter 1 dime 2 nickels 17 pennies
0 quarter 1 dime 3 nickels 12 pennies
0 quarter 1 dime 4 nickels 7 pennies
0 quarter 1 dime 5 nickels 2 pennies
0 quarter 2 dimes 0 nickels 17 pennies
0 quarter 2 dimes 1 nickel 12 pennies
0 quarter 2 dimes 2 nickels 7 pennies
0 quarter 2 dimes 3 nickels 2 pennies
0 quarter 3 dimes 0 nickels 7 pennies
0 quarter 3 dimes 1 nickel 2 pennies
1 quarter 0 dimes 0 nickels 12 pennies
1 quarter 0 dimes 1 nickel 7 pennies
1 quarter 0 dimes 2 nickels 2 pennies
1 quarter 1 dime 0 nickels 2 pennies

1

私のこのブログエントリはXKCDコミックのフィギュアのこのナップザックのような問題を解決します。items辞書とexactcost値を変更するだけで、問題のすべての解決策が得られます。

問題が最小コストを使用した変更を見つけることであった場合、最高値のコインを使用した単純な貪欲アルゴリズムは、コインとターゲット金額の一部の組み合わせで失敗する可能性があります。たとえば、値が1、3、4のコインがある場合、目標金額が6の場合、貪欲アルゴリズムは、値3のコイン2つを使用できることが簡単にわかる場合、値4、1、1の3つのコインを提案します。

  • 水田。

1
public class Coins {

static int ac = 421;
static int bc = 311;
static int cc = 11;

static int target = 4000;

public static void main(String[] args) {


    method2();
}

  public static void method2(){
    //running time n^2

    int da = target/ac;
    int db = target/bc;     

    for(int i=0;i<=da;i++){         
        for(int j=0;j<=db;j++){             
            int rem = target-(i*ac+j*bc);               
            if(rem < 0){                    
                break;                  
            }else{                  
                if(rem%cc==0){                  
                    System.out.format("\n%d, %d, %d ---- %d + %d + %d = %d \n", i, j, rem/cc, i*ac, j*bc, (rem/cc)*cc, target);                     
                }                   
            }                   
        }           
    }       
}
 }

1

O'reilyの著書「Python For Data Analysis」でこのコードを見つけました。それは遅延実装とint比較を使用し、小数を使用して他の宗派に変更できると思います。それがどのように機能するか教えてください!

def make_change(amount, coins=[1, 5, 10, 25], hand=None):
 hand = [] if hand is None else hand
 if amount == 0:
 yield hand
 for coin in coins:
 # ensures we don't give too much change, and combinations are unique
 if coin > amount or (len(hand) > 0 and hand[-1] < coin):
 continue
 for result in make_change(amount - coin, coins=coins,
 hand=hand + [coin]):
 yield result


1

これはジハンの答えの改善です。額面金額が1セントの場合、不要なループが大量に発生します。

それは直感的で非再帰的です。

    public static int Ways2PayNCents(int n)
    {
        int numberOfWays=0;
        int cent, nickel, dime, quarter;
        for (quarter = 0; quarter <= n/25; quarter++)
        {
            for (dime = 0; dime <= n/10; dime++)
            {
                for (nickel = 0; nickel <= n/5; nickel++)
                {
                    cent = n - (quarter * 25 + dime * 10 + nickel * 5);
                    if (cent >= 0)
                    {
                        numberOfWays += 1;
                        Console.WriteLine("{0},{1},{2},{3}", quarter, dime, nickel, cent);
                    }                   
                }
            }
        }
        return numberOfWays;            
    }

uはこのソリューションを一般化できないため、たとえば、その場合は新しい要素が表示され、別のforループを追加する必要があります
Sumit Kumar Saha

1

簡単なJavaソリューション:

public static void main(String[] args) 
{    
    int[] denoms = {4,2,3,1};
    int[] vals = new int[denoms.length];
    int target = 6;
    printCombinations(0, denoms, target, vals);
}


public static void printCombinations(int index, int[] denom,int target, int[] vals)
{
  if(target==0)
  {
    System.out.println(Arrays.toString(vals));
    return;
  }
  if(index == denom.length) return;   
  int currDenom = denom[index];
  for(int i = 0; i*currDenom <= target;i++)
  {
    vals[index] = i;
    printCombinations(index+1, denom, target - i*currDenom, vals);
    vals[index] = 0;
  }
}

1
/*
* make a list of all distinct sets of coins of from the set of coins to
* sum up to the given target amount.
* Here the input set of coins is assumed yo be {1, 2, 4}, this set MUST
* have the coins sorted in ascending order.
* Outline of the algorithm:
* 
* Keep track of what the current coin is, say ccn; current number of coins
* in the partial solution, say k; current sum, say sum, obtained by adding
* ccn; sum sofar, say accsum:
*  1) Use ccn as long as it can be added without exceeding the target
*     a) if current sum equals target, add cc to solution coin set, increase
*     coin coin in the solution by 1, and print it and return
*     b) if current sum exceeds target, ccn can't be in the solution, so
*        return
*     c) if neither of the above, add current coin to partial solution,
*        increase k by 1 (number of coins in partial solution), and recuse
*  2) When current denomination can no longer be used, start using the
*     next higher denomination coins, just like in (1)
*  3) When all denominations have been used, we are done
*/

#include <iostream>
#include <cstdlib>

using namespace std;

// int num_calls = 0;
// int num_ways = 0;

void print(const int coins[], int n);

void combine_coins(
                   const int denoms[], // coins sorted in ascending order
                   int n,              // number of denominations
                   int target,         // target sum
                   int accsum,         // accumulated sum
                   int coins[],        // solution set, MUST equal
                                       // target / lowest denom coin
                   int k               // number of coins in coins[]
                  )
{

    int  ccn;   // current coin
    int  sum;   // current sum

    // ++num_calls;

    for (int i = 0; i < n; ++i) {
        /*
         * skip coins of lesser denomination: This is to be efficient
         * and also avoid generating duplicate sequences. What we need
         * is combinations and without this check we will generate
         * permutations.
         */
        if (k > 0 && denoms[i] < coins[k - 1])
            continue;   // skip coins of lesser denomination

        ccn = denoms[i];

        if ((sum = accsum + ccn) > target)
            return;     // no point trying higher denominations now


        if (sum == target) {
            // found yet another solution
            coins[k] = ccn;
            print(coins, k + 1);
            // ++num_ways;
            return;
        }

        coins[k] = ccn;
        combine_coins(denoms, n, target, sum, coins, k + 1);
    }
}

void print(const int coins[], int n)
{
    int s = 0;
    for (int i = 0; i < n; ++i) {
        cout << coins[i] << " ";
        s += coins[i];
    }
    cout << "\t = \t" << s << "\n";

}

int main(int argc, const char *argv[])
{

    int denoms[] = {1, 2, 4};
    int dsize = sizeof(denoms) / sizeof(denoms[0]);
    int target;

    if (argv[1])
        target = atoi(argv[1]);
    else
        target = 8;

    int *coins = new int[target];


    combine_coins(denoms, dsize, target, 0, coins, 0);

    // cout << "num calls = " << num_calls << ", num ways = " << num_ways << "\n";

    return 0;
}

1

C#関数は次のとおりです。

    public static void change(int money, List<int> coins, List<int> combination)
    {
        if(money < 0 || coins.Count == 0) return;
        if (money == 0)
        {
            Console.WriteLine((String.Join("; ", combination)));
            return;
        }

        List<int> copy = new List<int>(coins);
        copy.RemoveAt(0);
        change(money, copy, combination);

        combination = new List<int>(combination) { coins[0] };
        change(money - coins[0], coins, new List<int>(combination));
    }

次のように使用します。

change(100, new List<int>() {5, 10, 25}, new List<int>());

それは印刷します:

25; 25; 25; 25
10; 10; 10; 10; 10; 25; 25
10; 10; 10; 10; 10; 10; 10; 10; 10; 10
5; 10; 10; 25; 25; 25
5; 10; 10; 10; 10; 10; 10; 10; 25
5; 5; 10; 10; 10; 10; 25; 25
5; 5; 10; 10; 10; 10; 10; 10; 10; 10; 10
5; 5; 5; 10; 25; 25; 25
5; 5; 5; 10; 10; 10; 10; 10; 10; 25
5; 5; 5; 5; 10; 10; 10; 25; 25
5; 5; 5; 5; 10; 10; 10; 10; 10; 10; 10; 10
5; 5; 5; 5; 5; 25; 25; 25
5; 5; 5; 5; 5; 10; 10; 10; 10; 10; 25
5; 5; 5; 5; 5; 5; 10; 10; 25; 25
5; 5; 5; 5; 5; 5; 10; 10; 10; 10; 10; 10; 10
5; 5; 5; 5; 5; 5; 5; 10; 10; 10; 10; 25
5; 5; 5; 5; 5; 5; 5; 5; 10; 25; 25
5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 10; 10; 10; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 10; 25
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 25; 25
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 10; 10; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 25
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 10; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 25
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 25
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 10
5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5; 5

出力はかなり
ありがとう

1

以下は、お金のすべての組み合わせを見つけるためのpythonプログラムです。これは、order(n)時間の動的プログラミングソリューションです。お金は1,5,10,25

行マネー1から行マネー25(4行)までトラバースします。行money 1には、組み合わせの数を計算する際にmoney 1のみを考慮した場合のカウントが含まれます。行マネー5は、同じ最終通貨の行マネーrのカウントと、その行の前の5カウント(現在の位置から5を引いたもの)を足して、各列を生成します。ローマネー10は、ローマネー5を使用します。これには、1,5の両方のカウントが含まれ、前の10カウント(現在の位置から10を引いたもの)が追加されます。ローマネー25はローマネー10を使用します。これには、ローマネー1、5、10のカウントと前の25カウントが含まれます。

たとえば、numbers [1] [12] = numbers [0] [12] + numbers [1] [7](7 = 12-5)の場合、3 = 1 + 2となります。数値[3] [12] =数値[2] [12] +数値[3] [9](-13 = 12-25)。-13は0より小さいため、4 = 0 + 4になります。

def cntMoney(num):
    mSz = len(money)
    numbers = [[0]*(1+num) for _ in range(mSz)]
    for mI in range(mSz): numbers[mI][0] = 1
    for mI,m in enumerate(money):
        for i in range(1,num+1):
            numbers[mI][i] = numbers[mI][i-m] if i >= m else 0
            if mI != 0: numbers[mI][i] += numbers[mI-1][i]
        print('m,numbers',m,numbers[mI])
    return numbers[mSz-1][num]

money = [1,5,10,25]
    num = 12
    print('money,combinations',num,cntMoney(num))

output:    
('m,numbers', 1, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
('m,numbers', 5, [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3])
('m,numbers', 10, [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 4, 4, 4])
('m,numbers', 25, [1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 4, 4, 4])
('money,combinations', 12, 4)

0

Javaソリューション

import java.util.Arrays;
import java.util.Scanner;


public class nCents {



public static void main(String[] args) {

    Scanner input=new Scanner(System.in);
    int cents=input.nextInt();
    int num_ways [][] =new int [5][cents+1];

    //putting in zeroes to offset
    int getCents[]={0 , 0 , 5 , 10 , 25};
    Arrays.fill(num_ways[0], 0);
    Arrays.fill(num_ways[1], 1);

    int current_cent=0;
    for(int i=2;i<num_ways.length;i++){

        current_cent=getCents[i];

        for(int j=1;j<num_ways[0].length;j++){
            if(j-current_cent>=0){
                if(j-current_cent==0){
                    num_ways[i][j]=num_ways[i-1][j]+1;
                }else{
                    num_ways[i][j]=num_ways[i][j-current_cent]+num_ways[i-1][j];
                }
            }else{
                num_ways[i][j]=num_ways[i-1][j];
            }


        }


    }



    System.out.println(num_ways[num_ways.length-1][num_ways[0].length-1]);

}

}


0

さまざまな組み合わせも出力する以下のJavaソリューション。わかりやすい。アイデアは

合計5

解決策は

    5 - 5(i) times 1 = 0
        if(sum = 0)
           print i times 1
    5 - 4(i) times 1 = 1
    5 - 3 times 1 = 2
        2 -  1(j) times 2 = 0
           if(sum = 0)
              print i times 1 and j times 2
    and so on......

各ループの残りの合計が額面より少ない場合、つまり残りの合計1が2未満の場合は、ループを中断します。

以下の完全なコード

間違いがあったら訂正してください

public class CoinCombinbationSimple {
public static void main(String[] args) {
    int sum = 100000;
    printCombination(sum);
}

static void printCombination(int sum) {
    for (int i = sum; i >= 0; i--) {
        int sumCopy1 = sum - i * 1;
        if (sumCopy1 == 0) {
            System.out.println(i + " 1 coins");
        }
        for (int j = sumCopy1 / 2; j >= 0; j--) {
            int sumCopy2 = sumCopy1;
            if (sumCopy2 < 2) {
                break;
            }
            sumCopy2 = sumCopy1 - 2 * j;
            if (sumCopy2 == 0) {
                System.out.println(i + " 1 coins " + j + " 2 coins ");
            }
            for (int k = sumCopy2 / 5; k >= 0; k--) {
                int sumCopy3 = sumCopy2;
                if (sumCopy2 < 5) {
                    break;
                }
                sumCopy3 = sumCopy2 - 5 * k;
                if (sumCopy3 == 0) {
                    System.out.println(i + " 1 coins " + j + " 2 coins "
                            + k + " 5 coins");
                }
            }
        }
    }
}

}


0

これは、再帰とメモ化を使用して、O(mxn)の複雑さをもたらすpythonベースのソリューションです

    def get_combinations_dynamic(self, amount, coins, memo):
    end_index = len(coins) - 1
    memo_key = str(amount)+'->'+str(coins)
    if memo_key in memo:
        return memo[memo_key]
    remaining_amount = amount
    if amount < 0:
        return []
    if amount == 0:
        return [[]]
    combinations = []
    if len(coins) <= 1:
        if amount % coins[0] == 0:
            combination = []
            for i in range(amount // coins[0]):
                combination.append(coins[0])
            list.sort(combination)
            if combination not in combinations:
                combinations.append(combination)
    else:
        k = 0
        while remaining_amount >= 0:
            sub_combinations = self.get_combinations_dynamic(remaining_amount, coins[:end_index], memo)
            for combination in sub_combinations:
                temp = combination[:]
                for i in range(k):
                    temp.append(coins[end_index])
                list.sort(temp)
                if temp not in combinations:
                    combinations.append(temp)
            k += 1
            remaining_amount -= coins[end_index]
    memo[memo_key] = combinations
    return combinations

さて、上記に多項式の実行時間があるとは思いません。多項式の実行時間が可能かどうかは不明です。しかし、私が観察したのは、多くの場合、上記はメモ化されていないバージョンよりも高速に実行されることです。理由については引き続き調査します
lalatnayak 2017
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.