相关疑难解决方法(0)

我是麻省理工学院开放式课程的SICP课程的初学者,使用视频讲座和在线提供的书籍.昨天我遇到了一个例子,它询问我们是否可以编写一个程序来计算改变任何给定金额的方法的数量.

这个问题有一个简单的解决方案作为递归过程:

(define (count-change amount)
  (cc amount 5))
(define (cc amount kinds-of-coins)
  (cond ((= amount 0) 1)
        ((or (< amount 0) (= kinds-of-coins 0)) 0)
        (else (+ (cc amount
                     (- kinds-of-coins 1))
                 (cc (- amount
                        (first-denomination kinds-of-coins))
                     kinds-of-coins)))))
(define (first-denomination kinds-of-coins)
  (cond ((= kinds-of-coins 1) 1)
        ((= kinds-of-coins 2) 5)
        ((= kinds-of-coins 3) 10)
        ((= kinds-of-coins 4) 25)
        ((= kinds-of-coins 5) 50)))

如果你想检查更多,我从这里拿走它.

他们通过添加以下内容计算使用K种硬币改变数量(N)的数量(N):

1. 没有第一类硬币的改变A的方式(X)的数量.

2. 改变(A - D)的方式(Y)的数量,其中D是fisrt硬币的面额,使用所有K种类型的硬币.

问题是,我只是不明白这一点.接着,他们试图解释说:

"要明白为什么这是真的,请注意改变的方法可以分为两组:那些不使用任何第一种硬币的那些,以及那些使用任何第三种硬币的方法.因此,改变方法的总数对于某些金额等于不使用任何第一种硬币进行金额变更的方式的数量,加上假设我们使用第一种硬币进行变更的方式的数量.(最后一句话)与加法N = X + Y相同？)但后一个数字等于使用第一种硬币后剩余数量的变化方式的数量.(使用此硬币后,它们指的是方式是否使用第一种硬币进行更改？) " …

我最近面临一个编程算法的提示,我不知道该怎么做.我以前从来没有真正写过算法,所以我对此有点新意.

问题是写一个程序,以确定收银员根据硬币值和硬币数量作为变化回馈所有可能的硬币组合.例如,可能有一个有4个硬币的货币:2美分,6美分,10美分和15美分硬币.这有多少组合等于50美分？

我正在使用的语言是C++,虽然这并不重要.

编辑:这是一个更具体的编程问题,但我如何分析C++中的字符串来获取硬币值？它们是在文本文档中给出的

4 2 6 10 15 50 

(在这种情况下,数字对应于我给出的例子)

我正在为android制作一个数学应用程序.在其中一个字段中,用户可以输入int(无数字且高于0).这个想法是获得所有可能的和,使得这个int,没有双打(在这种情况下4 + 1 == 1 + 4).唯一知道的是这一个int.

例如:

假设用户输入4,我希望应用程序返回:

• 4
• 3 + 1
• 2 + 2
• 2 + 1 + 1
• 1 + 1 + 1 + 1

显然4 == 4所以也应该加上.关于我应该如何做这个的任何建议？

这是一个采访问题:

给定金额,比如167.37美元,找到使用货币中可用面额产生此金额变化的所有可能方法？

任何想到空间和时间效率算法和支持代码的人,请分享.

这是我写的(工作)代码.我试图找到这个的运行时间,任何帮助表示赞赏

    import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;


public class change_generation {

    /**
     * @param args
     */

    public static void generatechange(float amount,LinkedList<Float> denominations,HashMap<Float,Integer> useddenominations)
    {
        if(amount<0)
            return;
        if(amount==0)
        {
            Iterator<Float> it = useddenominations.keySet().iterator();
            while(it.hasNext())
            {
                Float val = it.next();
                System.out.println(val +" :: "+useddenominations.get(val));
            }

            System.out.println("**************************************");
            return;
        }

        for(Float denom : denominations)
        {

            if(amount-denom < 0)
                continue;

            if(useddenominations.get(denom)== null)
                useddenominations.put(denom, 0);

            useddenominations.put(denom, useddenominations.get(denom)+1);
            generatechange(amount-denom, denominations, useddenominations);
            useddenominations.put(denom, useddenominations.get(denom)-1);
        }

    }

    public static void main(String[] args) {
        // …

我正在从范围列表中创建一个包含itertools的列表,到目前为止我有这个:

start_list = [xrange(0,201,1),xrange(0,201,2),xrange(0,201,5),xrange(0,201,10),xrange(0,201,20),xrange(0,201,50),xrange(0,201,100),xrange(0,201,200)]

现在,我知道如果我试图运行下一行,它将杀死我的python解释器:

next_list = list(itertools.product(*start_list))

我想知道的是,是否有可能引入一个参数来检查每个元组,它的项目总和只有在等于一定数量时才将它们放入next_list中？

也许是这样的:

next_list = list(itertools.product(*start_list,sum(tuples)=200))

我知道这是不对的,我可能需要开始重新思考我的方式.start_list在生成器中的范围是否太多而无法构建另一个列表？

我的任务是使用强力写入算法来确定不同方式的数量,给定数量的相关变化组合.更改将使用以下硬币生产:便士(1美分),镍(5美分),角钱(10美分)和季度(25美分).

例如

输入:16(表示16美分的变化)

输出:可以通过6种不同的方式生成,它们是:

1. 16便士.
2. 11便士,1镍
3. 6便士,1角钱
4. 6便士,2镍
5. 1便士,3镍
6. 1便士,1镍,1角钱

我的算法必须为指定的更改量生成所有可能的更改组合.

关于如何开始这样的算法,我完全不知所措.让我前进的任何意见或见解都会很棒.

我试图解决硬币改变问题.因为我住在欧洲让我们成为欧元问题.我们需要5欧元.我们可以使用10,20,50美分,1欧元,2欧元和5欧元.有多少种可能获得5欧元？

这是leif在这里发布的代码.

cents = 50
denominations = [50, 20, 10, 5, 2, 1]
names = {50: "", 20: "", 10 : "", 5 : "", 2 : "", 1: ""}

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:
            comb.append( (left, denominations[i]) )
            i += 1
        while i < len(denominations):
            comb.append( (0, denominations[i]) )
            i += 1
        print " ".join("%d %s" …

我正在尝试使用递归方法来解决硬币找零问题。问题是这样的：

系统会为您提供不同面额的硬币和总金额。编写一个函数来计算组成该数量的组合的数量。

系统会为您提供一定数量的硬币。

这是我到目前为止的内容：

private static int[] coins = {1,2,5};

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

public static int count(int n)
{
    // If n is 0 then there is 1 solution
    if (n == 0)
        return 1;

    // If n is less than 0 then no solution exists
    if (n < 0)
        return 0;

    return count(n - coins[0]) + count(n - coins[1]) + count(n - coins[2]);
}

当我这样做时，我什么也无法找到正确的组合。我认为问题在于退货，但我不知道为什么。在这里，我从金额中减去硬币，然后每次将它们加在一起。当它为0时，返回1。

我正在研究以下算法，想知道我的实现是否正确：

给定无限数量的四分之一、一角硬币、五分硬币和便士，编写代码来计算表示 n 美分的方法数

这是没有记忆的：

def count_ways(n)
  return 0 if n < 0 
  return 1 if n == 0 

  count_ways(n-25) + count_ways(n-5) + count_ways(n-10) + count_ways(n-1)
end