标签: traversal

编写一个函数,计算列表中大于或等于平均值​​的元素数(为简单起见,使用整数除法).
只使用single traversal列表结构!

我已经有了解决方案,但它涉及ref从闭包变化的变量foo'.

我对如何 在满足时功能 传递值[]感兴趣？

我天真的解决方案使用ref:

let foo ls =
    let avg = ref 0
    let rec foo' xs sumAcc lenAcc  =
        match xs with
        | x'::xs'   ->
            let s = foo' xs' (x' + sumAcc) (1 + lenAcc)
            if x' < !avg then s else s + 1
        | []        ->
            avg := (sumAcc / lenAcc) //? how to change THIS to functional …

我想为prevUntil()或nextUntil()jQuery选择器方法选择开始和结束选择器.如果我现在实现这些方法,它会抓住给定的两个选择器之间的所有内容.

即$('p').prevUntil('h1')不包括p和h1元素,只包括它们之间的那些元素.我怎样才能选择p和h1元素以及两者之间？

我有哈希哈希%signal_db.一个典型的元素是:$signal_db{$cycle}{$key}.有10,000个信号和10,000个密钥.

有没有办法优化(按时)这段代码:

foreach my $cycle (sort numerically keys %signal_db) {
    foreach my $key (sort keys %{$signal_db{$cycle}}) {
        print $signal_db{$cycle}{$key}.$key."\n";
    }
}

元素必须以与我的代码相同的顺序打印.

作为个人复活节项目,我正在尝试在工作中实施一些基于模型的测试.我有一个在python中实现的图形,我需要遍历所有边缘/完成图形的所有转换,至少一次.遍历边缘两次或更多并不重要,但我需要在同一节点中开始和结束并获得一系列边缘/过渡.

更简单的算法>最短的序列.

我环顾四周,发现了很多算法,但我找不到一个适用于我的组合/组合.如果有人能指出我正确的方向或给我一些如何做到这一点的提示,那将是很棒的.

我的图形实现如下所示:

graph = {
    A : {'IDLE': 't8', 'B': 't2', 'C': 't4'},
    B : {'A': 't3', 'C': 't4', 'IDLE': 't6'},
    C : {'A': 't5', 'IDLE': 't7', 'B': 't2'},
    IDLE : {'A': 't1'}
}

我有这样的HTML标记:

<p>
  <label>Arrive</label>
  <input id="from-date1" class="from-date calender" type="text" />
</p>

<p>
  <label>Depart</label>
  <input id="to-date1" class="to-date calender" type="text" />
</p>

<p>
  <label>Arrive</label>
  <input id="from-date2" class="from-date calender" type="text" />
</p>

<p>
  <label>Depart</label>
  <input id="to-date2" class="to-date calender" type="text" />
</p>

我希望从日期之后获取下一个元素以获得相应的日期.(布局稍微复杂一些,但是从日期开始,从日期开始,到日期已经到了日期类).

这是我想要做的,我想从date元素中获取并使用to-date类在dom中找到下一个元素.我试过这个:

$('#from-date1').next('.to-date')

但它给了我空的jQuery元素.我认为这是因为next给下一个兄弟匹配选择器.我怎样才能得到相应的to-date？

我一直在尝试金字塔,这种遍历的事情让我疯了.我基本上摆弄周围做一个购物车的控制面板,这是基本的结构,我的想法.

登录页面

localhost:6543/admin_login

成功登录后

localhost:6543/admin/home 

查看所有现有产品

localhost:6543/admin/product

编辑产品X.

localhost:6543/admin/product/edit/1

所以我的文件夹结构是这样的(大写文件是模型)

• 我的车
  • resources.py
  • Admin.py
  • Product.py
  • 静态的
  • 模板
  • 意见
    • __init__.py
    • admin.py
    • root.py

我的resources.py

    from pyramid.security import Authenticated
    from pyramid.security import Allow
    from pyramid.response import Response

    class Root(object):
       __name__ = ''
       __parent__ = None

       def __init__(self, request):
          pass

       def __getitem__(self, key):

           if key == 'admin_login':
              return Admin()

           elif key == 'admin':
              return Admin()

           raise KeyError

    class Admin(object):

        __name__ = ''
        __parent__ = Root
        __acl__ = [(Allow, Authenticated, 'admin')]

        def __init__(self):
           pass

在views/__init.py …

我想将嵌套类转换为漂亮的键/值字典,并保留每个属性的类名和嵌套路径,以便以后轻松搜索.

这是我的示例类:

var agreement = new Agreement
            {
                ID = 101,
                Description = "Convert to dictionary",
                Customer = new Customer
                {
                    FirstName = "John",
                    LastName = "Smith",
                    Age = 30,
                    Address = new List<Address>() 
                    { 
                        new Address 
                        {
                            Name = "Los Angeles 1",
                            ZipCode = 25437
                        }, 
                        new Address
                        {
                            Name = "New York 25",
                            ZipCode = 25441
                        }
                    }
                }
            };

这是我在字典中预期的键/值输出:

KEY                                    VALUE
Agreement.ID:                          101
Agreement.Description:                 Convert to dictionary
Agreement.Customer.FirstName:          John
Agreement.Customer.LastName:           Smith
Agreement.Customer.Age:                30
Agreement.Customer.Address[0].Name:    Los Angeles …

在我的ArangoDB图中,我有一个主题,与该主题相关联的消息线程,以及这些消息线程内的消息.我想以这样一种方式遍历图形,即返回与消息线程关联的数据以及消息线程内的消息计数.

数据的结构非常简单:我有主题节点,边缘扩展到线程节点,日期和类别相关联,以及从线程节点到消息节点的边缘.

我想返回存储在线程节点中的数据和附加到线程的消息计数.

我不确定如何使用for v, e, p in 1..2 outbound语法执行此操作.我应该for v, e, p in outbound在里面使用嵌套图吗？这仍然是高性能的吗？

令我非常惊讶的是,遍历需要花费更多时间而不是合并两个排序std::list大约12%的结果.由于可以将合并视为连续元素比较并将其实现,因此列表拼接和迭代器遍历两个分开的已排序链接列表.因此,遍历不应该比通过它们合并慢,特别是当两个列表足够大时,因为迭代元素的比率增加.

然而,结果似乎与我的想法不符,这就是我测试上面的想法的方式:

std::list<int> list1, list2;

for (int cnt = 0; cnt < 1 << 22; cnt++)
    list1.push_back(rand());
for (int cnt = 0; cnt < 1 << 23; cnt++)
    list2.push_back(rand());

list1.sort();
list2.sort();

auto start = std::chrono::system_clock::now();  // C++ wall clock

// Choose either one option below
list1.merge(list2);         // Option 1
for (auto num : list1);     // Option 2
for (auto num : list2);     // Option 2

std::chrono::duration<double> diff = std::chrono::system_clock::now() - start;
std::cout << std::setprecision(9) << "\n       "
          << …

我们知道，fmap“签名是(a -> b) -> f a -> f b其中f的一个Functor。

为了尽可能地通用和更好地分解因子代码，人们可能希望将“事物列表”映射到另一个可能不同的“事物列表”。凭直觉，我不明白为什么它不应该或不可能。

我正在寻找的功能gmap与该功能具有相同的功能，fmap但具有该签名gmap :: (a -> b) -> (f a) -> (g b)，在该功能中，我允许到达和离开容器有所不同。

我不确定这在一般情况下where f和gare 是否有意义Functors，但是Traversable假设我最感兴趣的是遍历数据，那么“事物列表”的想法在本质上听起来更像是课堂上所捕获的。

所以也许签名应该是gmap :: (Traversable f, Traversable g) => (a -> b) -> (f a) -> (g b)。

即使g具有不同的性质f，它仍然可以从左到右遍历，因此仍然觉得应该能够将的第k个被访问元素映射f到的第k个被访问元素g。

假设我的想法没有错，Haskell中是否有这样的功能？

从本质上讲，我的问题是，您将如何以最简洁，最优雅的方式从Haskell中的一个类似列表的事物转换为另一个？