blocks|key|2024181|text|a+=+[1,+2,+3]
b+=+[2,+3,+4]
a+%2B+b+-+(a+&+b)
#+=>+[1,+4]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2024182|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|$]]

blocks|key|3105019|text|正如@iamnotmaynard在注释中所指出的，这传统上是一种集合操作(称为对称差异)。Ruby的Set类包含了这个操作，因此表达它的最惯用的方法是使用Set：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3105020|Set.new(a)+%5E+b|code-block|syntax|javascript|3105021|这应该会给O(n)性能(因为集合成员资格测试是常数时间)。|3105022|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As @iamnotmaynard noted in the comments, this is traditionally a set operation (called the symmetric difference). Ruby's Set class includes this operation, so the most idiomatic way to express it would be with a Set:

<pre><code>Set.new(a) ^ b
</code></pre>

That should give O(n) performance (since a set membership test is constant-time).

blocks|key|3105104|text|最简单的解决方案(就只使用已经存在的数组和库存数组方法而言)是友联市+of+差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3105105|a+=+[1,2,3,4]
b+=+[1,2,4]
(a-b)+%7C+(b-a)
=>+[3]|code-block|syntax|javascript|3105106|这可能比O(n**2)更好，也可能不会更好。还有其他选项可能会提供更好的绩效(见其他答案/评论)。|style|CODE|3105107|编辑:下面是排序和迭代方法的一个快速实现(这假设数组没有重复的元素，否则它将需要修改，这取决于在这种情况下需要什么样的行为)。如果有人能想出更短的方法来做这件事，我会感兴趣的。限制因素是所使用的类型。我假设Ruby使用某种快速排序，因此复杂度平均为O(n+log+n)，可能是O(n**2)的最坏情况；如果数组已经排序，那么当然可以删除对sort的两个调用，并在O(n)中运行。|3105108|def+diff+a,+b
++a+=+a.sort
++b+=+b.sort
++result+=+[]
++bi+=+0
++ai+=+0
++while+(ai+<+a.size+&&+bi+<+b.size)
++++if+a[ai]+==+b[bi]
++++++ai+%2B=+1
++++++bi+%2B=+1
++++elsif+a[ai]<b[bi]
++++++result+<<+a[ai]
++++++ai+%2B=+1
++++else
++++++result+<<+b[bi]
++++++bi+%2B=+1
++++end
++end
++result+%2B=+a[ai,+a.size-ai]+if+ai<a.size
++result+%2B=+b[bi,+b.size-bi]+if+bi<b.size
++result
end|3105109|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-7C|1|http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-2D^0|V|3|0|12|2|1|0|0|4|7|0|3G|A|3U|7|4P|4|51|4|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|18|8|@$A|19|B|1A|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1B|8|@$A|1C|B|1D|K|L]|$A|1E|B|1F|K|L]|$A|1G|B|1H|K|L]|$A|1I|B|1J|K|L]]|9|@]|C|$]]|$1|O|3|P|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

The simplest (in terms of using only the arrays already in place and stock array methods, anyway) solution is the <a href="http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-7C" rel="noreferrer">union</a> of the <a href="http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-2D" rel="noreferrer">differences</a>:

<pre><code>a = [1,2,3,4]
b = [1,2,4]
(a-b) | (b-a)
=&gt; [3]
</code></pre>

This may or may not be better than <code>O(n**2)</code>. There are other options which are likely to give better peformance (see other answers/comments).

Edit: Here's a quick-ish implementation of the sort-and-iterate approach (this assumes no array has repeated elements; otherwise it will need to be modified depending on what behavior is wanted in that case). If anyone can come up with a shorter way to do it, I'd be interested. The limiting factor is the sort used. I assume Ruby uses some sort of Quicksort, so complexity averages <code>O(n log n)</code> with possible worst-case of <code>O(n**2)</code>; if the arrays are already sorted, then of course the two calls to <code>sort</code> can be removed and it will run in <code>O(n)</code>.

<pre><code>def diff a, b
 a = a.sort
 b = b.sort
 result = []
 bi = 0
 ai = 0
 while (ai &lt; a.size &amp;&amp; bi &lt; b.size)
 if a[ai] == b[bi]
 ai += 1
 bi += 1
 elsif a[ai]&lt;b[bi]
 result &lt;&lt; a[ai]
 ai += 1
 else
 result &lt;&lt; b[bi]
 bi += 1
 end
 end
 result += a[ai, a.size-ai] if ai&lt;a.size
 result += b[bi, b.size-bi] if bi&lt;b.size
 result
end
</code></pre>

blocks|key|2024416|text|数组分歧的解决方案类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2024417|a+=+[1,+2,+3]
b+=+[2,+3,+4]
(a+-+b)+%7C+(b+-+a)
#+=>+[1,+4]|code-block|syntax|javascript|2024418|你也可以阅读我关于阵列相干的博客文章。|offset|length|2024419|entityMap|0|LINK|mutability|MUTABLE|url|http://www.chrisrolle.com/en/blog/array-coherences^0|0|0|9|4|0|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|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The solution for Array divergences is like:

<pre><code>a = [1, 2, 3]
b = [2, 3, 4]
(a - b) | (b - a)
# =&gt; [1, 4]
</code></pre>

You can also read my blog post about <a href="http://www.chrisrolle.com/en/blog/array-coherences" rel="nofollow noreferrer">Array coherences</a>

I've been thinking about a following problem - there are two arrays, and I need to find elements not common for them both, for example:

<pre><code>a = [1,2,3,4]
b = [1,2,4]
</code></pre>

And the expected answer is <code>[3]</code>.

So far I've been doing it like this:

<pre><code>a.select { |elem| !b.include?(elem) }
</code></pre>

But it gives me <code>O(N ** 2)</code> time complexity. I'm sure it can be done faster ;)

Also, I've been thinking about getting it somehow like this (using some method opposite to <code>&amp;</code> which gives common elements of 2 arrays):

<pre><code>a !&amp; b #=&gt; doesn't work of course
</code></pre>

Another way might be to add two arrays and find the unique element with some method similar to <code>uniq</code>, so that:

<pre><code>[1,1,2,2,3,4,4].some_method #=&gt; would return 3
</code></pre>

Ruby - Find element not in common for two arrays

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我一直在考虑下面的一个问题--有两个数组，我需要找到它们都不常见的元素，例如：a = [1,2,3,4]b = [1,2,4]预期的答案是[3]。到目前为止我一直是这样做的：a.select { |elem| !b.include?(elem) }但它给了我O(N ** 2)的时间复杂性。我相信可以做得更快;)另外，我...

问Ruby -查找两个数组中不相同的元素
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby -查找两个数组中不相同的元素EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby -查找两个数组中不相同的元素
EN