blocks|key|4460956|text|我就快到了，但是我没有完成全部工作，而且已经很晚了(zzz)。首先是代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4460957|x+<-c(rep(1:4,+5),+rep(5:6,+3),+rep(c(1,+4,+7),+5),+rep(c(1,+5,+7),+1),+rep(2:4,+3))

#The+first+break+must+be+position+1
Xbreaklist+<-+1

#We+need+a+counter,+a+duplicate+dataset+
counter+<-+0
xx+<-+x

while+(length(xx)+>+0)+{
#first+we+extract+a+pattern+by+looking+for+the+first+repeated+number
Xpattern+<-+xx[1:(min(which(stri_duplicated(xx)+==+TRUE))-1)]

#then+we+convert+the+vector+and+the+pattern+into+a+string
XpatternS+<-+paste0(Xpattern,+collapse="")
xxS+<-+paste0(xx,+collapse="")

#then+we+extract+all+patterns+and+count+them,+multiply+by+length+and+add+1+
Xbreak+<-+1+%2B+(length(unlist(stri_extract_all_coll(xxS,+XpatternS)))+*+length(Xpattern))

#break+here+if+we+reached+the+end+
if+(Xbreak+>=+length(xx))+break

#+We+add+that+to+the+list+of+breaks
counter+<-+counter+%2B+Xbreak
Xbreaklist+<-+c(Xbreaklist,+counter)

#+then+we+remove+the+part+of+the+list+we're+done+with
xx+<-+xx[(Xbreak):length(xx)]
}

Xbreaklist
[1]++1+21+28+44+51|code-block|syntax|javascript|4460958|它有什么问题？两件事：|4460959|1不重复的模式将第一次出现的下一个模式："121212+56+787878“被拆分为("121212+567878”)|4460960|2个重复的模式(“1212565612134”)把事情搞乱了，因为stri_extract_all_coll把它们都去掉了，因此长度太长了。|offset|length|style|CODE|4460961|entityMap^0|0|0|0|0|X|L|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I am almost there, but I doesn't work for the full 100% and it is getting late (zzz). First the code:

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

#The first break must be position 1
Xbreaklist &lt;- 1

#We need a counter, a duplicate dataset 
counter &lt;- 0
xx &lt;- x

while (length(xx) &gt; 0) {
#first we extract a pattern by looking for the first repeated number
Xpattern &lt;- xx[1:(min(which(stri_duplicated(xx) == TRUE))-1)]

#then we convert the vector and the pattern into a string
XpatternS &lt;- paste0(Xpattern, collapse="")
xxS &lt;- paste0(xx, collapse="")

#then we extract all patterns and count them, multiply by length and add 1 
Xbreak &lt;- 1 + (length(unlist(stri_extract_all_coll(xxS, XpatternS))) * length(Xpattern))

#break here if we reached the end 
if (Xbreak &gt;= length(xx)) break

# We add that to the list of breaks
counter &lt;- counter + Xbreak
Xbreaklist &lt;- c(Xbreaklist, counter)

# then we remove the part of the list we're done with
xx &lt;- xx[(Xbreak):length(xx)]
}

Xbreaklist
[1] 1 21 28 44 51
</code></pre>

What is wrong with it? Two things: 
1 A pattern that is not repeated takes the first occurrence of the next pattern with it: "121212 56 787878" gets split as ("121212 5678 7878") 
2 Repeating patterns ("1212 5656 12 134") mess things up because <code>stri_extract_all_coll</code> takes them all out and hence length is to long.

blocks|key|4461129|text|这是一个部分的答案，但我认为这比在评论中发布要好。这可能会让其他人找到一种方法来做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4461130|我的想法是将向量分成大小为N的相等部分，然后检查连续的块是否是前一个块的副本。我这样做的方式可能太长了--我相信肯定有更简单的方式来做。|4461131|它似乎工作得很好，可以形成另一种方式的基础。缺点是它不能识别只出现一次的重复序列，例如"157“。|4461132|xx+<-+split(x,+ceiling(seq_along(x)/N))++#split+vector+into+equal+chunks+of+size+N
xx+<-+xx[-(length(xx))]++#get+rid+of+uneven+splitting+of+last+vector

df+<-+do.call('rbind',+xx)+#bind+together+in+a+dataframe

results<-NULL++#loop+to+test+if+row+is+same+as+previous+row+(must+be+better+way+to+do+this)
for(i+in+2:nrow(df)-1)+{results[[i]]+<-+df[i,]==df[i%2B1,]+}

results1+<-+unlist(lapply(results,+sum))+#count+TRUEs+in+each+result
results1[results1<N]<-0+#make+all+not+equal+to+size+of+chunk+(N)+equal+to+zero

indices+<-+which(diff(results1)==-N)%2B1++#this+is+the+first+non-repeating+group+of+N
indicesall+<-+(indices*N)%2B1+#to+find+location+of+next+non-repeating+id|code-block|syntax|javascript|4461133|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is a partial answer but thought it better than posting in a comment. It may get others to find a way to do this.

My idea was to split the vector into equal parts of size N. Then to check if the successive chunk was a duplicate of the previous chunk. I did this in a likely overly long way - I'm sure there must be an easier way to do it. 

It seems to work ok and could form the basis of another way of going about this. The downside is that it can't pick up the repeats that only occur once e.g. "157".

<pre><code>xx &lt;- split(x, ceiling(seq_along(x)/N)) #split vector into equal chunks of size N
xx &lt;- xx[-(length(xx))] #get rid of uneven splitting of last vector

df &lt;- do.call('rbind', xx) #bind together in a dataframe

results&lt;-NULL #loop to test if row is same as previous row (must be better way to do this)
for(i in 2:nrow(df)-1) {results[[i]] &lt;- df[i,]==df[i+1,] }

results1 &lt;- unlist(lapply(results, sum)) #count TRUEs in each result
results1[results1&lt;N]&lt;-0 #make all not equal to size of chunk (N) equal to zero

indices &lt;- which(diff(results1)==-N)+1 #this is the first non-repeating group of N
indicesall &lt;- (indices*N)+1 #to find location of next non-repeating id
</code></pre>

blocks|key|4461202|text|这里有一个函数可以做到这一点。顺便说一下，这是遗传学上的一个问题--寻找串联重复序列。Here's+a+link+to+an+algorithm+paper是一种比这更好的处理方法，但实现起来要复杂得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4461203|输出是要将x拆分成的组的向量。|4461204|首先是一个辅助函数：|4461205|factorise+<-+function(x)+{
++x+<-+length(x)
++if(x+==+1){return(1)}
++todivide+<-+seq(from+=+2,+to+=+x)
++out+<-+todivide[x+%25%25+todivide+==+0L]
++return(out)
}|code-block|syntax|javascript|4461206|现在主要的功能是：|4461207|findreps+<-+function(x,+counter+=+NULL){
++if(is.null(counter)){
++++counter+<-+c()
++++maxcounter+<-+0
++}+else+{
++++maxcounter+<-+max(counter)
++}
++holding+<-+lapply(1:length(x),+function(y){x[1:y]})
++factors+<-+lapply(holding,+factorise)
++repeats+<-+sapply(1:length(factors),+function(index)+{any(sapply(1:length(factors[[index]]),+function(zz)+{all((rep(holding[[index]][1:(length(holding[[index]])/factors[[index]][zz])],+factors[[index]][zz]))==holding[[index]])}))})
++holding+<-+holding[max(which(repeats))][[1]]
++if(length(holding)+==+length(x)){
++++return(c(counter,+rep(maxcounter+%2B+1,+length(x))))
++}+else+{
++++counter+<-+c(counter,+rep(maxcounter+%2B+1,+length(holding)))
++++return(findreps(x[(length(holding)+%2B+1):length(x)],+counter))
++}
}|4461208|它的工作原理:它是一个递归函数，它运行，切断它能找到的从向量开始的最大重复组，然后运行，直到它们都消失。|4461209|首先，我们为最终输出创建一个counter。|style|CODE|4461210|接下来，我们将从1开始将x划分为每个子集，并将其划分为一个列表holding。|4461211|然后我们找出一个组大小的所有因素，除了1。|4461212|然后才是最糟糕的部分。我们取最大子集的每个子集，并在重复合理的次数后检查它是否等于其组中的最大子集。|4461213|findreps(x)
+[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+3+3+3+3+3+3+3+3+3+3
[37]+3+3+3+3+3+4+5+6+7+7+7+7+7+7+7+7+7|4461214|如果您希望对非重复序列进行分组，我们可以使用一些dplyr和tidyr|4461215|library(dplyr)
library(tidyr)

z+<-+data.frame(x+=+x,+y+=+findreps(x))

z+%25>%25+mutate(y+=+ifelse(duplicated(y)+%7C+rev(duplicated(rev(y))),+y,+NA),
+++++++++++++holding+=+c(0,+y[2:n()]))+%25>%25
++++++fill(holding)+%25>%25
++++++mutate(y+=+ifelse(is.na(y),+holding+%2B1,+y))+%25>%25
++++++select(-holding)|4461216|这就给出了：|4461217|+[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+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+4+4+4+7+7+7+7+7+7+7+7
[53]+7|4461218|entityMap|0|LINK|mutability|MUTABLE|url|http://csiflabs.cs.ucdavis.edu/~gusfield/lineartime.pdf^0|17|Z|0|0|0|0|0|0|0|0|E|7|0|C|1|V|7|0|0|0|0|O|5|U|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|D|3|E|5|6|7|1O|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1P|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1Q|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1R|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1S|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1T|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1U|8|@$A|1V|B|1W|U|V]]|9|@]|C|$]]|$1|W|3|X|5|6|7|1X|8|@$A|1Y|B|1Z|U|V]|$A|20|B|21|U|V]]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|22|8|@]|9|@]|C|$]]|$1|10|3|11|5|6|7|23|8|@]|9|@]|C|$]]|$1|12|3|13|5|J|7|24|8|@]|9|@]|C|$K|L]]|$1|14|3|15|5|6|7|25|8|@$A|26|B|27|U|V]|$A|28|B|29|U|V]]|9|@]|C|$]]|$1|16|3|17|5|J|7|2A|8|@]|9|@]|C|$K|L]]|$1|18|3|19|5|6|7|2B|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|J|7|2C|8|@]|9|@]|C|$K|L]]|$1|1C|3|-4|5|6|7|2D|8|@]|9|@]|C|$]]]|1D|$1E|$5|1F|1G|1H|C|$1I|1J]]]]

Here's a function to do it. By the way, this is a problem in genetics - finding tandem repeats. <a href="http://csiflabs.cs.ucdavis.edu/~gusfield/lineartime.pdf">Here's a link to an algorithm paper</a> that is a much better treatment than this, but much more complicated to implement. 

The output is a vector of groups to split x into. 

First a helper function:

<pre><code>factorise &lt;- function(x) {
 x &lt;- length(x)
 if(x == 1){return(1)}
 todivide &lt;- seq(from = 2, to = x)
 out &lt;- todivide[x %% todivide == 0L]
 return(out)
}
</code></pre>

Now the main function:

<pre><code>findreps &lt;- function(x, counter = NULL){
 if(is.null(counter)){
 counter &lt;- c()
 maxcounter &lt;- 0
 } else {
 maxcounter &lt;- max(counter)
 }
 holding &lt;- lapply(1:length(x), function(y){x[1:y]})
 factors &lt;- lapply(holding, factorise)
 repeats &lt;- sapply(1:length(factors), function(index) {any(sapply(1:length(factors[[index]]), function(zz) {all((rep(holding[[index]][1:(length(holding[[index]])/factors[[index]][zz])], factors[[index]][zz]))==holding[[index]])}))})
 holding &lt;- holding[max(which(repeats))][[1]]
 if(length(holding) == length(x)){
 return(c(counter, rep(maxcounter + 1, length(x))))
 } else {
 counter &lt;- c(counter, rep(maxcounter + 1, length(holding)))
 return(findreps(x[(length(holding) + 1):length(x)], counter))
 }
}
</code></pre>

How it works:
It's a recursive function that runs, cuts off the biggest repeats group it can find from the start of the vector, and then runs until they are all gone.

First we make a <code>counter</code> for the final output.

Next, we split <code>x</code> into each subset starting from 1 into a list, <code>holding</code>.

Then we find all factors of the size of a group, except 1. 

Then is the worst part. We take each subset of the biggest subset, and check if it is equal to the biggest subset in its group after being repeated the sensible amount of times.

<pre><code>findreps(x)
 [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 3 3 3 3 3 3 3 3 3 3
[37] 3 3 3 3 3 4 5 6 7 7 7 7 7 7 7 7 7
</code></pre>

If you want non-repeats to be grouped, we can use a little <code>dplyr</code> and <code>tidyr</code>:

<pre><code>library(dplyr)
library(tidyr)

z &lt;- data.frame(x = x, y = findreps(x))

z %&gt;% mutate(y = ifelse(duplicated(y) | rev(duplicated(rev(y))), y, NA),
 holding = c(0, y[2:n()])) %&gt;%
 fill(holding) %&gt;%
 mutate(y = ifelse(is.na(y), holding +1, y)) %&gt;%
 select(-holding)
</code></pre>

Which gives:

<pre><code> [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 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 7 7 7 7 7 7 7 7
[53] 7
</code></pre>

I have a vector with repeating patterns within it. I want to break any where the repeating pattern of n length changes.
Here's the data:

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

## [1] 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 5 6 5 6 5 6 1 4 7 1 4 7 1 4 7 1 4 7 1 4 7 1 5 7 2 3 4 2 3 4 2 3 4
</code></pre>

I want to be able to find those places the pattern changes so it breaks like this:

<a href="https://i.stack.imgur.com/UtpNk.png" rel="noreferrer"><img src="https://i.stack.imgur.com/UtpNk.png" alt="enter image description here"></a>

I think <code>rle</code> may be of use but don't see how.

Find and break on repeated runs

我有一个向量，里面有重复的模式。我想要在n长度的重复模式改变的任何地方中断。以下是数据：x <- c(rep(1:4, 5), rep(5:6, 3), rep(c(1, 4, 7), 5), rep(c(1, 5, 7), 1), rep(2:4, 3))## [1] 1 2 3 4 1 2 3 4 1 2 3 4...

问在重复运行时查找和中断
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在重复运行时查找和中断EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在重复运行时查找和中断
EN