标签: higher-order-functions

我的教授要求我们在 Haskell 中实现冒泡排序。问题应该很简单，但是，他指定了这样的函数签名

bsort :: (a -> a -> Bool) -> [a] -> [a]
bsort = undefined

问题是 a 没有导出Ord，所以我不知道如何比较as。所以我想知道这是否可行或者他忘记添加(Ord a) =>？

要求：基本上我在 React JS 中有一个员工对象数组，比如 empList。这个 empList 包含原始字段和另一个“地址”对象的内部数组，例如 addressList。我想获取属于城市“ABC”的所有员工的数据。它们在城市“ABC”中可以有多个地址，但它们应该只被提取一次并被推入 FinalList 一次。

问题：我能够过滤在城市“ABC”中有地址的员工，但如果他们在城市“ABC”有多个地址，那么他们会被多次添加到最终列表中。因此，我想检查一名员工的所有地址，以防万一在城市“ABC”中找到任何地址，我想将其添加到 FinalList，打破这个内部 map() 函数并转到外部 map() 进行检查为下一位员工。

下面是我的代码片段。

var finalList =[];
empList.map(function(employee) {
           
            var valid = employee.addressList.map(function(address) {
                if (address.city.startsWith("ABC")) {
                    finalList.push(employee);
                    //Employee pushed to validList once, so now break from inner map() function & goto second line/execute on next employee object 
                  
                }
            });     //.slice(0,1); Slice doesn't work here since I want the condition to be true first, then break it.

0

大家，早安。

我有以下数据：

import pandas as pd\n\ninfo = {\n'states': [-1, -1, -1, 1, 1, -1, 0, 1, 1, 1],\n'values': [34, 29, 28, 30, 35, 33, 33, 36, 40, 41] }\n\ndf = pd.DataFrame(data=info)\n\nprint(df)\n\n>>> \n    states   values\n0       -1       34\n1       -1       29\n2       -1       28\n3        1       30\n4        1       35\n5       -1       33\n6        0       33\n7        1       36\n8        1       40\n9        1       41\n

我需要使用 PANDAS（和/或高阶函数）对数据进行分组（已经使用 for 循环进行了练习），我需要对以“状态”列作为指导的数据进行分组。但分组不应该是所有数据，我只需要对相邻的数据进行分组......如下所示：

初始数据框：

    states   values\n0       -1       34 \xe2\x94\x90\n1       -1       29 \xe2\x94\x82    Group this …

我对列表理解有一点认识.我理解的表达方式:

[x * x | x <- [1..10]]
should output [1,4,9,16,25,36,49,64,81,100]

并且该表达式的效果与以下内容相同:

map power [1..10]
power x = x * x

现在,我必须找到以下函数的其他方法(就像上面这样):

[(x,y+z) | x <- [1..10], y <- [1..x], z <- [1..y]]

我无法自己弄清楚没有错误,请帮助我

我无法理解这里发生了什么？任何人都可以解释一下这段代码吗？这个函数如何计算长度？

callength = foldr (\_ n -> 1 + n) 0

为什么它在右下角使用lambda,下划线,下划线和n和零之间的空格？

我得到了一些变量依赖于不同功能的对象.换句话说:对象中的变量依赖于多种类型的函数,但应该有多个对象具有相同的这些函数.为了更多的清关,我试图给出一个例子(这不起作用).

#include <iostream>

class A
{
  double size;

  A( double (*f)() )
  {
    size = (*f)();
  };
};

double fun1()
{
  return 42.0;
}


int main()
{
  A a = A( &fun1() );

  std::cout << a.size << std::endl;
}

这当然是一个极小的例子.变量大小取决于某个函数,该函数应该作为参数传递给类.想象一下fun1,fun2作为不同种类的随机数生成器.

我认为C++中的ideomatic方式是一个包含变量的类,从它继承的类被不同对象的函数修改(如果我错误的话,请纠正我).但我的问题是:

是否有可能实现某种高阶构造函数？如果是这样,一个例子会很好.

ps:如果我使用了一些错误的技术术语,我很乐意得到纠正.

假设你有一个功能,你可以用"嘿"输入一个警报,你想允许它发生给定次数 - 比如2,或3,或任何你想要的 - 然后在给定的数字后提醒相同的数量时间为负数或"不再"类型的字符串.

所以你希望你的函数调用n次

var hey = funky(function(){alert("hey")},3);

hey();

你是怎样做的？

我在Haskell中有一个字符串列表,我需要在另一个列表中获取奇数长度的元素.如何使用更高阶函数(如foldr,foldl,foldr1,foldl1,filter,map等)来完成此操作？我非常感谢你的帮助.在这种情况下可以使用列表理解吗？

我有一个包含对象的数组,每个对象都有一个唯一的ID.我需要根据它们的ID分离这些对象,并创建包含只具有相同ID的对象的新数组.

这是我到目前为止..

let fullArray = [{
  name: 'John',
  id: 1
}, {
  name: 'Lucy',
  id: 1
}, {
  name: 'Tyler',
  id: 2
}];

function separateObjectsInArray(fullArray) {

  let newArr = [];

  fullArray.map((each) => {

    newArr.push(each.id);

  });

  let uniqueIdArr = [...new Set(newArr)];

  fullArray.map((eachObj) => {

    uniqueArr.map((uniqueId) => {

      if (eachObj.id === uniqueId) {
         //CREATE NEW ARRAYS WITH MATCHING ID'S

      }

    })

  })

}

separateObjectsInArray(fullArray);

正如您所看到的,我首先绘制出对象数组,然后使用ids创建一个数组,然后取出任何重复项(uniqueIdArr).之后,我再次映射fullArray并将每个对象的ID与ID的uniqueIdArr进行比较.我坚持如何告诉它为每个ID创建一个数组并推送匹配的对象.

let finalArray1 = [{
  name: 'John',
  id: 1
}, {
  name: 'Lucy',
  id: 1
}];

let finalArray2 …

我试图创建一个通用的包装函数,可以包装任何返回对象的方法.非常类似于这个 SO问题的答案.我尝试了以下方法:

def wrapper_function[T](f: => T): T = { 
    println("Executing now");
    val ret: T = f;
    println("Execution finished"); 
    ret 
}

def multiply2( x: Int ): Int = wrapper_function {
    println("inside multiply2"); 
    return x*2
}

但是,我观察到在包装函数内的函数调用之后没有执行任何操作.具体而言,"执行完成"未打印.

scala> val x = multiply2(4)
Executing now
inside multiply2
x: Int = 8

我正在使用scala 2.11.8

我在这里做错了吗？这令人费解,我将不胜感激.