blocks|key|1969137|text|.init参数决定输出中的第一个值。如果您没有指定任何内容，它将将向量的第一个值作为输出中的第一个值返回(此处为1)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1969138|来自?accumulate。|1969139|1969140|+.init+-如果提供，将用作开始积累的第一个值，而不是使用.x[1]。|blockquote|1969141|1969142|1969143|您可以指定自己的.init参数。|1969144|library(purrr)
1:5+%25>%25+accumulate(`%2B`,+.init+=+3)
#[1]++3++4++6++9+13+18|code-block|syntax|javascript|1969145|entityMap^0|0|5|0|2|B|0|0|0|0|0|8|5|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|12|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|13|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|R|7|19|8|@]|D|@]|E|$S|T]]|$1|U|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|V|$]]

<code>.init</code> argument decides which would be the 1st value in the output. If you haven't specified anything it returns the the first value of the vector as first value in the output (which is 1 here).
From <code>?accumulate</code>.
<blockquote>
.init - If supplied, will be used as the first value to start the accumulation, rather than using .x[[1]].
</blockquote>
You can specify your own <code>.init</code> argument.
<pre><code>library(purrr)
1:5 %&gt;% accumulate(`+`, .init = 3)
#[1] 3 4 6 9 13 18
</code></pre>

blocks|key|1419330|text|accumulate是两个参数函数，其中第一个参数是向量，第二个参数是函数。它的输出也是与输入的输出长度相同的向量，除非提供.init，在这种情况下，它将比输入长度大一长度。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1419331|1:5+%25>%25+accumulate(`%2B`)

#means

accumulate(1:5,+`%2B`)|code-block|syntax|javascript|1419332|现在，accumulate通过在所提供向量的各个元素之间滚动所提供的函数来计算输出。由于作为输出的第二个参数提供的operation需要两个元素，即(i)前一个元素的输出和(ii)下一个元素，因此逻辑上它可以第一次输出输入向量的相同元素，而无需任何操作。|1419333|1:5+%25>%25+accumulate(`%2B`)
#>+[1]++1++3++6+10+15|1419334|即使提供了.init，情况也是一样的，在这种情况下，输出向量的第一个元素将等于提供的.init。(见Ronak的例子)|1419335|library(purrr)
1:5+%25>%25+accumulate(`%2B`,+.init+=+3)
#[1]++3++4++6++9+13+18|1419336|现在检查输出向量中有六个元素，尽管输入向量中有五个元素(1:5)。|1419337|您的逻辑是，给定输出的第一个元素应该是3，这是正确的，但在大多数情况下，输出向量的要求与输入的长度相同。因此，开发人员可能会考虑将第一个元素作为第一个元素，而不需要任何函数的操作/应用。|1419338|entityMap^0|0|A|1Q|5|0|0|3|A|1L|9|0|0|5|5|16|5|0|0|0|J|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1G|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|X|$]]

<code>accumulate</code> is a two argument function where the first argument is a vector and the second argument a function. Its output is also a vector of the same length as that of the input unless <code>.init</code> is supplied in which case it will be one length greater than the input length.
<pre><code>1:5 %&gt;% accumulate(`+`)

#means

accumulate(1:5, `+`)
</code></pre>
Now, <code>accumulate</code> calculates the output by rolling the supplied function between the individual elements of the supplied vector. Since the <code>operation</code> supplied as the second argument for the output requires two elements i.e. (i) output of previous element and (ii) next element, logically for the first time it may output the same element of the input vector without applying any operation.
<pre><code>1:5 %&gt;% accumulate(`+`)
#&gt; [1] 1 3 6 10 15
</code></pre>
The case will be the same even if <code>.init</code> is provided and in that case the first element of the output vector will be equal to the supplied <code>.init</code>. (See Ronak's example)
<pre><code>library(purrr)
1:5 %&gt;% accumulate(`+`, .init = 3)
#[1] 3 4 6 9 13 18
</code></pre>
Now check that there are six elements in output vector despite five elements in input vector (1:5).
Your logic that the first element of the given output should be <code>3</code> is correct but in most cases the requirement of the output vector is of the same length as that of the input. Therefore, the developers may have thought to include the first element as such without any operation/application of function.

I read the manual for using <code>accumulate</code> saying that it is a 2-argument function. I don't understand the given example:
<pre><code>1:5 %&gt;% accumulate(`+`)
#&gt; [1] 1 3 6 10 15
</code></pre>
If <code>accumulate</code> is a 2-argument function, should the first element that it outputs be <code>3</code>? because <code>1+2=3</code>, why can the first element can be the output?

Understanding how the accumulate function works

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我阅读了使用accumulate的手册，说它是一个2参数函数。我不明白这个例子：1:5 %>% accumulate(`+`)#> [1]  1  3  6 10 15如果accumulate是一个2参数函数，那么它输出的第一个元素应该是3吗？因为1+2=3，为什么第一个元素可以是输出？

问理解累积函数是如何工作的
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问理解累积函数是如何工作的EN