blocks|key|4545105|text|如果vector已经订购，您可以尝试rle。提取长度($lengths)，然后提取cumsum。正如我前面提到的，如果没有订购，这将不起作用(同样，这取决于你真正想要的)。基本上，rle通过检查拉伸上相似的连续元素的数量来工作。它将在列表中给出lengths和相应的values。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4545106|cumsum(rle(v1)$lengths)
#[1]+28+37+42+46+50|code-block|syntax|javascript|4545107|另一种选择是按向量对序列进行分组，并获取每个group的max值。我认为这是一个缓慢的过程。|4545108|unname(cumsum(tapply(seq_along(v1),v1,+FUN=which.max)))++++
#[1]+28+37+42+46+50|4545109|或者只检查前一个值与当前值是否相同，然后插入TRUE作为最后一个元素，用which得到TRUE的索引|4545110|+which(c(v1[-1]!=v1[-length(v1)],TRUE))
+#[1]+28+37+42+46+50|4545111|或者使用match|4545112|+c(match(unique(v1),v1)-1,+length(v1))[-1]
#[1]+28+37+42+46+50|4545113|或者使用findInterval|4545114|+findInterval(unique(v1),+v1)
+#[1]+28+37+42+46+50|4545115|更新|4545116|对于新的矢量v2|4545117|max.col(t(sapply(unique(v2),+`==`,+v2)),'last')
#[1]+41+46+45+44+50+27|4545118|或者在ordering无序向量之后使用findInterval的函数|4545119|+++f1+<-+function(v){
++++++v1+<-+setNames(v,+seq_along(v))
++++++ind+<-+order(v1)
++++++as.numeric(names(v1[ind][findInterval(unique(v1),+v1[ind])]))
++++}+++++

+f1(v2)
+#[1]+41+46+45+44+50+27|4545120|使用@Marat+talipov的帖子中的示例(z)，|4545121|+f1(z)
+#[1]+4+5+3|4545122|注意:我按照唯一元素首次出现在z中的顺序得到结果。即1，然后是3、2。如果需要根据值重新排序，可以使用order+(如@Marat+Talipov所述)来完成。然而，在这种情况下，还不清楚OP真正想要什么。|4545123|数据|4545124|v1+<-+c(1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+1,+
+1,+1,+1,+1,+1,+1,+1,+1,+2,+2,+2,+2,+2,+2,+2,+2,+2,+3,+3,+3,+3,+
+3,+4,+4,+4,+4,+5,+5,+5,+5)

v2+<-++c(1,+2,+1,+2,+1,+1,+1,+3,+1,+2,+2,+3,+3,+3,+1,+1,+1,+4,+1,+1,+
+1,+4,+1,+5,+5,+6,+6,+2,+3,+3,+4,+4,+2,+2,+2,+2,+2,+3,+3,+3,+1,+
+4,+4,+4,+3,+2,+5,+5,+5,+5)

+z+<-+c(1,+3,+2,+1,+3)|4545125|entityMap^0|2|6|I|3|R|9|15|6|2I|3|3E|7|3P|6|0|0|M|5|S|3|0|0|M|4|10|5|17|4|0|0|4|5|0|0|4|C|0|0|0|6|2|0|0|3|8|J|C|0|0|O|1|0|0|F|1|Q|1|V|1|X|1|1F|5|0|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|21|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|27|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|28|8|@$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2G|8|@$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2K|8|@$9|2L|A|2M|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|2N|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2O|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|14|3|15|5|H|7|2S|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]]|D|@]|E|$]]|$1|18|3|19|5|H|7|2Y|8|@]|D|@]|E|$I|J]]|$1|1A|3|1B|5|6|7|2Z|8|@$9|30|A|31|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|H|7|32|8|@]|D|@]|E|$I|J]]|$1|1E|3|1F|5|6|7|33|8|@$9|34|A|35|B|C]|$9|36|A|37|B|C]|$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|3E|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|H|7|3F|8|@]|D|@]|E|$I|J]]|$1|1K|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]]|1L|$]]

You could try <code>rle</code> if the <code>vector</code> is already ordered. Extract the lengths (<code>$lengths)</code> and then <code>cumsum</code>. As I mentioned earlier, this will not work if it is not ordered (again it depends on what you really wanted). Basically <code>rle</code> works by checking the number of consecutive elements that are similar on a stretch. It will give the <code>lengths</code> and corresponding <code>values</code> in a list. 

<pre><code>cumsum(rle(v1)$lengths)
#[1] 28 37 42 46 50
</code></pre>

Another option is to group the sequence by the vector and get the <code>max</code> value for each <code>group</code>. I would imagine this to be slow.

<pre><code>unname(cumsum(tapply(seq_along(v1),v1, FUN=which.max))) 
#[1] 28 37 42 46 50
</code></pre>

Or just check whether the previous value is the same as the current value and then insert <code>TRUE</code> as the last element, and get the index of <code>TRUE</code> with <code>which</code>

<pre><code> which(c(v1[-1]!=v1[-length(v1)],TRUE))
 #[1] 28 37 42 46 50
</code></pre>

Or use <code>match</code>

<pre><code> c(match(unique(v1),v1)-1, length(v1))[-1]
#[1] 28 37 42 46 50
</code></pre>

Or use <code>findInterval</code>

<pre><code> findInterval(unique(v1), v1)
 #[1] 28 37 42 46 50
</code></pre>

<h3>Update</h3>

For the new vector <code>v2</code>

<pre><code>max.col(t(sapply(unique(v2), `==`, v2)),'last')
#[1] 41 46 45 44 50 27
</code></pre>

Or a function using <code>findInterval</code> after <code>ordering</code> the unordered vector

<pre><code> f1 &lt;- function(v){
 v1 &lt;- setNames(v, seq_along(v))
 ind &lt;- order(v1)
 as.numeric(names(v1[ind][findInterval(unique(v1), v1[ind])]))
 } 

 f1(v2)
 #[1] 41 46 45 44 50 27
</code></pre>

Using the example (<code>z</code>) from @Marat talipov's post, 

<pre><code> f1(z)
 #[1] 4 5 3
</code></pre>

NOTE: I get the result in the order in which the unique elements first appeared in <code>z</code>. i.e. <code>1</code>, followed by <code>3</code>, <code>2</code>. If it needs to be ordered again based on the values, it can be done using <code>order</code> (as mentioned by @Marat Talipov). However, it is not clear what the OP really wanted in such situations.

<h3>data</h3>

<pre><code>v1 &lt;- c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 
 3, 4, 4, 4, 4, 5, 5, 5, 5)

v2 &lt;- c(1, 2, 1, 2, 1, 1, 1, 3, 1, 2, 2, 3, 3, 3, 1, 1, 1, 4, 1, 1, 
 1, 4, 1, 5, 5, 6, 6, 2, 3, 3, 4, 4, 2, 2, 2, 2, 2, 3, 3, 3, 1, 
 4, 4, 4, 3, 2, 5, 5, 5, 5)

 z &lt;- c(1, 3, 2, 1, 3)
</code></pre>

blocks|key|4545155|text|也可以尝试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4545156|which(c(diff(tmp),+TRUE)+==+1)
#+[1]+28+37+42+46+50|code-block|syntax|javascript|4545157|或者类似的|4545158|which(!!c(diff(tmp),+TRUE))|4545159|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Also could try

<pre><code>which(c(diff(tmp), TRUE) == 1)
# [1] 28 37 42 46 50
</code></pre>

Or similarly

<pre><code>which(!!c(diff(tmp), TRUE))
</code></pre>

blocks|key|4545187|text|另一种即使数据没有排序也有效的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4545188|length(v1)-match(unique(v1),rev(v1))%2B1|code-block|syntax|javascript|4545189|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another approach that works even if the data are not ordered:

<pre><code>length(v1)-match(unique(v1),rev(v1))+1
</code></pre>

blocks|key|4545217|text|这是另一种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4545218|z+<-+c(1,2,1,2,+1,+1,+1,+3,+1,+2,+2,+3,+3,+3,+1,+1,+1,+4,+1,+1,+1,+4,+1,+5,+5,+6,+6,+2,+3,+3,+4,+4,+2,+2,+2,+2,+2,+3,+3,+3,+1,+4,+4,+4,+3,+2,+5,+5,+5,+5)

i+<-+which(!duplicated(z,fromLast=T))
i[order(z[i])]|code-block|syntax|javascript|4545219|duplicated返回一个逻辑向量，表示从相反方向考虑的重复项。其思想是取该向量的倒数来获得唯一元素的逻辑向量，并使用which来获得索引。|offset|length|style|CODE|4545220|更新:正如评论中所指出的，我最初的答案which(!duplicated(z,fromLast=T))返回的向量与输入向量中元素的升序不对应。为了解决这个问题，我将第一个命令的结果保存为向量i，并根据需要对其重新排序。|4545221|entityMap^0|0|0|0|A|1O|5|0|J|W|2N|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

Here is another approach:

<pre><code>z &lt;- c(1,2,1,2, 1, 1, 1, 3, 1, 2, 2, 3, 3, 3, 1, 1, 1, 4, 1, 1, 1, 4, 1, 5, 5, 6, 6, 2, 3, 3, 4, 4, 2, 2, 2, 2, 2, 3, 3, 3, 1, 4, 4, 4, 3, 2, 5, 5, 5, 5)

i &lt;- which(!duplicated(z,fromLast=T))
i[order(z[i])]
</code></pre>

<code>duplicated</code> returns a logical vector indicating duplicates, considered from the reverse side. The idea is to take an inverse of this vector to obtain logical vector of unique elements, and to use <code>which</code> to obtain the indices.

UPDATE:
As noted in the comment, my original answer <code>which(!duplicated(z,fromLast=T))</code> returned a vector that did not correspond to the increasing order of elements in the input vector. To fix that issue, I saved the result from the first command as vector <code>i</code> and reordered it as needed.

blocks|key|4545242|text|只是为了好玩，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4545243|library(dplyr)++
#you+can+use+new+feature+`add_rownames()`+++
data.frame(x,+row=1:length(x))+%25>%25+group_by(x)+%25>%25++summarise(max(row))
#++x+max(row)
#1+1+++++++41
#2+2+++++++46
#3+3+++++++45
#4+4+++++++44
#5+5+++++++50
#6+6+++++++27|code-block|syntax|javascript|4545244|为|4545245|x+<-+c(1,+2,+1,+2,+1,+1,+1,+3,+1,+2,+2,+3,+3,+3,+1,+1,+1,+4,+1,+1,+
++1,+4,+1,+5,+5,+6,+6,+2,+3,+3,+4,+4,+2,+2,+2,+2,+2,+3,+3,+3,+1,+
++4,+4,+4,+3,+2,+5,+5,+5,+5)|4545246|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just for fun, 

<pre><code>library(dplyr) 
#you can use new feature `add_rownames()` 
data.frame(x, row=1:length(x)) %&gt;% group_by(x) %&gt;% summarise(max(row))
# x max(row)
#1 1 41
#2 2 46
#3 3 45
#4 4 44
#5 5 50
#6 6 27
</code></pre>

for

<pre><code>x &lt;- c(1, 2, 1, 2, 1, 1, 1, 3, 1, 2, 2, 3, 3, 3, 1, 1, 1, 4, 1, 1, 
 1, 4, 1, 5, 5, 6, 6, 2, 3, 3, 4, 4, 2, 2, 2, 2, 2, 3, 3, 3, 1, 
 4, 4, 4, 3, 2, 5, 5, 5, 5)
</code></pre>

blocks|key|38199|text|tapply(seq_along(v),+v,+max)
#++1++2++3++4++5++6+
#+41+46+45+44+50+27+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|38200|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>tapply(seq_along(v), v, max)
# 1 2 3 4 5 6 
# 41 46 45 44 50 27 
</code></pre>

blocks|key|4545268|text|只是为了好玩--不是矢量化--但确实是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4545269|sapply(split(seq_along(v),+v),+max)
#+1++2++3++4++5++6+
#41+46+45+44+50+27+|code-block|syntax|javascript|4545270|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just for fun - not vectorized - but does the job:

<pre><code>sapply(split(seq_along(v), v), max)
# 1 2 3 4 5 6 
#41 46 45 44 50 27 
</code></pre>

blocks|key|4545292|text|使用grouping函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4545293|g+<-+grouping(v)
g[attr(g,+"ends")]
#+[1]+41+46+45+44+50+27|code-block|syntax|javascript|4545294|entityMap^0|2|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

With the <code>grouping</code> function:

<pre><code>g &lt;- grouping(v)
g[attr(g, "ends")]
# [1] 41 46 45 44 50 27
</code></pre>

I have an unordered vector <code>v</code> like the one shown below and would like to find the indices of the last occurrence of every unique elements in the list.

<pre><code>v &lt;- scan(text="1 2 1 2 1 1 1 3 1 2 2 3 3 3 1 1 1 4 1 1 1 4 1 5 5 6
 6 2 3 3 4 4 2 2 2 2 2 3 3 3 1 4 4 4 3 2 5 5 5 5")
v
# [1] 1 2 1 2 1 1 1 3 1 2 2 3 3 3 1 1 1 4 1 1 1 4 1 5 5 6 6 2 3 3 4 4 2 2 2 2 2 3 3 3 
# [41] 1 4 4 4 3 2 5 5 5 5
</code></pre>

Expected result (in order of 1, 2, 3, 4, 5): 

<pre><code>41 46 45 44 50
</code></pre>

I know I can use <code>unique(unlist(v))</code> to find the unique elements but then how to find the indices of their last appearance? Any idea?

Thanks in advance.

Find the indices of last occurrence of the unique elements in a vector

我有一个无序向量v，就像下面显示的那样，希望找到列表中每个唯一元素的最后一次出现的索引。v <- scan(text="1 2 1 2 1 1 1 3 1 2 2 3 3 3 1 1 1 4 1 1 1 4 1 5 5 6 6 2 3 3 4 4 2 2 2 2 2 3 3 3 1 4 4...

问查找向量中最后一次出现的唯一元素的索引
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找向量中最后一次出现的唯一元素的索引EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找向量中最后一次出现的唯一元素的索引
EN