标签: reduce

我是Python的初学者,这是我的第一篇文章,所以不要太苛刻:).我最近一直在玩Python,并且想知道是否有类似的东西

max([x for x in range(25)]) 

会导致Python首先创建所有元素的列表,然后找到最大值,产生O(2n)时间,或者它会跟踪Θ(n)迭代时的最大值.另外,由于Python3中的范围不同(是可迭代的),是否会使它与Python2中的不同？

我的javascript应用程序非常适用于firefox和chrome.但它在Internet Explorer(IE 8)上被破坏了.

我在控制台日志中没有收到错误消息.通过调试我注意到的代码,应用程序在以下行中断:

 series.reduce(visit, []);

此时整个功能退出.我知道,这reduce适用于数组,但console.info(typeof(series))告诉:对象

但是这个对象看起来像一个数组 - 它可以在FF/Chrome上运行.这可能是为什么IE停止处理此功能的原因？并且:如何在IE处理这个？

谢谢.

假设a = [[1,2,3],[1,2,3]] reduce(lambda x,y: x==y, a)回归True

但如果a = [[1,2,3],[1,2,3],[1,2,3]] reduce(lambda x,y: x==y, a)回归False

为什么在第二种情况下,结果是False？

请帮忙

谢谢

我在客户端用Javascript做这个.我想改造:

[
  {
    "id": 10,
    "name": "Designer",
    "slug": "designer",
    "children": [
      {
        "id": 11,
        "name": "UI / Visual Designer",
        "slug": "ui-visual-designer",
        "children": []
      },
      ...
    ]
  },
  {
    "id": 1,
    "name": "Software Engineer",
    "slug": "software-engineer",
    "children": [
      {
        "id": 2,
        "name": "Back-End Developer",
        "slug": "back-end-developer",
        "children": []
      },
      ...
    ]
  },
  ...
]

进入这个:

[
  {
    "id": 10,
    "text": "Designer"
  },
  {
    "id": 11,
    "text": "UI / Visual Designer",
  },
  {
    "id": 1,
    "text": "Software Engineer",
  },
  {
    "id": 2, …

我需要通过将所有重复的条目合并到一个对象中从列表中生成一个唯一的朋友列表可以有重复项
示例 - 从不同的社交订阅源获取朋友并将其放入1个大列表中
1.朋友 - [姓名:"Johnny Depp", dob:"1970-11-10",来源:"FB",fbAttribute:".."]
2.朋友 - [姓名:"Christian Bale",dob:"1970-01-01",来源:"LI" ,liAttribute:".."]
3.朋友 - [姓名:"Johnny Depp",dob:"1970-11-10",来源:"Twitter",twitterAttribute:".."]
4.朋友 - [姓名: "Johnny Depp",dob:"1970-11-10",来源:"LinkedIn",liAttribute:".."]
5.朋友 - [姓名:"Christian Bale",dob:"1970-01-01",来源:"LI",liAttribute:".."]

预期输出
1.朋友 - [姓名:"Christian Bale",dob:"1970-01-01",liAttribute:"..",fbAttribute:"..",twitterAttribute:".."]
2.朋友 - [名称:"Johnny Depp",dob:"1970-11-10",liAttribute:"..",fbAttribute:"..",twitterAttribute:".."]

问题 - 如何在不使用任何中间容器的情况下合并？我可以轻松地使用中间映射并对条目的每个值应用reduce.

List<Friend> friends;
Map<String, List<Friend>> uniqueFriendMap
    = friends.stream().groupingBy(Friend::uniqueFunction);
List<Friend> mergedFriends = uniqueFriendMap.entrySet()
    .stream()
    .map(entry -> {
           return entry.getValue()
                .stream()
                .reduce((a,b) -> friendMergeFunction(a,b));
    })
    .filter(mergedPlace -> mergedPlace.isPresent())
    .collect(Collectors.toList());

我喜欢这样做而不使用中间Map uniqueFriendMap.有什么建议？

当reduce()在并行流上使用该操作时,OCP考试书指出reduce()参数必须遵守某些原则.这些论点如下:

1. 必须定义标识,使得对于流u中的所有元素,combiner.apply(identity,u)等于u.
2. 累加器运算符op必须是关联的和无状态的,(a op b) op c等于a op (b op c).
3. 组合器运算符还必须是关联的和无状态的并且与标识兼容,以便对于所有u和t combiner.apply(u, accumulator.apply(identity, t))等于accumulator.apply(u,t).

考试书提供了两个例子来说明这些原则,请参阅下面的代码:

关联的示例:

System.out.println(Arrays,asList(1,2,3,4,5,6))
.parallelStream()
.reduce(0,(a,b) -> (a-b))); //NOT AN ASSOCIATIVE ACCUMULATOR

OCP书中对此有何说法:

它可能会输出-21,3或其他一些值,因为累加器函数违反了associativity属性.

身份要求的示例:

System.out.println(Arrays.asList("w","o","l","f"))
.parallelStream()
.reduce("X", String::concat));

OCP书中对此有何说法:

如果我们使用的身份参数不是真正的身份值,您可以看到其他问题.它可以输出XwXoXlXf.作为并行过程的一部分,标识将应用于流中的多个元素,从而导致非常意外的数据.

我不明白这些例子.使用累加器示例,累加器以0 -1 = -1然后-1 -2开始,其中= -3然后-6等等一直到-21.我明白,因为生成的arraylist不同步,结果可能是不可预测的,因为竞争条件等的可能性,但为什么累加器不关联？Woulden也不会(a+b)导致不可预测的结果？我真的没有看到示例中使用的累加器有什么问题,以及为什么它不是关联的,但是我仍然不能完全理解关联原则是什么.

我也不了解身份的例子.据我所知,如果4个独立的线程同时开始与身份一起累积,那么结果确实可能是XwXoXlXf,但这与身份参数本身有什么关系呢？究竟什么是适当的身份才能使用呢？

我想知道是否有人可以更多地了解这些原则.

谢谢

试图解决代码战中的这一挑战。根据挑战，数组的部分：

ls = [0, 1, 3, 6, 10]

是

ls = [0, 1, 3, 6, 10]
ls = [1, 3, 6, 10]
ls = [3, 6, 10]
ls = [6, 10]
ls = [10]
ls = []

我们需要返回一个包含这些部分之和的数组。

所以我的代码如下：

ls = [0, 1, 3, 6, 10]
ls = [1, 3, 6, 10]
ls = [3, 6, 10]
ls = [6, 10]
ls = [10]
ls = []

问题在于，它希望我们在数组为空时将最后一个总和0加。所以我们应该得到：

[20，20，19，16，10，0]

代替

[20、20、19、16、10]

所以我尝试了这个：

function partsSums(ls) {
  let arrayOfSums = …

我经常发现自己这样做:

list.stream().min(new Comparator<>() {

    @Override
    public int compare(E a, E b) {
        return Double.compare(f(a),f(b));
    }
})

哪里f是计算密集型功能.这需要两倍于f实际需要的评估.我更喜欢

list.stream().mapToDouble(f).min()

但后来我不知道如何获得这个最小值对应的原始元素.

围绕这个的一个丑陋的方法是

class WithF<E>{
    private final E e;
    private final double fe;
    WithF(E e, double fe){
        this.e = e;
        this.fe = fe;
    }
    public E getE(){
        return e;
    }
    public double getFE(){
        return fe;
    }
}

然后

list.stream().map(e -> new WithF<>(e,f(e))).min(Comparator.comparingDouble(WithF::getFE))

使用流API是否有更好的,惯用的方法？

我有以下代码:

(defn series-sum
  "Compute a series : (+ 1 1/4 1/7 1/10 1/13 1/16 ...)"
  [n]
  (->> (iterate (partial + 3) 1)
       (map #(/ 1 %))
       (take n)
       (reduce +)
       float
       (format "%.2f")
       (str)))

它工作得很好,只是当数字变大时它的运行时间会爆炸.在我的电脑(series-sum 2500)上可能是一(series-sum 25000)两秒,但我必须杀死我的REPL.

我尝试尽可能地移动(take n),但这还不够.我觉得我对Clojure不了解,因为我不明白为什么它会慢一点(我希望(series-sum 25000)大约需要10倍(series-sum 2500)).

有一个明显的循环/重复解决方案来优化它,但我喜欢能够打印步骤和一步((take n)看起来像docstring)的想法.

如何在保持可调试性的同时提高此代码的性能？

更好的是,我可以测量每个步骤的时间来看一个花时间吗？

一些背景资料：

我正在使用 Dataiku DSS、HDFS 和分区数据集。我有一个特定的作业正在运行（Hive 查询），它有两个输入数据集 - 一个是非常大的分区数据集，另一个是小的（~250 行，2 列）非分区数据集。我们称分区表 A 和非分区表 B。

题：

查询格式如下，

SELECT a.f1, f2, ..., fn
  FROM A as a
  LEFT JOIN B as b
  ON a.f1 = b.f1
WHERE {PARTITION_FILTER}

这是 MapReduce 作业的当前输出（请记住，该作业仍在运行）：

[09:05:53] [INFO] [dku.utils]  - INFO  : Total jobs = 4
[09:05:53] [INFO] [dku.utils]  - INFO  : Starting task [Stage-10:CONDITIONAL] in serial mode
[09:05:53] [INFO] [dku.utils]  - INFO  : Stage-11 is filtered out by condition resolver.
[09:05:53] [INFO] [dku.utils]  - INFO  : Stage-1 …