标签: composition

我想知道是否有一种优雅的方法来推导出2n的所有成分作为n个非负整数变量的总和.

例如,对于n = 2个变量x和y,有5个成分有两个部分:

x = 0 y = 4; x = 1 y = 3; x = 2 y = 2; x = 3 y = 1; x = 4 y = 0

使得x + y = 4 = 2n.

更一般地,该问题可以被公式化以找到s的所有组成为n个非负整数变量,其总和等于s.

关于如何有效地计算这个问题的任何建议都是值得欢迎的,一些伪代码将非常受欢迎.谢谢.

编辑:虽然下面的解决方案如Perl和Prolog所示,但Java实现可能会出现一个新问题,因为线性数据结构(如数组)需要在递归调用期间传递和操作,并且这样的实践可能会变得非常昂贵更大,我想知道是否有替代(并且更有效)的Java实现来解决这个问题.

我需要为许多类实现基本行为.举个例子,假设它是一种绘图行为:可以绘制许多不同类型的对象,它们都需要一些属性和一些通用代码来实现绘图过程.假设我将这个常见部分放在一个名为Drawable的类中.

问题是这些不同的类可能正在扩展其他类,所以我不能让它们继承自Drawable.显而易见的解决方案是使用接口(IDrawable),但是我无法在其中实现任何代码; 我能想到的另一个解决方案是使用组合,通过创建一个我所有类都可以实例化的DrawAction类,但这需要我在我需要制作的所有类中放入相同的代码(如果只是几行)绘制.

有人可以给我一些关于如何做的建议吗？谢谢.

我来自ECMAScript背景(似乎是非常C/C++).因此,我学习了经典的C++样式继承,包括类,对象和多态等很酷的东西.

我最近喜欢Android和iOS开发.Java看起来是基于C的,所以我很好地使用了我的大多数基于C的规则,但是iOS足够不同以至于我对我的方法很谨慎 - 特别是对象继承这样的东西.

我问,因为似乎对作文有一些强烈的意见.从我迄今为止看到的构图,我不是最大的粉丝,除非该项目提供了一个很好的理由来使用它.

你是专业的Obj-C/iOS开发者,你会推荐构图而不是经典继承吗？还是情境化的东西？

当我们谈论构造线程安全类时，我并没有真正理解“委托”的概念。这是什么意思？以及该策略如何有效地创建线程安全类？何时会失败？有人可以举个例子吗？

我对编程很新,对Java来说也是新手.我在今年秋天开始开设计算机科学课程之前就开始自学,我对两种不同作者的语法有好奇心.在一本书中,通常通过使类成为JFrame的扩展来建立JFrame

public class MyClass extends JFrame {

等等

但是,另一位作者以及本网站上的问题通常会在课程内部建立一个框架:

public class MyClass {
JFrame frame = new JFrame();

首先,一个优于另一个的优势是什么？在我看来,我并不是一个专家,将类作为JFrame的扩展可以更容易地设置框架的参数并且还可以向其添加组件.

你只想说扩展格式的IE

add(component);

但是,在其他格式中,必须键入:

frame.getContentPane().add(component);

这似乎更乏味.

有人可以简洁地解释这背后的原因,或者只是一个偏好的问题.我已经调查了这个并且无法得到直接的答案.

我经常面对这个问题.假设我有这些课程:

class B
{
  public:
    virtual std::string className(){return "B";}
};

class A
{
  public:
    A()
    : _B(new B)
    {}

    virtual std::string className(){return "A";}

    virtual void desc()
    {
      std::cout << "I am " << className() << 
        " and I own: " << _B->className() << std::endl;
    }

  protected:
    B * _B;
};

然后,我想扩展A并B提供新信息.我敢肯定,SuperA并SuperB有一个"是"的有关系A,并B分别.直接的方法是尝试继承:

class SuperB: public B
{
  public:
    virtual std::string className(){return "SuperB";}
}

class SuperA: public A
{
  public: …

假设我有一个抽象类,创建和复制是昂贵的:

class AbstractBase {
public:
    AbstractBase() {
        for (int i = 0; i < 50000000; ++i) {
            values.push_back(i);
        }
    }

    virtual void doThing() = 0;

private:
    vector<int> values;
};

它有两个子类FirstDerived:

class FirstDerived : public AbstractBase {
public:
    void doThing() {
        std::cout << "I did the thing in FirstDerived!\n";
    }

};

并且SecondDerived:

class SecondDerived : public AbstractBase {
public:
    void doThing() {
        std::cout << "I did the thing in SecondDerived!\n";
    }
};

此外,我想创建一个使用FirstDerived或SecondDerived使用组合(不是聚合)的类.意思是说我想 …

因此,我经常发现自己设计的"管道"就像数据流一样,并且通常最终导致管道本身是动态的.

有没有一种简单的方法可以做这样的事情？

pipe :: [a -> a] -> a -> a

或者是否有一种不同的模式我应该用这样的东西来达成？它类似于State monad,但我不想编辑函数(a -> (), a)或其他:/

我意识到这是一个幺半群,所以我写了这个,这似乎是一个优雅的解决方案,它存在于某个库的某个库中吗？似乎大多数箭头和函数Monoids做不同的事情.

newtype Comp a = Comp { 
      runComp :: a -> a 
}

instance Monoid (Comp a) where
  (Comp a) `mappend` (Comp b) =  Comp (b . a)
  mempty = Comp id

pipe :: [a -> a] -> a -> a
pipe = runComp . foldMap Comp

任何人都有他们用于此类事情的模式吗？谢谢!

我无法理解Dot（函数组合）和bind（>> =）之间的区别。

如果我理解的话，这两种方法会将以前的功能结果用于新功能。

那么区别是什么呢 ？

我在玩Haskell中的类型，偶然发现它length . sum是有效的。是否有某种语义上的含义应该允许它起作用，或者这仅仅是类型定义的疣？我已经在下面编写了每个类型定义。

length :: Foldable t => t a -> Int
sum :: (Foldable t, Num a) => t a -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
length . sum :: (Foldable t1, Foldable t2, Num (t1 a)) => t2 (t1 a) -> Int

我能理解的唯一情况是将字符加到一个字符串中，然后就可以得到该字符串的长度。但是，sum只能采用可折叠的数字类型，因此无法使用。