标签: reduce

如何获取javascript对象数组,例如:

my objArr = [
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:42},
{key:Mon Sep 24 2013 00:00:00 GMT-0400, val:78},
{key:Mon Sep 25 2013 00:00:00 GMT-0400, val:23},
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:54}]

并通过对值进行求和来合并重复键.为了得到这样的东西:

my reducedObjArr = [
{key:Mon Sep 23 2013 00:00:00 GMT-0400, val:96},
{key:Mon Sep 24 2013 00:00:00 GMT-0400, val:78},
{key:Mon Sep 25 2013 00:00:00 GMT-0400, val:23}]

我已经尝试迭代并添加到一个新数组,但这不起作用:

var reducedObjArr = [];
var item = null, key = null;
for(var i=0; i<objArr.length; i++) {
   item=objArr[i];
   key = Object.keys(item)[0]; …

我有一些问题,了解如何在python中使用reduce与词典.例如,我有以下字典.

{1: 3, 2: 1, 3: 2}

我正在尝试计算以下内容:

s = 0
for i in h:
    s += h[i] * (h[i] - 1)

这按预期工作(我得到:) 8,但我试图将其转换为减少范式失败: reduce(lambda x, y: x + y * (y - 1), h)但是我得到了错误的答案.

我认为这是因为我使用的是键,而不是值.如何将我的代码转换为正确缩减？

在Spark的文档中,它说RDDs方法reduce需要一个关联的AND可交换二进制函数.

但是,该方法reduceByKey仅需要关联二进制函数.

sc.textFile("file4kB", 4)

我做了一些测试,显然这是我得到的行为.为何如此区别？为什么reduceByKey确保二进制函数总是以某种顺序应用(以适应缺乏可交换性)何时reduce不？

例如,如果加载一些(小)文本有4个分区(最小):

val r = sc.textFile("file4k", 4)

然后:

r.reduce(_ + _)

返回一个字符串,其中的部分并不总是以相同的顺序,而:

r.map(x => (1,x)).reduceByKey(_ + _).first

始终返回相同的字符串(其中所有内容的顺序与原始文件中的顺序相同).

(我检查过r.glom,文件内容确实分布在4个分区,没有空分区).

运行以下代码示例以:
"线程中的异常"main"java.lang.StackOverflowError"结束

import java.util.stream.IntStream;
import java.util.stream.Stream;

public class TestStream {

    public static void main(String[] args) {
        Stream<String> reducedStream = IntStream.range(0, 15000)
            .mapToObj(Abc::new)
            .reduce(
                Stream.of("Test")
                , (str , abc) -> abc.process(str)
                , (a , b) -> {throw new IllegalStateException();}
        );
        System.out.println(reducedStream.findFirst().get());
    }

    private static class Abc { 
        public Abc(int id) {
        }

        public Stream<String> process(Stream<String> batch) {
            return batch.map(this::doNothing);
        }

        private String doNothing(String test) {
            return test;
        }
    }
}

究竟是什么导致了这个问题？这段代码的哪一部分是递归的,为什么？

我正在使用redux承诺开发天气应用程序,并且无法检索action.payLoad.data.

actions/index.js

import axios from 'axios';

const API_KEY = 'xxxxxxxxx';
const ROOT_URL = `http://api.openweathermap.org/data/2.5/forecast?appid=${API_KEY}`;

export const FETCH_WEATHER = 'FETCH_WEATHER';

export function fetchWeather(city) {
  const url = `${ROOT_URL}&q=${city},us`;
  const request = axios.get(url);

  //console.log("request:", request);

  return {
    type: FETCH_WEATHER,
    payLoad: request
  };
}

reducers/reducer_weather.js

import  { FETCH_WEATHER } from '../actions/index';

export default function(state = [], action) {
  if (action.type === FETCH_WEATHER) {
    console.log('Action.payLoad.data received:', action.payLoad.data);
    console.log('Action received:', action);
  }

  switch (action.type) {
    case FETCH_WEATHER:
      return [ action.payLoad.data, ...state ]; // …

代码胜于语言，因此：

['a', 'b', 'c'].reduce((accumulator, value) => accumulator.concat(value), []);

该代码非常愚蠢，并返回一个复制的数组...

TS抱怨concat的参数：TS2345：类型'string'的参数不能分配给'ConcatArray'类型的参数。

我试图mkString在Java8中编写一个函数,一个Scala是有用的,mkString并遇到了两个问题,我可以使用一些帮助:

1. 我无法创建mkString泛型Collection引用的第一个参数,Collection<Object> c并且让调用者使用任何类型的集合调用.

2. 无法引用内联返回的结果reduce()来访问结果的长度以删除额外的前导分隔符.

这是代码:

public static void main(String[] args) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    System.out.println(mkString(numbers, ","));

}

public static String mkString(Collection<Integer> c, String sep) {
    return c.stream()
            .map(e -> String.valueOf(e))
            .reduce("", (a, b) -> a + sep + b)
            .substring(1, <<>>.length);
}

我当前的代码在 typescriptlang.org （打字稿游乐场）上运行

我已经阅读了 typeScript 中类型的重要性以及如何在函数中使用它们。然而，我正在努力在此减少方法中添加以下类型：

// Types for car
type Car = {
 name:string,
 age:number,
 registered: boolean
};

// Reduce function to hopefully get the total number of cars that are registered.

function totalRegisteredCars(cars:Car[]) {
 cars.reduce((acc:number , car:Car) => {
    if(car.registered === true ) {
        acc + 1;
    }
 },0);
}

var cars = [
{name:'vw' , age: 30, registered: true},
{name:'vw' , age: 32, registered: true},
{name:'Merc' , age: 25, registered: false},
{name:'bmw' , age: 20, registered: false}, …

这不应该工作吗？

> val setOfSets = Set[Set[String]]()    
setOfSets: scala.collection.immutable.Set[Set[String]] = Set()

> setOfSets reduce (_ union _)
java.lang.UnsupportedOperationException: empty.reduceLeft
  at scala.collection.TraversableOnce$class.reduceLeft(TraversableOnce.scala:152)
  [...]

你知道reducePython中的方便功能.例如,您可以使用它来总结这样的列表(假装没有内置总和):

reduce(lambda x,y: x+y, [1,2,3,4], 0)

返回(((0 + 1)+2)+3)+4 = 10.

现在如果我想要一个中间总和列表怎么办？在这种情况下,[1,3,6,10].

这是一个丑陋的解决方案.还有更多的pythonic吗？

def reducelist(f, l, x): 
  out = [x]
  prev = x
  for i in l:
    prev = f(prev, i)
    out.append(prev)
  return out