যখন কিছু ডলারের মান দেওয়া হয় তখন কীভাবে সমস্ত মুদ্রার সংমিশ্রণ সন্ধান করতে হয়


114

আমি কোডের একটি অংশ পেয়েছি যা আমি কয়েক মাস আগে সাক্ষাত্কারের প্রস্তুতির জন্য লিখছিলাম।

আমার যে মতামত ছিল, সে অনুযায়ী এই সমস্যাটি সমাধান করার চেষ্টা করা হয়েছিল:

সেন্টে কিছু ডলারের মূল্য দেওয়া (যেমন 200 = 2 ডলার, 1000 = 10 ডলার), ডলারের মান তৈরি করে এমন সমস্ত মুদ্রার সংমিশ্রণ সন্ধান করুন। এখানে কেবল পেনি (1 ¢), নিকেলস (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
@ কাপ্পা: পেনি = 1 সেন্ট; নিকেল = 5 সেন্ট; ডাইম = 10 সেন্ট; চতুর্থাংশ = 25 সেন্ট :)
কোডিংবিয়ার

@ জন টি: কোড গল্ফ? আমি এই শব্দটির কথা শুনিনি! যাইহোক, আমি কিছু আকর্ষণীয় উত্তরগুলি আশা করি, যেহেতু এসও সম্প্রদায় যে কোনও সমস্যার সমাধান করতে পারে
কোডিংবার

আমি ঘরে ফিরে একবার আমার উত্তর পোস্ট করার চেষ্টা করব ... এখনও কর্মক্ষেত্রে এবং এসও-তে খুব বেশি সময় ব্যয় করা উচিত নয়।
কোডিংবিয়ার

1
@blee কোড গল্ফ আপনার পছন্দের প্রোগ্রামিং ভাষার সাথে সম্ভাব্য ন্যূনতম পরিমাণে সমস্যার সমাধান বোঝায়। এই ওয়েবসাইটটিতে সম্পন্ন কিছু এখানে রয়েছে: stackoverflow.com/search?q=code+ গল্ফ
জন টি

উত্তর:


54

আমি অনেক আগে এই একবার দেখেছি এবং আপনি আমার পড়তে পারেন এটিতে ছোট্ট । এখানে গণিতের উত্স

উত্পন্ন ফাংশনগুলি ব্যবহার করে, আপনি সমস্যার বদ্ধ-ফর্ম স্থির-সময় সমাধান পেতে পারেন। গ্রাহাম, নুথ এবং পাতাসনিকের কংক্রিট গণিত এটির জন্য একটি বই এবং এতে সমস্যাটির সম্পর্কে যথেষ্ট বিস্তৃত আলোচনা রয়েছে। মূলত আপনি একটি বহুপদী সংজ্ঞায়িত করেন যেখানে n তম সহগ হ'ল এন ডলারে পরিবর্তন আনার উপায় সংখ্যা ।

লেখার 4-5 পৃষ্ঠাগুলি দেখায় যে আপনি ম্যাথমেটিকা ​​(বা অন্য কোনও সুবিধাজনক কম্পিউটার বীজগণিত সিস্টেম) কীভাবে উত্তরটির তিনটি কোডের লাইনে কয়েক সেকেন্ডে 10 ^ 10 ^ 6 ডলার গণনা করতে পারবেন।

(এবং এটি অনেক আগেই ছিল যে এটি 75Mhz পেন্টিয়ামের কয়েক সেকেন্ড ...)


16
উত্তম উত্তর, তবে ছোটখাটো কুইবলস: দ্রষ্টব্য: (1) এটি উপায়গুলির সংখ্যা দেয় , কিছু কারণের জন্য প্রশ্নটি সমস্ত উপায়ে প্রকৃত সেট জিজ্ঞাসা করে। অবশ্যই, বহুবর্ষীয় সময়ে সেটটি খুঁজে পাওয়ার কোনও উপায় নেই, যেহেতু আউটপুটে নিজেই অতিশয় বিস্তৃতভাবে অনেকগুলি এন্ট্রি রয়েছে (২) জেনারেটিং ফাংশনটি "বদ্ধ ফর্ম" কিনা তা বিতর্কযোগ্য (দেখুন হার্বার্ট উইলফের দুর্দান্ত বই জেনারেটিং ফাংশনোলজি : গণিত)। upenn.edu/~wilf/DownldGF.html ) এবং আপনি যদি (1 + √5) like n এর মত একটি এক্সপ্রেশন বোঝাতে চান তবে এটি ধ্রুবক সময় নয়, গণনা করতে Ω (লগ এন) সময় নেয়।
শ্রীভাত্সআর

ডায়নামিক প্রোগ্রামিংয়ের কোমল ভূমিকা। এছাড়াও, আমি সিকোয়েন্স সমস্যাযুক্ত কাউকে জেনারেটিং ফাংশনোলজি পড়তে উত্সাহিত করি ।
কর্নেল আতঙ্ক

অনেক ধন্যবাদ অ্যান্ড্রু ... এই ব্যাখ্যাটি আমাকে এতটা সাহায্য করেছে ... নীচের স্কেল ফাংশনটি পোস্ট করা ... কারও কারও এর প্রয়োজন হওয়া উচিত
জয়রাম এস

1
আমি বিশ্বাস করি শুরুতে প্রশ্নটির কিছুটা সংশোধন দরকার কারণ এটি "... 1-, 10-, 25-, 50-, এবং 100-শতাংশ মুদ্রা ব্যবহার করে" জিজ্ঞাসা করে? কিন্তু তারপরে রাইট আপ সেটটিকে কিন্তু aএর ডোমেন হিসাবে সংজ্ঞায়িত করে । সেন্ট কয়েন তালিকায় একটি 5- হওয়া উচিত। অন্যথায় লেখা আপ চমত্কার ছিল, ধন্যবাদ! fa = {1,5,10,25,50,100}
rbrtl

@rbrtl বাহ, আপনি ঠিক বলেছেন, তা দেখার জন্য ধন্যবাদ! আমি এটি আপডেট করব…
অ্যান্ড্রুডটন

42

বিঃদ্রঃ : এটি কেবল উপায়গুলির সংখ্যা দেখায়।

স্কালা ফাংশন:

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 পরিবর্তন করার সত্যিই একটি উপায় আছে? আমার ধারণা এটি করার কোনও উপায় নেই way
লুক

2
এটি বহুভুজ সমাধানের সংখ্যা থেকে উদ্ভূত হয় n1 * coins(0) + n2 * coins(1) + ... + nN * coins(N-1) = money। সুতরাং money=0এবং coins=List(1,2,5,10)সংমিশ্রণের জন্য গণনা (n1, n2, n3, n4)1 এবং সমাধানটি (0, 0, 0, 0)
কিআর

3
কেন এই বাস্তবায়ন কাজ করে তা আমি মাথা ঘিরে রাখতে পারি না। কেউ আমাকে পিছনে অ্যালগরিদম ব্যাখ্যা করতে পারেন?
অ্যাড্রিয়েন লেমায়ার

3
এটি অবশ্যই কোর্স স্কালার কোর্সের অনুশীলন 1 এর 3 টি সমস্যার সঠিক উত্তর।
জাস্টিন স্ট্যান্ডার্ড

আমি বিশ্বাস করি যে, তবে money == 0তবে coins.isEmpty, এটি সলান হিসাবে গণনা করা উচিত নয়। সুতরাং, coins.isEmpty || money < 0শর্তটি প্রথমে সি কেড করা থাকলে অ্যালগো আরও ভাল পরিবেশিত হতে পারে ।
জুনআচিতো

26

আমি পুনরাবৃত্তির সমাধানের পক্ষে চাই। আপনার কিছু সম্প্রদায়ের তালিকা রয়েছে, যদি ক্ষুদ্রতম কোনও বাকী মুদ্রার পরিমাণকে সমানভাবে ভাগ করতে পারে তবে এটি সূক্ষ্মভাবে কাজ করা উচিত।

মূলত, আপনি বৃহত্তম থেকে ছোট সংখ্যায় চলে যান।
recursively,

  1. আপনার কাছে এখন মোট মোট পূর্ণ করতে হবে এবং একটি বৃহত্তর সম্প্রদায় (1 টিরও বেশি বাম সহ)। যদি কেবল 1 টি সম্প্রদায়টি বাকী থাকে তবে মোটটি পূরণ করার একমাত্র উপায় রয়েছে। আপনি আপনার বর্তমান বর্ণের 0 থেকে কে অনুলিপি ব্যবহার করতে পারেন যেমন কে * কর্কৃত <= মোট।
  2. 0 থেকে কে এর জন্য, পরিবর্তিত মোট এবং নতুন বৃহত্তম বর্ণের সাহায্যে ফাংশনটি কল করুন।
  3. 0 থেকে কে পর্যন্ত ফলাফল যুক্ত করুন। এটি আপনার বর্তমান সংখ্যাকে নীচে রেখে মোট কতগুলি উপায়ে পূরণ করতে পারে। এই নম্বরটি ফেরত দিন।

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)

এটি দৌড়েছে না, তবে আপনার যুক্তি দিয়েই বোঝা যায় :)
কোডিংবার

আপনি ফাংশনের শেষ দুটি লাইন "রিটার্ন যোগ (গণনা_কম্বস (...) এর জন্য ...)" দিয়ে প্রতিস্থাপন করতে পারেন - এইভাবে তালিকাটি বাস্তবে বাস্তবায়িত হয় না। :)
নিক জনসন

বখশিশের জন্য ধন্যবাদ. আমি কোডটি আরও শক্ত করার উপায়গুলিতে সর্বদা আগ্রহী।
লিফ

2
অন্য প্রশ্নে আলোচিত হিসাবে , তালিকাটি শেষ মান হিসাবে denominationsনা থাকলে এই কোডটি ভুল আউটপুট দেবে 1ifএটি ঠিক করার জন্য আপনি অন্তর্নিহিত ব্লকে অল্প পরিমাণে কোড যুক্ত করতে পারেন (যেমন আমি অন্য প্রশ্নের উত্তরটিতে বর্ণনা করি)।
ব্ল্যাককিংহাট

12

স্কালা ফাংশন:

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
}

ধন্যবাদ! এই একটি দুর্দান্ত শুরু। তবে, আমি মনে করি এটি যখন ব্যয় হয় যখন "অর্থ" 0 হওয়া শুরু হয়।
aqn

10

সমস্যাটি সমাধান করার জন্য এখানে একেবারে সরল সি ++ কোড যা সমস্ত সংমিশ্রণগুলি দেখানোর জন্য জিজ্ঞাসা করেছিল।

#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
নিশ্চয় এটি সি ,++ নয়।
নিখিল

1
@ জর্জি ফিলিপস আপনি কি ব্যাখ্যা করতে পারেন?
চেষ্টা করা হচ্ছে

আমি মনে করি এটি বেশ সোজা। মূলত, ধারণা সব চতুর্থাংশ (0,1,2 ব্যবহার .. সর্বোচ্চ), এবং তারপর বারবার ব্যবহৃত চতুর্থাংশ উপর ভিত্তি করে সব dimes মাধ্যমে পুনরুক্তি হয়, ইত্যাদি ..
পিটার লি

4
এই সমাধানের ক্ষতিটি হ'ল: যদি এখানে 50-সেন্ট, 100-সেন্ট, 500-শতাংশ মুদ্রা থাকে তবে আমাদের 6-স্তরের লুপগুলি ব্যবহার করতে হবে ...
পিটার লি

3
এটি বেশ খারাপ, আপনার যদি ডায়নামিক সংজ্ঞা থাকে বা আপনি অন্য একটি সংজ্ঞা যুক্ত করতে চান তবে এটি কার্যকর হবে না।
shinzou

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

আপনার গতিশীল সমাধানগুলির জন্য সি বিয়োগের দৈর্ঘ্য 1 কে হতে হবে a কিছুটা বিভ্রান্তিকর। সি এর আসল দৈর্ঘ্য সমর্থন করার জন্য আপনি এটিকে সহজেই পরিবর্তন করতে পারেন
ইডান

7

কোডটি জাভাটি এই সমস্যাটি সমাধান করার জন্য ব্যবহার করছে এবং এটিও কাজ করে ... অনেকগুলি লুপের কারণে এই পদ্ধতিটি ভাল ধারণা নাও পারা যায়, তবে এটি সত্যই সরাসরি এগিয়ে যাওয়ার উপায়।

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

এটি সত্যিই একটি পুরানো প্রশ্ন, তবে আমি জাভাতে একটি পুনরাবৃত্ত সমাধান নিয়ে এসেছি যা অন্য সকলের চেয়ে ছোট মনে হয়েছিল, তাই এখানে যায় -

 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

সি (আই, জে) সেট জে মানগুলি ব্যবহার করে আই সেন্ট তৈরির সংমিশ্রণের সেট করতে দিন।

আপনি সি হিসাবে এটি নির্ধারণ করতে পারেন:

এখানে চিত্র বর্ণনা লিখুন

(প্রথম (জে) লাগে একটি নির্ণায়ক ভাবে একটি উপাদান একটি সেটের)

এটি একটি সুন্দর পুনরাবৃত্তি ফাংশন ... এবং যদি আপনি স্মৃতিচারণ ব্যবহার করেন তবে যুক্তিযুক্ত দক্ষ হয়;)


হ্যাঁ, এটি ("গতিশীল প্রোগ্রামিং", এক অর্থে) সর্বোত্তম সমাধান হতে চলেছে।
শ্রীভাতসারআর

আপনি ঠিক বলেছেন: জে তালিকা হিসাবে নাও সেট হিসাবে বেছে নিন: তারপরে প্রথমে (জে) আপনার কাছে প্রথম উপাদানটি নিয়ে আসে এবং জে \ প্রথম (জে) আপনাকে বাকী তালিকাটি দেয় gives
ওরপ্পা

এটি গণিতের কোন রূপ?
মুহাম্মদ উমার

5

অনন্য সংমিশ্রণ সমস্যাটি ঘুরে দেখার জন্য আধা হ্যাক - চাপ অবতরণ করে:

oms ডেনমস = [1,5,10,25]
Def all_combs (যোগফল, শেষ) 
  সমষ্টি == 0 হলে 1 প্রদান করুন
  প্রত্যাবর্তন $ denoms.select return | d | ডি ও লে সমষ্টি এবং & ড & লে শেষ}। ইনজেক্ট (0) total | মোট, ডেনম |
           মোট + + all_combs (সমষ্টি-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

পাইথনে এটি আমার উত্তর। এটি পুনরাবৃত্তি ব্যবহার করে না:

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

উভয়: উচ্চ থেকে নিম্নে সমস্ত সংখ্যার মধ্য দিয়ে পুনরাবৃত্তি করুন, কোনও একটি বর্ণ নিন, যথাযথ মোট থেকে বিয়োগ করুন, তারপরে বাকী অংশে পুনরাবৃত্তি করুন (উপলভ্য সম্প্রদায়গুলি বর্তমান পুনরাবৃত্ত মানের সমান বা নিম্ন হতে বাধ্য করুন))


2

যদি মুদ্রা ব্যবস্থা এটির অনুমতি দেয় তবে একটি সাধারণ লোভী অ্যালগরিদম সর্বোচ্চ মুদ্রার সাথে শুরু করে প্রতিটি মুদ্রা যতটা সম্ভব নেয়।

অন্যথায়, ডায়নামিক প্রোগ্রামিংয়ের জন্য একটি অনুকূল সমাধান দ্রুত খুঁজে পাওয়া প্রয়োজন কারণ এই সমস্যাটি মূলত ন্যাপস্যাক সমস্যা

উদাহরণস্বরূপ, যদি কোনও মুদ্রার সিস্টেমে মুদ্রাগুলি থাকে {13, 8, 1}:, লোভী সমাধানটি 24 হিসাবে পরিবর্তন করতে পারে {13, 8, 1, 1, 1}তবে আসল অনুকূল সমাধানটি হ'ল{8, 8, 8}

সম্পাদনা: আমি ভেবেছিলাম যে আমরা ডলারের জন্য পরিবর্তন করার সমস্ত উপায়ে তালিকাভুক্ত না করে, অনুকূলভাবে পরিবর্তন আনছি। আমার সাম্প্রতিক সাক্ষাত্কারে কীভাবে পরিবর্তন আনতে বলা হয়েছিল তাই প্রশ্নটি পড়া শেষ করার আগে আমি এগিয়ে গেলাম।


সমস্যাটি অগত্যা এক ডলারের জন্য নয় - এটি 2 বা 23 হতে পারে, সুতরাং আপনার সমাধানটি এখনও একমাত্র সঠিক।
নিল জি

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

এটি একটি জাভাস্ক্রিপ্ট সমাধান এবং পুনরাবৃত্তি ব্যবহার করে।


এই সমাধানটি কেবল একটি বর্ণকে খুঁজে পায়। প্রশ্নটি ছিল "সমস্ত" বর্ণবাদগুলি সন্ধান করার জন্য।
হেইনব

2

স্কালাল প্রোগ্রামিং ভাষায় আমি এটি এইভাবে করব:

 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"
}

সুতরাং, ৩ coins টি মুদ্রার জন্য, উদাহরণস্বরূপ:

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

খনিটির এই ব্লগ এন্ট্রি কোনও এক্সকেসিডি কমিকের চিত্রগুলির জন্য এই ন্যাপস্যাকটিকে সমস্যার মতো সমাধান করে । itemsডিকের একটি সাধারণ পরিবর্তন এবং মানটিও exactcostআপনার সমস্যার জন্য সমস্ত সমাধান দেবে।

যদি সমস্যাটি সর্বনিম্ন ব্যয় ব্যবহার করে এমন পরিবর্তনগুলি খুঁজে পেতে থাকে, তবে সর্বাধিক মূল্যের মুদ্রা হিসাবে ব্যবহার করা একটি নিষ্পাপ লোভী অ্যালগরিদম মুদ্রা এবং লক্ষ্য পরিমাণের সংমিশ্রণে ভালভাবে ব্যর্থ হতে পারে। উদাহরণস্বরূপ যদি মান 1, 3, এবং 4 সহ মুদ্রা থাকে; এবং টার্গেটের পরিমাণ 6 হয় তবে লোভী অ্যালগরিদম 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

আমি ওরেইলির "পাইথন ফর ডেটা অ্যানালাইসিস" বইতে এই ঝরঝরে কোডটি পেয়েছি। এটি অলস বাস্তবায়ন এবং ইনটি তুলনা ব্যবহার করে এবং আমি অনুমান করি যে এটি অন্যান্য দশকের দশমিক ব্যবহার করে সংশোধন করা যেতে পারে। আপনার জন্য এটি কেমন কাজ করেছে আমাকে জানান!

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

আপনি এই সমাধানটিকে সাধারণীকরণ করতে পারবেন না, উদাহরণস্বরূপ একটি নতুন উপাদান আসে সেই ক্ষেত্রে আপনাকে লুপের জন্য আরও একটি যোগ করতে হবে
সুমিত কুমার সাহা

1

সোজা জাভা সমাধান:

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

এখানে একটি সি # ফাংশন রয়েছে:

    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

নীচে অর্থের সমস্ত সংমিশ্রণ খুঁজতে পাইথন প্রোগ্রাম রয়েছে is এটি অর্ডার (এন) সময় সহ একটি গতিশীল প্রোগ্রামিং সমাধান। টাকা 1,5,10,25

আমরা সারি মানি 1 থেকে সারি মানি 25 (4 সারি) এর মধ্যে চলে যাই। সংযুক্তির সংখ্যা গণনা করতে আমরা যদি কেবলমাত্র অর্থ 1 টি বিবেচনা করি তবে সারি মান 1টিতে গণনা রয়েছে। সারি মানি 5 একই চূড়ান্ত অর্থের জন্য সারি মানি আরে গণনাটি তার নিজস্ব সারিতে পূর্ববর্তী 5 গণনা (বর্তমান অবস্থান বিয়োগ 5) করে প্রতিটি কলাম তৈরি করে। সারি মানি 10 সারি অর্থ 5 ব্যবহার করে, এতে উভয়ই 1,5 ​​উভয়ের জন্য গণনা করে এবং পূর্ববর্তী 10 গণনায় যোগ করে (বর্তমান অবস্থান বিয়োগ 10)। সারি মানি 25 সারি মানি 10 ব্যবহার করে, এতে সারি অর্থ 1,5,10 এর সাথে পূর্ববর্তী 25 গণনার গণনা রয়েছে।

উদাহরণস্বরূপ, সংখ্যা [1] [12] = সংখ্যা [0] [12] + সংখ্যা [1] [7] (7 = 12-5) যার ফলাফল 3 = 1 + 2; সংখ্যা [3] [12] = সংখ্যা [2] [12] + সংখ্যা [3] [9] (-13 = 12-25) যার ফলাফল 4 = 0 + 4, যেহেতু -13 0 এর চেয়ে কম হয়।

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

জাভা সমাধান

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

নীচে জাভা সমাধান যা বিভিন্ন সংমিশ্রণগুলিও প্রিন্ট করবে। সহজে বোধগম্য. আইডিয়া হয়

যোগফল 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

এখানে একটি অজগর ভিত্তিক সমাধান যা পুনরাবৃত্তির পাশাপাশি স্মৃতিচারণের ব্যবহার করে যা হে (এমএক্সএন) এর জটিলতার ফলে ঘটে

    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

ঠিক আছে আমি সন্দেহ করি উপরোক্তের বহুপদী সময় রয়েছে। নিশ্চিত না যে আমরা আদৌ বহুপদী রান সময় পেতে পারি কিনা। তবে আমি যা পর্যবেক্ষণ করেছি তা হ'ল উপরের রানগুলি অনেক ক্ষেত্রে নন-মেমোইজড সংস্করণের চেয়ে দ্রুত। আমি কেন গবেষণা চালিয়ে যাব
ললাতনায়েক
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.