小编m09*_*m09的帖子

好的,基本上我知道选项1或2是否适用于以下情况:

naturals = 0 : map (+ 1) naturals

选项包括:
1.执行很糟糕,每一步都重新计算:

naturals     = [0]
naturals'    = 0:map (+ 1) [0]          // == [0, 1]
naturals''   = 0:map (+ 1) [0, 1]       // == [0, 1, 2]
naturals'''  = 0:map (+ 1) [0, 1, 2]    // == [0, 1, 2, 3]
naturals'''' = 0:map (+ 1) [0, 1, 2, 3] // == [0, 1, 2, 3, 4]

2.执行不是很糟糕,列表总是无限的,map只应用一次

naturals     = 0:something
                                  |
naturals'    = 0:      map (+ 1) (0: …

另一个简单的问题:是否有任何方法可以告诉flex更喜欢匹配较短事物的规则与匹配较长事物的规则？我找不到任何关于这方面的好文件.

这就是我需要的原因:我为一个伪语言解析一个文件,其中包含一些与控制指令相对应的关键字.我希望它们是绝对的优先级,这样它们就不会被解析为表达式的一部分.我实际上需要这个优先级的东西,因为我不需要为我的项目写一个完整的语法(在我的情况下,因为我对解析的程序执行结构分析,我不需要知道细节,这将是完全矫枉过正的... .),所以我不能使用精细的语法调整来确保这些块不会被解析为表达式.

任何帮助将不胜感激.

以下是解析文件的示例:

If a > 0 Then read(b); Endif
c := "If I were...";
While d > 5 Do d := d + 1 Endwhile

我只想收集关于Ifs,Thens,Endifs等的信息......其余对我来说无关紧要.这就是为什么我喜欢Ifs,Thens等...相关规则要优先考虑,而不必编写语法.

这篇文章只讨论scala.collection.mutable.LinkedList.其他实现不是此线程的主题.

我的问题是:这门课的用例是什么？我发现它具有可变和不可变类型结构的问题,同时产生无效的好处.我这样说是因为:

• 该API在我看来,就好像它是一个不可改变的API( ,filter,,map 等全部返回一个新的,而不是做就地修改)droptakeLinkedList
• 至少我猜,不可变链表的所有好处都不存在,即结构之间的最大共享,因为它们仍然是可变的(通过var elem和var next.

所以基本上我们有线性访问时间,线性附加时间,线性空间等,并且没有任何东西可以在空间复杂性或推理代码的能力中显示(除了可能是O(1)前置,但它仍然是不可变列表的情况) .

我没有看到这种结构的重要好处吗？我正在寻找适用于本课程的客观测量和/或用例.

罪犯是A,B,C和D之一.

A说:"这不是我"
B说:"它是D"
C说:"它是B"
D说:"这不是我"

而且我们知道其中只有一个说实话.

谁是谁？我想用Prolog来解决它.

这是一个面试问题.

我正在研究项目euler问题14.

我用一个编码不好的程序解决了它,没有记忆,运行了386 5秒(见编辑).

这里是:

step :: (Integer, Int) -> Integer -> (Integer, Int)
step (i, m) n   | nextValue > m         = (n, nextValue)
                | otherwise             = (i, m)
                where nextValue = syr n 1

syr :: Integer -> Int -> Int
syr 1 acc   = acc
syr x acc   | even x    = syr (x `div` 2) (acc + 1)
            | otherwise = syr (3 * x + 1) (acc + 1)

p14 = foldl step …

作为Prolog的初学者,我发现Prolog中的交换表达非常不直观.

例如,如果我想表达X和Y在一个家庭中,如:

family(X,Y) :-
      married(X,Y);
      relative(X,Y);
      father_son(X,Y).

我还应该在定义中添加以下内容,以使其"可交换":

      married(Y,X);
      relative(Y,X);
      father_son(Y,X).

但是我们使用Prolog,因为我们想要编写优雅的代码......所以,我希望只在原始代码中添加一行(而不是上面的三行):

      family(Y,X).

这是POINT.它会导致不确定!为什么序言不那么"合乎逻辑"？是否有一个替代这个整洁的单行表达式,不会导致不确定？

周末愉快!瓦

所以.我有一个非常基本的脚本,它连接到一个数据库,并find在一个包含大量文档的集合上执行,并将其限制为3个项目.一切都顺利进行,除了在我的结果结束时,a null和脚本没有终止,而是在成功后悄然关闭连接.

在这里,我声明我的参数并创建我的数据库对象:

var SERVER = 'localhost',
 PORT = 27017,
 DATABASE = 'test',
 COLLECTION = 'coll',
 mongo = require('mongodb'),
 db = new mongo.Db(DATABASE,
  new mongo.Server(SERVER, PORT, {auto_reconnect: true}),
  {});

在这里,我连接到数据库并继续使用find游标和each函数查询它:

db.open(function(err, db) {
 if(err) throw err;
 var collection = new mongo.Collection(db, COLLECTION),
  cursor = collection.find({}, {}).limit(3);
 cursor.each(function(err, doc) {
  if(err) throw err;
  console.log(doc);
 });
 db.close();
});

结果很好:

{ _id: '1',
  a: 'first object' }
{ _id: '2',
  a: 'second object' }
{ _id: …

我有一个函数,rev它为三个类型类中的类型返回一些值:

rev :: (Integral a, Show a, Read a) => a -> a
rev = read . reverse . show

我想通过quickcheck测试一些关于它的属性.虽然,我对测试Integral类型的负值不感兴趣,因为我在基础库中Integer缺少Natural类型.所以我想,让我们采取与生成的值为负时生成的值相反的方法,我会没事的:

prop_id :: (Integral a, Show a, Read a) => Positive a -> Bool
prop_id n | n >= 0    = (rev.rev) n == n
          | otherwise = let n' = -n in (rev.rev) n' == n'

(测试的属性在这里并不重要 - 特别是它不适用于非常基本的值,我知道这一点,它不是这个问题的主题)

然后我遇到了Positive修改器,并认为虽然我的测试现在正在运行,但以更好的方式实现它会很好.所以我尝试过:

prop_id :: (Integral a, Show a, Read a) => Positive a …

我使用一个标记器将法语句子分成单词,并且包含法语字符的单词出现问题â.

我试图找出问题并最终归结为这个简单的事实:

>>> re.match(r"’", u'â', re.U)
>>> re.match(r"[’]", u'â', re.U)
<_sre.SRE_Match object at 0x21d41d0>

â与一个模式相匹配,’ 如果它放在一个整体匹配器中.

关于UTF-8处理我是否有问题或者它是一个错误？

我的python版本是:

Python 2.7.3 (default, Jan  2 2013, 13:56:14) 
[GCC 4.7.2] on linux2

编辑:

嗯,令人尴尬的是,似乎r用一个u修复问题来替换模式的前缀.

我不知道为什么官方文档广泛使用r,然后:((

最近我正在网上学习Haskell,学习Haskell for Great Good.

我有两个问题:

1. fmap (replicate 3)是类型的Functor f=> f a -> f [a].为什么可以应用它Just？

2. 此外,为什么是fmap (replicate 3) Just类型a -> [Maybe a],而不是类型a -> Maybe [a]？