小编F. *_*ler的帖子

我想知道Haskell中是否存在已定义的类型类,它声明了连接.

对于列表,有++和concat.但当然还有其他类型可以使用.

例:

type Valuater = A -> [Int]
concatValuater :: [Valuater] -> Valuater
concatValuater vs = \a -> concat [v a | v <- vs]

是不是有类型类concat？

我有一个像这样的Java-8-FunctionalInterface:

@FunctionalInterface
public interface A {
    void doIt ();
}

该Function-Interface提供的compose-方法.我想用它来减少这样的流A:

Stream<A> as;
A composed = as.reduce (() -> {}, Function::compose);

结果我希望有一个函数A,它调用每个AStream的方法doIt.

composed.doIt (); // Executes every doIt ()

但由于A 不是实现者Function,因此Function::compose不可能使用方法参考.我不能从Function(或Supplier)扩展,因为那时我将有两个抽象方法(我自己和来自Function).

我能做些什么来使我的功能成为可能A呢？

也许这是一个经常被问到的问题,但我没有找到答案.

monad的绑定定义如下:

(>>=)  :: m a -> (a -> m b) -> m b

目前我正在这样做:

foo :: Int
foo = sum $ ((*11) . (+2)) `map` [1..4]

我想实现这样的语法,因为我认为它更具可读性:

[1..4] >>= (+2) >>= (*11) >>= sum

我不知道合适的运营商而不是>>=.

此外:foo是198.

我编写了代码来查找大量字符串中的distinct元素.代码如下

HashMap<String, Integer> countMap = new HashMap<>();
String[] str={"aa","bb","cc","bb","aa","cc","aa","bb","cc","bb"};
for (String e : str) {
  if (!countMap.containsKey(e)) {
    countMap.put(e, 1);
  } 
}
Iterator it=countMap.keySet().iterator();
String[] db= new String[countMap.size()];
for(int i=0;i<countMap.size();i++){
  db[i]=(String)it.next();
  System.out.println(db[i]);
}

有没有比这更快的代码,因为我必须处理非常大的数组.

我对Java相对较新,但当然试图变得更好.我无法解决一个容易看起来容易解决的问题,但这里是:写一个计算n!/ k的程序!(阶乘),取n和k作为用户输入,检查n> k> 0并且如果不是则打印错误.

这是我到目前为止所拥有的.我知道我没有完成问题的错误部分,但我想让它现在正常工作.计算一个因子是非常直接的,但将两者分开似乎是一个挑战.任何帮助,将不胜感激!提前致谢!

import java.util.Scanner;

public class nkFactorial {

    @SuppressWarnings({ "resource" })
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);   
        System.out.println("Enter n");
        int n = input.nextInt();
        System.out.println("Enter k");
        int k = input.nextInt();

        long nfactorial=1;
        long kfactorial=1;

        do {
            nfactorial *=n;
            n--;
            kfactorial *=k;
            k--;
        } while (n>k && k>1);
        System.out.println("n!/k!=" + nfactorial/kfactorial );
    }
}