blocks|key|2418852|text|这将删除末尾的元素(并显示警告)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418853|locality+<-+3
x+<-+1:100
c(apply(matrix(x,+nrow=locality,+ncol=length(x)+%25/%25+locality),+2,+sample))
##+[1]++1++2++3++4++6++5++8++9++7+12+10+11+13+15+14+16+18+17+19+20+21+22+24+23+26+25+27+28+30+29+32+33+31+35+34+36+38+39+37
##+[40]+42+40+41+43+44+45+47+48+46+51+49+50+54+52+53+55+57+56+58+59+60+62+61+63+64+65+66+67+69+68+71+72+70+74+75+73+78+77+76
##+[79]+80+81+79+83+82+84+87+85+86+88+89+90+92+93+91+96+94+95+99+98+97|code-block|syntax|javascript|2418854|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|$]]

This will drop elements at the end (with a warning):

<pre><code>locality &lt;- 3
x &lt;- 1:100
c(apply(matrix(x, nrow=locality, ncol=length(x) %/% locality), 2, sample))
## [1] 1 2 3 4 6 5 8 9 7 12 10 11 13 15 14 16 18 17 19 20 21 22 24 23 26 25 27 28 30 29 32 33 31 35 34 36 38 39 37
## [40] 42 40 41 43 44 45 47 48 46 51 49 50 54 52 53 55 57 56 58 59 60 62 61 63 64 65 66 67 69 68 71 72 70 74 75 73 78 77 76
## [79] 80 81 79 83 82 84 87 85 86 88 89 90 92 93 91 96 94 95 99 98 97
</code></pre>

blocks|key|2418880|text|我更喜欢Matthew的方法，但下面是我解决问题的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418881|x+<-+1:100
fact+<-+3

y+<-+ceiling(length(x)/fact)

unlist(lapply(split(x,+rep(1:y,+each+=fact)[1:length(x)]),+function(x){
++++if+(length(x)==1)+return(x)
++++sample(x)
}),+use.names+=+FALSE)

##+++[1]+++3+++1+++2+++6+++4+++5+++8+++9+++7++11++10++12++13++15++14++17++16++18
##++[19]++20++21++19++24++23++22++26++27++25++29++30++28++31++32++33++35++34++36
##++[37]++39++37++38++41++42++40++45++43++44++47++46++48++51++49++50++52++53++54
##++[55]++57++56++55++59++60++58++63++62++61++64++66++65++67++68++69++70++71++72
##++[73]++75++73++74++77++76++78++80++79++81++82++84++83++85++86++87++90++89++88
##++[91]++92++91++93++96++94++95++98++99++97+100|code-block|syntax|javascript|2418882|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|$]]

I like Matthew's approach way better but here was the way I did the problem:

<pre><code>x &lt;- 1:100
fact &lt;- 3

y &lt;- ceiling(length(x)/fact)

unlist(lapply(split(x, rep(1:y, each =fact)[1:length(x)]), function(x){
 if (length(x)==1) return(x)
 sample(x)
}), use.names = FALSE)

## [1] 3 1 2 6 4 5 8 9 7 11 10 12 13 15 14 17 16 18
## [19] 20 21 19 24 23 22 26 27 25 29 30 28 31 32 33 35 34 36
## [37] 39 37 38 41 42 40 45 43 44 47 46 48 51 49 50 52 53 54
## [55] 57 56 55 59 60 58 63 62 61 64 66 65 67 68 69 70 71 72
## [73] 75 73 74 77 76 78 80 79 81 82 84 83 85 86 87 90 89 88
## [91] 92 91 93 96 94 95 98 99 97 100
</code></pre>

blocks|key|2418914|text|一般解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2418915|编辑:正如@MatthewLundberg评论的那样，我指出的“在x中重复数字”的问题可以通过使用seq_along(x)轻松克服，这意味着结果值将是索引。所以，它应该是这样的：|offset|length|style|CODE|2418916|k+<-+3
x+<-+c(2,2,1,+1,3,4,+4,6,5,+3)
x.s+<-+seq_along(x)
y+<-+sample(x.s)
x[unlist(split(y,+(match(y,+x.s)-1)+%25/%25+k),+use.names+=+FALSE)]
#+[1]+2+2+1+3+4+1+4+5+6+3|code-block|syntax|javascript|2418917|2418918|老生常谈：|2418919|这里的瓶颈是对函数sample的调用量。只要您的数字不重复，我认为您只需以这种方式调用一次sample就可以做到这一点：|2418920|k+<-+3
x+<-+1:20
y+<-+sample(x)
unlist(split(y,+(match(y,x)-1)+%25/%25+k),+use.names+=+FALSE)
#+[1]++1++3++2++5++6++4++8++9++7+12+10+11+13+14+15+17+16+18+19+20|2418921|2418922|将所有内容放在一个函数中(我喜欢@Roland‘s中的名称scramble+)：|2418923|scramble+<-+function(x,+k=3)+{
++++x.s+<-+seq_along(x)
++++y.s+<-+sample(x.s)
++++idx+<-+unlist(split(y.s,+(match(y.s,+x.s)-1)+%25/%25+k),+use.names+=+FALSE)
++++x[idx]
}

scramble(x,+3)
#+[1]+2+1+2+3+4+1+5+4+6+3
scramble(x,+3)
#+[1]+1+2+2+1+4+3+6+5+4+3|2418924|2418925|要进一步简化答案(并更快地获得答案)，请关注@flodel的评论：|2418926|scramble+<-+function(x,+k=3L)+{
++++x.s+<-+seq_along(x)
++++y.s+<-+sample(x.s)
++++x[unlist(split(x.s[y.s],+(y.s-1)+%25/%25+k),+use.names+=+FALSE)]
}|2418927|entityMap^0|0|1D|C|0|0|0|0|9|6|19|6|0|0|0|T|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@$D|17|E|18|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1C|8|@$D|1D|E|1E|F|G]|$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|R|3|S|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|T|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|Y|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1O|8|@]|9|@]|A|$]]|$1|11|3|12|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|13|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|14|$]]

<h3>General solution:</h3>

Edit: As @MatthewLundberg comments, the issue I pointed out with "repeating numbers in x" can be easily overcome by working on <code>seq_along(x)</code>, which would mean the resulting values will be indices. So, it'd be like so:

<pre><code>k &lt;- 3
x &lt;- c(2,2,1, 1,3,4, 4,6,5, 3)
x.s &lt;- seq_along(x)
y &lt;- sample(x.s)
x[unlist(split(y, (match(y, x.s)-1) %/% k), use.names = FALSE)]
# [1] 2 2 1 3 4 1 4 5 6 3
</code></pre>

<hr>

<h3>Old answer:</h3>

The bottleneck here is the amount of calls to function <code>sample</code>. And as long as your numbers don't repeat, I think you can do this with just one call to <code>sample</code> in this manner:

<pre><code>k &lt;- 3
x &lt;- 1:20
y &lt;- sample(x)
unlist(split(y, (match(y,x)-1) %/% k), use.names = FALSE)
# [1] 1 3 2 5 6 4 8 9 7 12 10 11 13 14 15 17 16 18 19 20
</code></pre>

<hr>

To put everything together in a function (I like the name <code>scramble</code> from @Roland's):

<pre><code>scramble &lt;- function(x, k=3) {
 x.s &lt;- seq_along(x)
 y.s &lt;- sample(x.s)
 idx &lt;- unlist(split(y.s, (match(y.s, x.s)-1) %/% k), use.names = FALSE)
 x[idx]
}

scramble(x, 3)
# [1] 2 1 2 3 4 1 5 4 6 3
scramble(x, 3)
# [1] 1 2 2 1 4 3 6 5 4 3
</code></pre>

<hr>

To reduce the answer (and get it faster) even more, following @flodel's comment:

<pre><code>scramble &lt;- function(x, k=3L) {
 x.s &lt;- seq_along(x)
 y.s &lt;- sample(x.s)
 x[unlist(split(x.s[y.s], (y.s-1) %/% k), use.names = FALSE)]
}
</code></pre>

blocks|key|2031496|text|v+<-+1:16

scramble+<-+function(vec,n)+{
++res+<-+tapply(vec,(seq_along(vec)%2Bn-1)%25/%25n,
++++++++++++++++FUN=function(x)+x[sample.int(length(x),+size=length(x))])
++unname(unlist(res))
}

set.seed(42)
scramble(v,3)
#[1]++3++2++1++6++5++4++9++7++8+12+10+11+15+13+14+16

scramble(v,4)
#[1]++2++3++1++4++5++8++6++7+10+12++9+11+14+15+16+13|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2031497|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>v &lt;- 1:16

scramble &lt;- function(vec,n) {
 res &lt;- tapply(vec,(seq_along(vec)+n-1)%/%n,
 FUN=function(x) x[sample.int(length(x), size=length(x))])
 unname(unlist(res))
}

set.seed(42)
scramble(v,3)
#[1] 3 2 1 6 5 4 9 7 8 12 10 11 15 13 14 16

scramble(v,4)
#[1] 2 3 1 4 5 8 6 7 10 12 9 11 14 15 16 13
</code></pre>

blocks|key|890417|text|根据记录，boot软件包(随base+R一起提供)包含一个仅用于此目的的函数permutation.array()：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|890418|x+<-+1:100
k+<-+3
ii+<-+boot:::permutation.array(n+=+length(x),+
+++++++++++++++++++++++++++++++R+=+2,+
+++++++++++++++++++++++++++++++strata+=+(seq_along(x)+-+1)+%25/%25+k)[1,]
x[ii]
#+++[1]+++2+++1+++3+++6+++5+++4+++9+++7+++8++12++11++10++15++13++14++16++18++17
#++[19]++21++19++20++23++22++24++26++27++25++28++29++30++33++31++32++36++35++34
#++[37]++38++39++37++41++40++42++43++44++45++46++47++48++51++50++49++53++52++54
#++[55]++57++55++56++59++60++58++63++61++62++65++66++64++67++69++68++72++71++70
#++[73]++75++73++74++76++77++78++79++80++81++82++83++84++86++87++85++89++88++90
#++[91]++93++91++92++94++95++96++97++98++99+100|code-block|syntax|javascript|890419|entityMap^0|5|4|12|J|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|S|8|@]|E|@]|F|$J|K]]|$1|L|3|-4|5|6|7|T|8|@]|E|@]|F|$]]]|M|$]]

For the record, the boot package (shipped with base R) includes a function <code>permutation.array()</code> that is used for just this purpose:

<pre><code>x &lt;- 1:100
k &lt;- 3
ii &lt;- boot:::permutation.array(n = length(x), 
 R = 2, 
 strata = (seq_along(x) - 1) %/% k)[1,]
x[ii]
# [1] 2 1 3 6 5 4 9 7 8 12 11 10 15 13 14 16 18 17
# [19] 21 19 20 23 22 24 26 27 25 28 29 30 33 31 32 36 35 34
# [37] 38 39 37 41 40 42 43 44 45 46 47 48 51 50 49 53 52 54
# [55] 57 55 56 59 60 58 63 61 62 65 66 64 67 69 68 72 71 70
# [73] 75 73 74 76 77 78 79 80 81 82 83 84 86 87 85 89 88 90
# [91] 93 91 92 94 95 96 97 98 99 100
</code></pre>

blocks|key|2031525|text|Arun不喜欢我的另一个答案是多么的低效，所以这里有一些非常快的东西给他。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031526|它只需要分别调用runif()和order()一次，而且根本不使用sample()。|offset|length|style|CODE|2031527|x+<-+1:100
k+<-+3
n+<-+length(x)

x[order(rep(seq_len(ceiling(n/k)),+each=k,+length.out=n)+%2B+runif(n))]
#++[1]+++3+++1+++2+++6+++5+++4+++8+++9+++7++11++12++10++13++14++15++18++16++17
#+[19]++20++19++21++23++22++24++27++25++26++29++28++30++33++31++32++36++34++35
#+[37]++37++38++39++40++41++42++43++44++45++47++48++46++51++49++50++52++54++53
#+[55]++55++57++56++58++60++59++62++63++61++66++64++65++68++67++69++71++70++72
#+[73]++75++74++73++76++77++78++81++80++79++84++82++83++86++85++87++89++88++90
#+[91]++93++92++91++94++96++95++97++98++99+100|code-block|syntax|javascript|2031528|entityMap^0|0|8|7|G|7|X|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

Arun didn't like how inefficient my other answer was, so here's something very fast just for him ;) 

It requires just one call each to <code>runif()</code> and <code>order()</code>, and doesn't use <code>sample()</code> at all.

<pre><code>x &lt;- 1:100
k &lt;- 3
n &lt;- length(x)

x[order(rep(seq_len(ceiling(n/k)), each=k, length.out=n) + runif(n))]
# [1] 3 1 2 6 5 4 8 9 7 11 12 10 13 14 15 18 16 17
# [19] 20 19 21 23 22 24 27 25 26 29 28 30 33 31 32 36 34 35
# [37] 37 38 39 40 41 42 43 44 45 47 48 46 51 49 50 52 54 53
# [55] 55 57 56 58 60 59 62 63 61 66 64 65 68 67 69 71 70 72
# [73] 75 74 73 76 77 78 81 80 79 84 82 83 86 85 87 89 88 90
# [91] 93 92 91 94 96 95 97 98 99 100
</code></pre>

I have the following vector in R. Think of them as a vector of numbers.

<pre><code>x = c(1,2,3,4,...100)
</code></pre>

I want to randomize this vector "locally" based on some input number the "locality factor". For example if the locality factor is 3, then the first 3 elements are taken and randomized followed by the next 3 elements and so on. Is there an efficient way to do this? I know if I use sample, it would jumble up the whole array.
Thanks in advance

In R, how do I locally shuffle a vector's elements

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在R中有下面的向量，把它们想象成一个数字的向量。x = c(1,2,3,4,...100)我想根据一些输入数字“局部性因子”来“局部”地随机化这个向量。例如，如果位置因子是3，则取前3个元素并随机化，然后是接下来的3个元素，依此类推。有没有一种有效的方法来做到这一点？我知道如果我使用sample，它会使整个数组变得混...

问在R中，我如何局部地混洗向量的元素
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在R中，我如何局部地混洗向量的元素EN