小编CSn*_*erd的帖子

我从Mongoose网站上快速入手,我几乎复制了代码,但我无法使用Node.js连接MongoDB.

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test');

exports.test = function(req, res) {
  var db = mongoose.connection;
  db.on('error', console.error.bind(console, 'connection error:'));
  console.log("h1");
  db.once('open', function callback () {
    console.log("h");
  });
  res.render('test');
};

这是我的代码.控制台只打印h1,而不是h.我哪里错了？

最近我正在研究操作系统.我只想知道:

系统调用(如write())和标准库函数(如printf())之间有什么区别？

关于leetcode的单号II的问题是:

给定一个整数数组,除了一个元素外,每个元素都会出现三次.找一个单一的.注意:您的算法应具有线性运行时复杂性.你能不用额外的内存来实现吗？

实际上,我已经从网站上找到了解决方案,解决方法是:

public int singleNumber(int[] A) {
    int one = 0, two = 0;
    for (int i = 0; i < A.length; i++) {
        int one_ = (one ^ A[i]) & ~two;
        int two_ = A[i] & one | ~A[i] & two;
        one = one_;
        two = two_;
    }
    return one;
}

但是,我不知道为什么这个代码可以工作,实际上我不知道在我第一次看到这个问题时想到这个问题的方法呢？任何帮助.谢谢!

我刚学会了Scala.现在我对Contravariance和Covariance很困惑.

从这个页面,我学到了以下内容:

协方差

也许子类型最明显的特征是能够用表达式中较窄类型的值替换较宽类型的值.例如,假设我有一些类型的Real,Integer <: Real和一些不相关的类型Boolean.我可以定义一个is_positive :: Real -> Boolean对Real值进行操作的函数,但我也可以将此函数应用于类型Integer(或任何其他子类型Real)的值.用更窄(后代)类型替换更宽(祖先)类型被称为covariance.这个概念covariance允许我们编写通用代码,在推理面向对象编程语言中的继承和函数式语言中的多态时非常有用.

但是,我也从其他地方看到了一些东西:

scala> class Animal?    defined class Animal

scala> class Dog extends Animal?    defined class Dog

scala> class Beagle extends Dog?    defined class Beagle

scala> def foo(x: List[Dog]) = x?    foo: (x: List[Dog])List[Dog] // Given a List[Dog], just returns it?     

scala> val an: List[Animal] = foo(List(new Beagle))?    an: List[Animal] = List(Beagle@284a6c0) …

我刚刚开始学习Haskell,其中一个奇怪的事情是具有多个参数的函数类型的语法.

考虑一个简单的例子:

(+) :: Num a => a -> a -> a

为什么我们需要这里的所有箭头？写一些类似的东西不是更有意义Num Num Num -> Num吗？

引擎盖下的原因是什么？我搜索了这个问题,但找不到任何有用的东西.

TreeSet 的构造函数除了标准构造函数之外，还包括一个允许您提供 Comparator 的构造函数和一个允许您从另一个 SortedSet 创建一个的构造函数：

TreeSet(Comparator<? super E> c)
// construct an empty set which will be sorted using the
// specified comparator 
TreeSet(SortedSet<E> s)
// construct a new set containing the elements of the 
// supplied set, sorted according to the same ordering

Run Code Online (Sandbox Code Playgroud)

其中的第二个在其声明中与标准的“转换构造函数”太接近了：

TreeSet(Collection<? extends E> c)

Run Code Online (Sandbox Code Playgroud)

正如 Joshua Bloch 在 Effective Java（方法一章中的“明智地使用重载”项）中所解释的那样，调用带有相关类型参数的两个构造函数或方法重载之一可能会产生令人困惑的结果。这是因为，在 Java 中，对重载构造函数和方法的调用是在编译时根据参数的静态类型解析的，因此对参数应用强制转换会对调用结果产生很大的影响，因为以下代码显示：

// construct and populate a NavigableSet whose iterator returns its
// elements in the reverse of natural order:
NavigableSet<String> base = new …

Run Code Online (Sandbox Code Playgroud)

某种字符串处理语言提供了一种原始操作,它将字符串分成两部分.由于此操作涉及复制原始字符串,因此无论剪切的位置如何,对于长度为n的字符串,都需要n个时间单位.现在假设您要将字符串分成许多部分.中断的顺序可能会影响总运行时间.例如,如果你想在3号和10号位置剪切一个20个字符的字符串,那么在第3个位置进行第一次剪切会产生20 + 17 = 37的总成本,而在第10个位置进行第一次剪切会产生更好的成本20+ 10 = 30.

给出一个动态编程算法,给定长度为n的字符串中m个切口的位置,找到将字符串分成m + 1个片段的最小成本.

这个问题来自"算法"第6章6.9.

由于这个问题没有答案,这就是我的想法.

定义OPT(i,j,n)为打破字符串的最小成本,i起始索引,j字符串的结束索引以及n我可以使用的剩余剪切数.

这是我得到的:

OPT(i,j,n) = min {OPT(i,k,w) + OPT(k+1,j,n-w) + j-i} for i<=k<j and 0<=w<=n

是对还是不对？请帮忙,谢谢!

问题是:整数的反转数字.

例1:x = 123,返回321

例2:x = -123,返回-321

您是否注意到反转的整数可能会溢出？假设输入是32位整数,则反向1000000003溢出.你应该如何处理这类案件？

抛出异常？很好,但如果抛出异常不是一种选择呢？然后,您必须重新设计该功能(即添加一个额外的参数).

我搜索的网站的解决方案是:

public class Solution {

     public static int reverse(int x) {
            int ret = 0;
            boolean zero = false;
            while (!zero) {
                ret = ret * 10 + (x % 10);
                x /= 10;      
                if(x == 0){
                    zero = true;
                }
            }
            return ret;   
        }

    public static void main(String[] args) {
        int s = 1000000003;
        System.out.println(reverse(s));
    }

}

但是,当s = 1000000003控制台打印-1294967295而不是3000000001.因此,如果我们不能使用异常,这个解决方案仍然无法解决溢出问题.这里有什么帮助？(虽然有一个提示:添加一个额外的参数,我仍然无法弄清楚我应该添加什么参数)

就Array没有给出初始值时而言,new是必需的,还有一个显式类型:

val ary = new Array[Int](5)

但对于List:

val list1 = List[Int]() // "new" is not needed here.

添加时new,会发生错误:

scala> val list = new List[Int]()
<console>:7: error: class List is abstract; cannot be instantiated
       val list = new List[Int]()

为什么会这样？

我认为Promise.resolve并且new Promise(resolve)可以互换。

考虑一下：

一种。

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return new RSVP.Promise(function (resolve) {
        resolve("HI")
    });
}).then(function (result) {
    console.log(result);
});

B．

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return RSVP.resolve("HI");
}).then(function (result) {
    console.log(result);
});

如我所料，两个都打印“ HI”。

因此，我认为如果我不需要“拒绝”任何东西。我可以简单写RSVP.resolve();。

但是，请考虑以下示例：

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return new RSVP.Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve("HI")
        }, 3000);
    });
}).then(function (result) {
    console.log(result);
});

如何使用 …