blocks|key|2448323|text|这是一个在大型测试用例上比OP的解决方案更快的基于25x的解决方案。它不依赖于paste，而是我们利用了数字的属性和矢量化操作。我们还使用RcppAlgos包(我是作者)中的comboGeneral，它比链接答案中的combn和combnPrim在生成向量组合方面要快得多。首先，我们展示了comboGeneral相对于其他函数的效率提升：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2448324|##+library(gRbase)
library(RcppAlgos)
library(microbenchmark)

microbenchmark(gRbase::combnPrim(300,+2),+combn(300,+2),+
+++++++++++++++comboGeneral(300,+2),+unit+=+"relative")
Unit:+relative
+++++++++++++++++++++expr++++++++min+++++++++lq++++++mean+++++median+++++++++uq+++++++max+neval
gRbase::combnPrim(300,+2)+++5.145654+++5.192439+++4.83561+++7.167839+++4.320497+++3.98992+++100
++++++++++++combn(300,+2)+204.866624+192.559119+143.75540+174.079339+102.733367+539.12325+++100
+++++comboGeneral(300,+2)+++1.000000+++1.000000+++1.00000+++1.000000+++1.000000+++1.00000+++100|code-block|syntax|javascript|2448325|现在，我们创建一个函数来创建一些随机可重现的数据，这些数据将传递给我们的测试函数：|2448326|makeTestSet+<-+function(vectorSize,+elementSize,+mySeed+=+42,+withRep+=+FALSE)+{
++++set.seed(mySeed)
++++sapply(1:vectorSize,+function(x)+{
++++++++paste(sample(10%5E6,+s1+<-+sample(2:elementSize,+1),+replace+=+withRep),+collapse+=+"+")
++++})
}

makeTestSet(5,+3)
[1]+"937076+286140+830446"+"519096+736588+134667"+"705065+457742+719111"+
[4]+"255429+462293+940013"+"117488+474997+560332"|2448327|看起来不错。现在，让我们看看设置fixed+=+TRUE是否会给我们带来任何好处(正如上面@MichaelChirico建议的那样)：|2448328|bigVec+<-+makeTestSet(10,+100000)

microbenchmark(standard+=+strsplit(bigVec,+"+"),+
+++++++++++++++withFixed+=+strsplit(bigVec,+"+",+fixed+=+TRUE),+
+++++++++++++++times+=+15,+unit+=+"relative")
Unit:+relative
+++++expr++++++min+++++++lq+++++mean+++median+++++++uq++++++max+neval
+standard+4.447413+4.296662+4.133797+4.339537+4.084019+3.415639++++15
withFixed+1.000000+1.000000+1.000000+1.000000+1.000000+1.000000++++15|2448329|@MichaelChirico说得很对。把所有这些放在一起，我们得到：|2448330|combPairFast+<-+function(testVec)+{
++++lapply(strsplit(testVec,+"+",+fixed+=+TRUE),+function(x)+{
++++++++combs+<-+RcppAlgos::comboGeneral(as.numeric(x),+2)
++++++++unique(combs[,1]+*+(10)%5E(as.integer(log10(combs[,2]))+%2B+1L)+%2B+combs[,2])
++++})
}

##+test.vector+defined+above+by+OP
combPairFast(test.vector)
[[1]]
[1]+335261344015+335261537633+344015537633

[[2]]
[1]+22404132858

[[3]]
[1]+254654355860+254654488288+355860488288

[[4]]
[1]+219943373817

[[5]]
[1]+331839404477

##+OP+original+code
combPairOP+<-+function(testVec)+{
++++lapply(strsplit(testVec,+"+"),+function(x)+unique(apply(combn(x,+2),+2,+function(y)+paste0(y,+collapse+=+""))))
}|2448331|正如OP的注释中所述，最大数字小于一百万(准确地说是600000)，这意味着我们将其中一个数字乘以最多10%5E6，并将其与另一个6位数字相加(相当于简单地连接两个数字字符串)，我们可以保证在基数R的数值精度(即2%5E53+-+1)之内。这很好，因为数字上的算术运算比字符串运算效率高得多。|2448332|剩下的就是基准测试了：|2448333|test.vector+<-+makeTestSet(100,+50)

microbenchmark(combPairOP(test.vector),+
+++++++++++++++combPairFast(test.vector),
+++++++++++++++times+=+20,+unit+=+"relative")
Unit:+relative
+++++++++++++++++++++expr++++++min++++++lq+++++mean+++median+++++uq++++++max+neval
++combPairOP(test.vector)+22.33991+22.4264+21.67291+22.11017+21.729+25.23342++++20
combPairFast(test.vector)++1.00000++1.0000++1.00000++1.00000++1.000++1.00000++++20|2448334|在更大的向量上：|2448335|bigTest.vector+<-+makeTestSet(1000,+100,+mySeed+=+22,+withRep+=+TRUE)

##+Duplicate+values+exist
any(sapply(strsplit(bigTest.vector,+"+",+fixed+=+TRUE),+function(x)+{
++++any(duplicated(x))
}))
[1]+TRUE

system.time(t1+<-+combPairFast(bigTest.vector))
+user++system+elapsed+
0.303+++0.011+++0.314+

system.time(t2+<-+combPairOP(bigTest.vector))
+user++system+elapsed+
8.820+++0.081+++8.902++++###+8.902+/+0.314+~=+28x+faster

##+results+are+the+same
all.equal(t1,+lapply(t2,+as.numeric))
[1]+TRUE|2448336|entityMap^0|P|3|13|5|1X|9|2F|C|30|5|36|9|41|C|0|0|0|0|G|C|0|0|0|0|2W|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1O|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1U|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1V|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|21|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|16|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|17|$]]

Here is an answer that is over <code>25x</code> faster than the OP's solution on large test cases. It doesn't rely on <code>paste</code>, but rather we take advantage of properties of numbers and vectorized operations. We also use <code>comboGeneral</code> from the <code>RcppAlgos</code> package (I am the author) which is much faster than <code>combn</code> and <code>combnPrim</code> from the linked answer for generating combinations of a vector. First we show the efficiency gains of <code>comboGeneral</code> over the other functions:

<pre><code>## library(gRbase)
library(RcppAlgos)
library(microbenchmark)

microbenchmark(gRbase::combnPrim(300, 2), combn(300, 2), 
 comboGeneral(300, 2), unit = "relative")
Unit: relative
 expr min lq mean median uq max neval
gRbase::combnPrim(300, 2) 5.145654 5.192439 4.83561 7.167839 4.320497 3.98992 100
 combn(300, 2) 204.866624 192.559119 143.75540 174.079339 102.733367 539.12325 100
 comboGeneral(300, 2) 1.000000 1.000000 1.00000 1.000000 1.000000 1.00000 100
</code></pre>

Now, we create a function to create some random reproducible data that will be passed to our test functions:

<pre><code>makeTestSet &lt;- function(vectorSize, elementSize, mySeed = 42, withRep = FALSE) {
 set.seed(mySeed)
 sapply(1:vectorSize, function(x) {
 paste(sample(10^6, s1 &lt;- sample(2:elementSize, 1), replace = withRep), collapse = " ")
 })
}

makeTestSet(5, 3)
[1] "937076 286140 830446" "519096 736588 134667" "705065 457742 719111" 
[4] "255429 462293 940013" "117488 474997 560332"
</code></pre>

That looks good. Now, lets see if setting <code>fixed = TRUE</code> gets us any gains (as suggested above by @MichaelChirico):

<pre><code>bigVec &lt;- makeTestSet(10, 100000)

microbenchmark(standard = strsplit(bigVec, " "), 
 withFixed = strsplit(bigVec, " ", fixed = TRUE), 
 times = 15, unit = "relative")
Unit: relative
 expr min lq mean median uq max neval
 standard 4.447413 4.296662 4.133797 4.339537 4.084019 3.415639 15
withFixed 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 15
</code></pre>

@MichaelChirico was spot on. Putting it all together we get:

<pre><code>combPairFast &lt;- function(testVec) {
 lapply(strsplit(testVec, " ", fixed = TRUE), function(x) {
 combs &lt;- RcppAlgos::comboGeneral(as.numeric(x), 2)
 unique(combs[,1] * (10)^(as.integer(log10(combs[,2])) + 1L) + combs[,2])
 })
}

## test.vector defined above by OP
combPairFast(test.vector)
[[1]]
[1] 335261344015 335261537633 344015537633

[[2]]
[1] 22404132858

[[3]]
[1] 254654355860 254654488288 355860488288

[[4]]
[1] 219943373817

[[5]]
[1] 331839404477

## OP original code
combPairOP &lt;- function(testVec) {
 lapply(strsplit(testVec, " "), function(x) unique(apply(combn(x, 2), 2, function(y) paste0(y, collapse = ""))))
}
</code></pre>

As stated in the comments by the OP, the maximum number is less than a million (600000 to be exact), which means that after we multiply one of the numbers by at most 10^6 and add it to another 6 digit number (equivalent to simply concatenating two strings of numbers), we are guaranteed to be within the numerical precision of base R (i.e. <code>2^53 - 1</code>). This is good because arithmetic operations on numerical numbers is much more efficient than strings operations.

All that is left is to benchmark:

<pre><code>test.vector &lt;- makeTestSet(100, 50)

microbenchmark(combPairOP(test.vector), 
 combPairFast(test.vector),
 times = 20, unit = "relative")
Unit: relative
 expr min lq mean median uq max neval
 combPairOP(test.vector) 22.33991 22.4264 21.67291 22.11017 21.729 25.23342 20
combPairFast(test.vector) 1.00000 1.0000 1.00000 1.00000 1.000 1.00000 20
</code></pre>

And on larger vectors:

<pre><code>bigTest.vector &lt;- makeTestSet(1000, 100, mySeed = 22, withRep = TRUE)

## Duplicate values exist
any(sapply(strsplit(bigTest.vector, " ", fixed = TRUE), function(x) {
 any(duplicated(x))
}))
[1] TRUE

system.time(t1 &lt;- combPairFast(bigTest.vector))
 user system elapsed 
0.303 0.011 0.314 

system.time(t2 &lt;- combPairOP(bigTest.vector))
 user system elapsed 
8.820 0.081 8.902 ### 8.902 / 0.314 ~= 28x faster

## results are the same
all.equal(t1, lapply(t2, as.numeric))
[1] TRUE
</code></pre>

I wonder if someone can figure out a faster way to calculate combinations of elements in vector. My approach works but is slow with about 6 million elements in the vector.

Test vector

<pre><code>test.vector &lt;- c("335261 344015 537633","22404 132858","254654 355860 488288","219943 373817","331839 404477")
</code></pre>

My approach

<pre><code>lapply(strsplit(test.vector, " "), function(x) unique(apply(combn(x, 2), 2, function(y) paste0(y, collapse = ""))))
</code></pre>

Expected output

<pre><code>[[1]]
[1] "335261344015" "335261537633" "344015537633"

[[2]]
[1] "22404132858"

[[3]]
[1] "254654355860" "254654488288" "355860488288"

[[4]]
[1] "219943373817"

[[5]]
[1] "331839404477"
</code></pre>

Optimizing calculation of combinations into list - large data set

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想知道是否有人能想出一种更快的方法来计算向量中元素的组合。我的方法有效，但在向量中有大约600万个元素，速度很慢。测试向量test.vector <- c("335261 344015 537633","22404 132858","254654 355860 488288","219943 373817","331...

组合到列表大数据集中的优化计算-腾讯云开发者社区-腾讯云

问组合到列表大数据集中的优化计算
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问组合到列表大数据集中的优化计算EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问组合到列表大数据集中的优化计算
EN